Friday, July 30, 2010

[Gd] Wave Visualizer: Turning Threads into Trees

| More

Google Wave Developer Blog: Wave Visualizer: Turning Threads into Trees

Two years ago, I discovered the JavaScript InfoVis Toolkit, a really cool library for doing visualizations in Javascript, like force-directed graphs, hypertree, treemaps, sunbursts, and more. Since then, I've been looking for an excuse to use the library in conjunction with a Google API, and after our latest API release, I found the perfect use.



A few weeks ago, we released a new feature in the data and robot APIs: threads. This feature means that developers can render threaded waves in alternative clients and export waves to other formats while retaining their true structure. It also means that I can finally use the InfoVis Toolkit, in order to visualize the threads in a wave as a structured tree.



To create the visualization, I started with the code for the Inbox Checker sample, a Python App Engine app that asks a user to authenticate (via OAuth), and then shows them their inbox and any wave they click on. I modified that app to output JSON instead of HTML for each wave, and I piped that JSON into the SpaceTree class from the toolkit.



Here's an side-by-side example of how a wave might look like in the client, and what it looks like as a SpaceTree:








You can try the app out for yourself here: Wave Visualizer. After granting access to the app, you can click each of the waves in your inbox and browse the tree for it. As you mouse over each blip, you'll see a snippet of the content of the blip in the tooltip. When you click on a blip, you'll be taken to that exact blip in the Wave client, utilizing our other new feature: blip linking.
(You can also try out the "Timeline" view, which shows the sequence of blips over time, using the Google Visualization API).



This app shows off one of my favorite features of Wave - flexibly structured conversations. Some waves are very flat long trees, and others are wide and deeply nested, and they are all made possible by the Wave conversation model. And now, thanks to the new Wave data APIs, apps like this are possible.



Enjoy playing around with the visualizer, and if you have any questions about building apps like it, stop by the Wave API forum and let us know!





Posted by Pamela Fox, Developer Relations
URL: http://googlewavedev.blogspot.com/2010/07/wave-visualizer-turning-trees-into.html

[Gd] Dev Channel Update

| More

Google Chrome Releases: Dev Channel Update

The Dev channel has been updated to 6.0.472.14 for All Platforms.

All
  • UI tweaks and clean up
  • Additional stability fixes
Linux
Mac

More details about additional changes are available in the svn log of all revisions.

You can find out about getting on the Dev channel here: http://dev.chromium.org/getting-involved/dev-channel.

If you find new issues, please let us know by filing a bug at http://code.google.com/p/chromium/issues/entry.

Jason Kersey
Google Chrome
URL: http://googlechromereleases.blogspot.com/2010/07/dev-channel-update_30.html

Thursday, July 29, 2010

[Gd] Wave UI: Making your gadgets look & feel Wave-y

| More

Google Wave Developer Blog: Wave UI: Making your gadgets look & feel Wave-y

As part of my Google I/O talk on "Anatomy of a Great Extension", I talked about the optimal look & feel for Wave gadgets. On one hand, if your Wave gadget is based off an existing website, like the 6Rounds gadget, then we recommend mimicing the UI of your website inside the gadget, so that your existing users feel like they're using an extension of your website into Wave. On the other hand, if your Wave gadget is independent and designed purely for Wave, like many extensions in the gallery, then we suggest mimicing the UI of the Google Wave client itself, so that users feel like the gadgets fit inside their environment, and so that waves with multiple independent gadgets look cohesive. To make that easier for developers, we've introduced a new feature to the Wave Gadgets API, the wave.ui library, which makes it easy to turn your gadget elements into wave-styled elements.



For example, you might start with an anchor with some javascript onclick behavior:


<a id="button" href="javascript:void(0)" onclick="doIt()">Do Cool Stuff!</a>



You can then call makeButton and pass in the anchor element:


<script>
wave.ui.makeButton(document.getElementById("button"));
</script>



And, presto, your button will be wave-styled like this:







The wave.ui library also offers the loadCss, makeDialog, and makeFrame methods, and will expand to include additional methods as needed by developers.



For examples of gadgets using the new wave.ui library, check out the Flammard bible bot, which uses makeFrame for a multi-tabbed interface, or the Google Maps gadget, which uses makeDialog for a welcome screen and makeButton for the info window buttons.



As usual, please let us know in the forum how you're using this feature and if you have any questions.



Enjoy wave-styling!




Posted by Pamela Fox, Developer Relations
URL: http://googlewavedev.blogspot.com/2010/07/wave-ui-making-your-gadgets-look-feel.html

[Gd] Building SaaSy Voice, a test application for the Apps Marketplace

| More

Google Apps Developer Blog: Building SaaSy Voice, a test application for the Apps Marketplace

As we build out a new platform and APIs for developers, we find it helpful to create our own applications to try it out. It helps us validate and influence the design based on direct experience using the APIs. In the case of the Google Apps Marketplace, we needed a real application to integrate with Google Apps. We decided to build SaaSy Voice -- a web-application for handling the phone system for small and medium businesses. For the call features we used Twilio, a cloud based voice communications provider.

Why did we decide to build SaaSy Voice? Voice applications are fun and allowed us to experiment not only with our APIs, but with Twilio’s voice APIs. Learning new APIs and creatively mashing them up with Google technologies is one of the many reasons we love our jobs in Developer Relations.

The first step in launching our application on the Google Apps Marketplace was to build the core business logic. This was simple. We wanted to allow companies to buy a new phone number for their business, assign extensions to their employees, and allow for voicemail or call forwarding to existing numbers. We wanted simple management functionality for administrators to manage extensions and view call activity for their company. In just a few days we built the core application in PHP with a MySQL database and spiced up the design a bit by using free CSS templates.

The next, and very important step, for our application was to integrate with Google Apps. We started with single sign-on integration using OpenID. Allowing users to quickly access their voicemail using their existing Google Apps account is a great user experience and a common feature of apps in the Google Apps Marketplace. We used Janrain’s PHP OpenID library with the Google Apps discovery extensions to integrate OpenID very quickly.

Our integration with Google Apps wasn’t complete with just single sign-on though, as we were aware that many other integrations with Google Apps could improve application provisioning for administrators and day-to-day effectiveness for end-users.

Here was our initial list of most helpful integrations:

Make the signup process easier. Instead of manually entering employee information by hand or implementing a cumbersome bulk import process, the application simply connects to Google Apps and automatically retrieves the list of users in the domain. Administrators can easily choose which of their users to assign extensions to. (Provisioning API)

Integrate with a user’s existing contact data to allow employees to see who called them. Showing rich contact information inline with voice mails makes it easier to reply to messages by phone or e-mail. (Contacts API)

Export voicemail logs and analyze them in a form business users are comfortable with: the spreadsheet. The application automatically creates spreadsheets in Google Docs where logs can be easily filtered, sorted and visualized. (Documents List API)


Integrate voicemail activity into Gmail. Business users often spend much of their day in their e-mail inbox. Instead of requiring users to open a new window to review voicemails, the gadget integrates a simple list view of recent voicemails and allows them to play messages without leaving their e-mail. (Gmail Sidebar Gadgets)


Integrating with a business’ contacts, docs, e-mail and company directory makes the application much easier for both administrators and employees, saving valuable time. Of course, there are plenty of other ways to improve the efficiency of SaaSy Voice users that we have yet to develop.

To name a few:
  • E-mail voicemail messages to users as they arrive. Using Gmail Contextual Gadgets, we can embed a voicemail player right below the e-mail to allow a user to listen to their message right away.
  • Create a Gmail Contextual Gadget that gives a one-click option for calling the user who e-mailed you. When you click the ‘call’ button, the sender is called on their phone number stored in the user contacts and you’re connected immediately using your company phone number.
Since SaaSy Voice provisions a new phone number for each company using the service, it costs money. We don’t want to go poor when lots of anxious developers try it out and also don’t want to start a new business right now, so it’s not currently published in the Apps Marketplace. However, there’s an application similar to SaaSy Voice which recently launched in the Apps Marketplace. It’s called Ginza Phone and their developers have thought of a few other great Google Apps integrations like using the Google Calendar API to look up a user’s free/busy schedule to determine how to best route calls.

These are just a few of examples of how integration can improve the productivity of users, and the possibilities are endless. We’ve heard from customers and vendors alike that Google Apps users love integrated applications. We look forward to hearing about the great integrations you build -- let us know what you’re doing via Tweeting/Buzzing with #AppsIntegrations.

You can learn more about how we built SaaSy Voice, you may wish to watch our Google I/O session on Integrating your app with the Google Apps Marketplace.

Posted by Ryan Boyd and Steve Bazyl, Google Apps Marketplace Team
URL: http://googleappsdeveloper.blogspot.com/2010/07/building-saasy-voice-test-application.html

Wednesday, July 28, 2010

[Gd] App Engine and IPv6, Round 2

| More

Google App Engine Blog: App Engine and IPv6, Round 2

Back in March, we announced that all App Engine apps hosted on appspot.com would be reachable over IPv6, from ISPs enrolled in the Google over IPv6 program.



Today, we're adding the same service to all domains hosted by ghs.google.com. If your App Engine app runs on your own domain name using Google Apps, then be sure to review our earlier blog post, which discusses the caveats of parsing client IP addresses, and how to use the SixXS Gateway to test your site over IPv6.



Currently, the Google over IPv6 program presents AAAA records only to ISPs within our whitelist. This helps ensure that our services remain reliable, by reducing exposure to clients with broken IPv6 connectivity. As the maturity of IPv6 deployment improves, we expect this whitelist to grow, eventually disappearing as it encompasses the entire Internet.



That said, we know that some of you are fans of IPv6 who would prefer to skip the whitelist, and offer dual-stack service to everyone immediately. To make your domain bypass the whitelist, just change your CNAME pointer from ghs.google.com to ghs46.google.com. Please note that, while ghs46 will cause your App Engine site to receive a larger fraction of its traffic over IPv6, our studies show that it may make your site slow or unreachable for up to 0.1% of clients across the Internet, so use this alternate domain with care.



As before, if you experience any problems with IPv6 serving and App Engine, please report it in the App Engine issue tracker or post about it in the App Engine discussion group.




Posted by Paul + the App Engine Traffic Team

URL: http://googleappengine.blogspot.com/2010/07/app-engine-and-ipv6-round-2.html

[Gd] New Google Font Previewer - Webfonts Easier and More Fun

| More

Google Code Blog: New Google Font Previewer - Webfonts Easier and More Fun

We’re very proud to tell you that we’ve just launched a new feature for the Google font directory. The new Google font previewer lets you test drive all the fonts in the directory so you can decide which web font in the Google Font API works best for your requirements.

Now, whenever you visit the font family page of any of the fonts, you will see a link saying “Preview this font” that will load your font selection into the font previewer.

Here you can edit the text, change its size and line height, and add decorations and spacing among other things. You can even apply text shadow to your text.

The previewer will generate the corresponding code for you so all you have to do to start using the font on your own website is to copy and paste the stylesheet link and the CSS into your pages. In the example above this would be:

<link href="http://fonts.googleapis.com/css?family=Lobster:regular"
rel="stylesheet" type="text/css" >
<style> body {
font-family: 'Lobster', serif;
font-size: 28px;
font-weight: 400;
text-shadow: 4px 4px 4px #bbb;
text-decoration: underline;
text-transform: lowercase; line-height: 1.42em; }
</style>

That’s really all you need to use the Google Font API.

If you want to see the font sample without any distractions from the font previewer controls, you can do that as well simply by clicking “Toggle controls” in the upper right corner. This will show you a nice clean example of what the font would look like in your design.

We think the previewer is a great way to try out web fonts and showcase what can be done with them. We’re looking forward to hearing what you think about the new font previewer.

By Marc Tobias Kunisch, Google Font API team
URL: http://googlecode.blogspot.com/2010/07/new-google-previewer-webfonts-easier.html

[Gd] Discover v201003: Learn from the past with the Bid Simulator

| More

AdWords API Blog: Discover v201003: Learn from the past with the Bid Simulator

Have you ever wondered how your keywords could have performed with a different bid? The bid simulator feature released last year allows you to do just that. Using data from the last seven days, it calculates the impressions, clicks, and cost your keywords could have received if different maximum CPC bids were used. This information was previously only exposed in the AdWords web interface, but is now available in the v201003 version of the API with the BidLandscapeService.

The getBidLandscape() method is used to retrieve the bid simulation results, also known as bid landscapes. You can use the selector to filter the results by campaign, ad group, or keyword ID. For example, to retrieve the results for a single keyword using the PHP client library you would use the following code:

// Create selector.
$selector = new CriterionBidLandscapeSelector();

// Create id filter.
$idFilter = new BidLandscapeIdFilter();
$idFilter->adGroupId = $adGroupId;
$idFilter->criterionId= $keywordId;
$selector->idFilters = array($idFilter);

// Get bid landscape for keyword.
$bidLandscapes = $bidLandscapeService->getBidLandscape($selector);

The returned BidLandscape contains a series of LandscapePoints, each of which represents a single simulation for that keyword. It isn’t possible to configure which bids are used in the simulations, but the points are chosen automatically by the system to give an interesting range of data. Each landscape point contains the impressions, clicks, and cost that the keyword could have received at that bid. In addition, it contains the field marginalCpc, which contains the incremental cost-per-click (ICC) at the simulated bid. More information on ICC values and how you can use them is outlined in a video by Google's Chief Economist, Hal Varian. Please note that depending on the recent performance of the keyword, only some of this information may be populated in the landscape point.

Bid simulations are currently only available for campaigns that use ManualCPC bidding and target the GOOGLE_SEARCH or SEARCH_NETWORK networks. Additional restrictions are listed in the AdWords Help Center. The bid simulations are performed automatically in regular intervals, and new keywords or those with no impressions in the last seven days won’t have any associated results. No errors will be thrown when this happens, but the response will not contain a BidLandscape for that keyword.

Example code using the BidLandscapeService is available in the client libraries. Please post any questions about this service to the forum. Additional information about the bid simulator can be found in the Help Center.

- Eric Koleda, AdWords API Team
URL: http://adwordsapi.blogspot.com/2010/07/discover-v201003-learn-from-past-with.html

[Gd] Dev Channel Update

| More

Google Chrome Releases: Dev Channel Update

The Dev channel has been updated to 6.0.472.11 for all platforms.

This release contains
  • UI tweaks and clean up
  • Additional stability fixes
Known Issues
More details about additional changes are available in the svn log of all revisions

You can find out about getting on the Dev channel here: http://dev.chromium.org/getting-involved/dev-channel

If you find new issues, please let us know by filing a bug at http://code.google.com/p/chromium/issues/entry

Jason Kersey
Google Chrome
URL: http://googlechromereleases.blogspot.com/2010/07/dev-channel-update_28.html

[Gd] Do You Know How Slow Your Web Page Is?

| More

Chromium Blog: Do You Know How Slow Your Web Page Is?

The Web Timing draft specification presents a standard set of metrics for measuring web page load time across browsers. We’re happy to announce that in Chrome 6, web developers can now access these new metrics under window.webkitPerformance.

Measuring web page load time is a notoriously tricky but important endeavor. One of the most common challenges is simply getting a true start time. Historically, the earliest a web page could reliably begin measurement is when the browser begins to parse an HTML document (by marking a start time in a <script> block at the top of the document).

Unfortunately, that is too late to include a significant portion of the time web surfers spend waiting for the page: much of the time is spent fetching the page from the web server. To address this shortcoming, some clever web developers work around the problem by storing the navigation start time in a cookie during the previous page’s onbeforeunload handler. However, this doesn’t work for the critical first page load which likely has a cold cache.

Web Timing now gives developers the ability to measure the true page load time by including the time to request, generate, and receive the HTML document. The timeline below illustrates the metrics it provides. The vertical line labeled "Legacy navigation started" is the earliest time a web page can reliably measure without Web Timing. In this case, instead of a misleading 80ms load time, it is now possible to see that the user actually experienced a 274ms time. Including this missing phase will make your measurements appear to increase. It’s not because pages are getting slower – we’re just getting a better view on where the time is actually being spent.


Across other browsers: Web Timing metrics are under window.msPerformance in the third platform preview of Internet Explorer 9 and work is underway to add window.mozPerformance to Firefox. The specification is still being finalized, so expect slight changes before the browser prefixes are dropped. If you’re running a supported browser, please try the Web Timing demonstration and send us feedback.

Posted by Tony Gentilcore, Software Engineer
URL: http://blog.chromium.org/2010/07/do-you-know-how-slow-your-web-page-is.html

Tuesday, July 27, 2010

[Gd] Update on Datastore Performance Status

| More

Google App Engine Blog: Update on Datastore Performance Status

If you have been running an App Engine application over the last few months, you will have noticed that performance of the Datastore has drastically improved. In fact, it quickly improved after the blog post we wrote in May acknowledging the performance issues. We chose to wait until this point to ensure that we could maintain the performance and quality of service. Thanks to a huge effort from the Datastore engineering team and our Production team, the metrics over the past month have made us confident that we have returned to a level of performance that we are proud to offer. With that in mind, we are now going to re-enable Datastore CPU usage billing.



On Tuesday, August 3rd, we will re-enable charging for Datastore CPU usage.



This does not mean that we are stopping work on Datastore performance and reliability-- quite the opposite, in fact. The issue has forced the team to step back and prioritize our long term roadmap for the Datastore. While we’re happy with our performance now, there are some very large changes to the Datastore in the pipeline that will continue to improve the App Engine platform. These include features such as a more highly replicated Datastore (now part of the roadmap) and improvements to the index building pipeline.



Thank you all for your patience and continued use of App Engine during this time. We’re excited to continue to serve our apps’ continued growth.



Posted by the App Engine Team
URL: http://googleappengine.blogspot.com/2010/07/update-on-datastore-performance-status.html

[Gd] Redesigned app pages on orkut

| More

Google Code Blog: Redesigned app pages on orkut

Since we launched the new orkut, we’ve been working hard to launch new features and introduce the new design to other pages that are still using the older UI. Today, we’re excited to announce the redesign of the app pages on orkut. Because we want developers to try it out first, these changes are first being rolled out to the sandbox, and you’ll have some time to give us your feedback before these go live for all users at orkut.com. We believe usability and speed improved considerably.

Let’s check out what’s new:

New canvas page
Options are more descriptive and appear at the top of the page. They open up as dialogs so users can configure or access the app information without leaving the canvas page.


New apps directory page
The apps directory is easier to navigate. We removed the descriptions and arranged the apps in two columns, and you can search for apps within categories, so it all looks much cleaner. We also created a section called "my applications" from where users can open or remove their apps.

When a user clicks on an app listed in the directory, the screenshot as well as the app’s description and popularity will now pop up in a new window. This window replaces the old app page and allows users to quickly add apps without loading another page.


New profile view for apps
We’re changing the way apps are displayed on a user’s profile. Showing several apps in tabs on the profile page was confusing. We made things simpler having users select a single app to appear on their profile page and other apps (as well as the "about me" section) are accessible by a drop-down menu.

A new apps box
We’re adding a “my applications” box, just below the “my communities” one on the right. This box will list the thumbnails of all apps the user has installed. We hope this will drive more traffic to the app’s canvas page.

We hope you’ll like these changes. Please share your feedback with us at the forum.

By Adler Silva, orkut Team
URL: http://googlecode.blogspot.com/2010/07/redesigned-app-pages-on-orkut.html

[Gd] Licensing Service Technology Highlights

| More

Android Developers Blog: Licensing Service Technology Highlights

We’ve just announced the introduction of a licensing server for Android Market. This should address one of the concerns we’ve heard repeatedly from the Android developer community.

The impact and intent, as outlined in the announcement, are straightforward. If you want to enable your app to use the licensing server, there’s no substitute for reading the authoritative documentation: Licensing Your Applications. Here are some technical highlights.

  • This capability has been in the Android Market client app since 1.5, so you don’t have to be running the latest Android flavor to use it.

  • It’s secure, based on a public/private key pair. Your requests to the server are signed with the public key and the responses from the server with the private key. There’s one key pair per publisher account.

  • Your app doesn’t talk directly to the licensing server; it IPCs to the Android Market client, which in turn takes care of talking to the server.

  • There’s a substantial tool-set that will ship with the SDK, the License Verification Library (LVL). It provides straightforward entry points for querying the server and handling results. Also, it includes modules that you can use to implement certain licensing policies that we expect to be popular.

  • LVL is provided in source form as an Android Library project. It also comes with a testing framework.

  • There’s a Web UI on the publisher-facing part of the Market’s Web site for key management; it includes setup for production and testing.

  • Obviously, you can’t call out to the server when the device is off-network. In this situation you have to decide what to do; one option is to cache licensing status, and LVL includes prebuilt modules to support that.

We think this is a major improvement over the copy-protection option we’ve offered up to this point, and look forward to feedback from developers.

URL: http://android-developers.blogspot.com/2010/07/licensing-service-technology-highlights.html

[Gd] Licensing Service For Android Applications

| More

Android Developers Blog: Licensing Service For Android Applications

[This post is by Eric Chu, Android Developer Ecosystem. — Tim Bray]

In my conversations with Android developers, I often hear that you’d like better protection against unauthorized use of your applications. So today, I’m pleased to announce the release of a licensing service for applications in Android Market.

This simple and free service provides a secure mechanism to manage access to all Android Market paid applications targeting Android 1.5 or higher. At run time, with the inclusion of a set of libraries provided by us, your application can query the Android Market licensing server to determine the license status of your users. It returns information on whether your users are authorized to use the app based on stored sales records.

This licensing service operating real time over the network provides more flexibility in choosing license-enforcement strategies, and a more secure approach in protecting your applications from unauthorized use, than copy protection.

The licensing service is available now; our plan is for it to replace the current Android Market copy-protection mechanism over the next few months. I encourage you to check out the Licensing Your Applications section of our Developer Guide and the Android Market Help Center to learn how you can take advantage of this new service immediately.

URL: http://android-developers.blogspot.com/2010/07/licensing-service-for-android.html

Monday, July 26, 2010

[Gd] Stable Channel Update

| More

Google Chrome Releases: Stable Channel Update

Google Chrome 5.0.375.125 has been released to the Stable channel on Linux, Mac, Windows, and Chrome Frame.

Security fixes and rewards:
Please see the Chromium security page for more detail. Note that the referenced bugs may be kept private until a majority of our users are up to date with the fix.
Aside from the listed security bugs fixed in Chromium, we have also deployed workarounds for two critical vulnerabilities where the root cause lies in external components. Credit and $1337 to Marc Schoenefeld for enabling us to work around a Windows kernel bug [48283]. Credit and $1337 to Simon Berry-Byrne for enabling us to work around a glibc bug [48733].
  • [$500] [42736] Medium Memory contents disclosure in layout code. Credit to Michail Nikolaev.
  • [$500] [43813] High Issue with large canvases. Credit to sp3x of SecurityReason.com.
  • [$500] [47866] High Memory corruption in rendering code. Credit to Jose A. Vazquez.
  • [$500] [48284] High Memory corruption in SVG handling. Credit to Aki Helin of OUSPG.
  • [48597] Low Avoid hostname truncation and incorrect eliding. Credit to Google Chrome Security Team (Inferno).
If you find issues, please let us know: http://code.google.com/p/chromium/issues/entry

Jason Kersey
Google Chrome
URL: http://googlechromereleases.blogspot.com/2010/07/stable-channel-update_26.html

[Gd] New Message Center notifications for detecting an increase in Crawl Errors

| More

Official Google Webmaster Central Blog: New Message Center notifications for detecting an increase in Crawl Errors

Webmaster Level: All

When Googlebot crawls your site, it’s expected that most URLs will return a 200 response code, some a 404 response, some will be disallowed by robots.txt, etc. Whenever we’re unable to reach your content, we show this information in the Crawl errors section of Webmaster Tools (even though it might be intentional and not actually an error). Continuing with our effort to provide useful and actionable information to webmasters, we're now sending SiteNotice messages when we detect a significant increase in the number of crawl errors impacting a specific site. These notifications are meant to alert you of potential crawl-related issues and provide a sample set of URLs for diagnosing and fixing them.

A SiteNotice for a spike in the number of unreachable URLs, for example, will look like this:


We hope you find SiteNotices helpful for discovering and dealing with issues that, if left unattended, could negatively affect your crawl coverage. You’ll only receive these notifications if you’ve verified your site in Webmaster Tools and we detect significant changes to the number of crawl errors we encounter on your site. And if you don't want to miss out on any these important messages, you can use the email forwarding feature to receive these alerts in your inbox.

If you have any questions, please post them in our Webmaster Help Forum or leave your comments below.

Posted by Pooja Shah and Jonathan Simon
URL: http://googlewebmastercentral.blogspot.com/2010/07/new-message-center-notifications-for.html

[Gd] New Message Center notifications for detecting an increase in Crawl Errors

| More

Official Google Webmaster Central Blog: New Message Center notifications for detecting an increase in Crawl Errors

Webmaster Level: All

When Googlebot crawls your site, it’s expected that most URLs will return a 200 response code, some a 404 response, some will be disallowed by robots.txt, etc. Whenever we’re unable to reach your content, we show this information in the Crawl errors section of Webmaster Tools (even though it might be intentional and not actually an error). Continuing with our effort to provide useful and actionable information to webmasters, we're now sending SiteNotice messages when we detect a significant increase in the number of crawl errors impacting a specific site. These notifications are meant to alert you of potential crawl-related issues and provide a sample set of URLs for diagnosing and fixing them.

A SiteNotice for a spike in the number of unreachable URLs, for example, will look like this:


We hope you find SiteNotices helpful for discovering and dealing with issues that, if left unattended, could negatively affect your crawl coverage. You’ll only receive these notifications if you’ve verified your site in Webmaster Tools and we detect significant changes to the number of crawl errors we encounter on your site. And if you don't want to miss out on any these important messages, you can use the email forwarding feature to receive these alerts in your inbox.

If you have any questions, please post them in our Webmaster Help Forum or leave your comments below.

Posted by Pooja Shah and Jonathan Simon
URL: http://googlewebmastercentral.blogspot.com/2010/07/new-message-center-notifications-for.html