Friday, October 23, 2009

[Gd] Dev Channel Updated with Crash and Calendar Fix

| More

Google Chrome Releases: Dev Channel Updated with Crash and Calendar Fix


This release fixes a crash when running extensions like the Subscribe in Feed Reader sample.  It also fixes a problem in Google Calendar where overlapping calendar items were invisible because they were being displayed with 0 width.  This update is being released for Windows, Mac and Linux.

You can find out about getting on the Dev channel here:

If you find new issues, please let us know by filing a bug at

Jonathan Conradt
Engineering Program Manager

[Gd] [Libraries][Update] - MooTools 1.2.4

| More

Google AJAX API Alerts: [Libraries][Update] - MooTools 1.2.4

MooTools was updated to version1.2.4

[Gd] UI framework changes in Android 1.6

| More

Android Developers Blog: UI framework changes in Android 1.6

Android 1.6 introduces numerous enhancements and bug fixes in the UI framework. Today, I'd like to highlight three improvements in particular.

Optimized drawing

The UI toolkit introduced in Android 1.6 is aware of which views are opaque and can use this information to avoid drawing views that the user will not be able to see. Before Android 1.6, the UI toolkit would sometimes perform unnecessary operations by drawing a window background when it was obscured by a full-screen opaque view. A workaround was available to avoid this, but the technique was limited and required work on your part. With Android 1.6, the UI toolkit determines whether a view is opaque by simply querying the opacity of the background drawable. If you know that your view is going to be opaque but that information does not depend on the background drawable, you can simply override the method called isOpaque():

public boolean isOpaque() {
return true;

The value returned by isOpaque() does not have to be constant and can change at any time. For instance, the implementation of ListView in Android 1.6 indicates that a list is opaque only when the user is scrolling it.

More flexible, more robust RelativeLayout

RelativeLayout is the most versatile layout offered by the Android UI toolkit and can be successfully used to reduce the number of views created by your applications. This layout used to suffer from various bugs and limitations, sometimes making it difficult to use without having some knowledge of its implementation. To make your life easier, Android 1.6 comes with a revamped RelativeLayout. This new implementation not only fixes all known bugs in RelativeLayout (let us know when you find new ones) but also addresses its major limitation: the fact that views had to be declared in a particular order. Consider the following XML layout:

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout xmlns:android=""



android:text="The Airborne Toxic Event" />



android:text="Sometime Around Midnight" />


android:src="@drawable/artwork" />


This code builds a very simple layout—an image on the left with two lines of text stacked vertically. This XML layout is perfectly fine and contains no errors. Unfortunately, Android 1.5's RelativeLayout is incapable of rendering it correctly, as shown in the screenshot below.

The problem is that this layout uses forward references. For instance, the "band" TextView is positioned below the "track" TextView but "track" is declared after "band" and, in Android 1.5, RelativeLayout does not know how to handle this case. Now look at the exact same layout running on Android 1.6:

As you can see Android 1.6 is now better able to handle forward reference. The result on screen is exactly what you would expect when writing the layout.

Easier click listeners

Setting up a click listener on a button is very common task, but it requires quite a bit of boilerplate code:

findViewById( View.OnClickListener() {
public void onClick(View v) {
// Do stuff

One way to reduce the amount of boilerplate is to share a single click listener between several buttons. While this technique reduces the number of classes, it still requires a fair amount of code and it still requires giving each button an id in your XML layout file:

View.OnClickListener handler = View.OnClickListener() {
public void onClick(View v) {
switch (v.getId()) {
case // doStuff
case // doStuff


With Android 1.6, none of this is necessary. All you have to do is declare a public method in your Activity to handle the click (the method must have one View argument):

class MyActivity extends Activity {
public void myClickHandler(View target) {
// Do stuff

And then reference this method from your XML layout:

<Button android:onClick="myClickHandler" />

This new feature reduces both the amount of Java and XML you have to write, leaving you more time to concentrate on your application.

The Android team is committed to helping you write applications in the easiest and most efficient way possible. We hope you find these improvements useful and we're excited to see your applications on Android Market.


Thursday, October 22, 2009

[Gd] Google Custom Search for your smartphone

| More

Google Custom Search: Google Custom Search for your smartphone

In our recent Product Ideas survey, one of the most-requested features was about enabling a mobile version of Custom Search. Guess what: It's here! As announced on the Google Mobile blog [link to mobile blog post], Custom Search now enables a rich interactive mobile experience on high-end devices such as Android-powered phones, iPhone, iPod Touch, and Palm Pre.

Try it out on your phone right now: search for user-generated content (e.g., search for [maradona]) from sites like Wikipedia, Knol, etc., or learn all about the latest and greatest Custom Search features on our product's mobile search engine (e.g., search for [snippets]).

Custom Search engine results can be embedded in your own site, but website owners can also choose to have Google host the search results page. You can now redirect visitors using these high-end mobile devices to Google-hosted search results, and we will serve up search results optimized for these devices. Better yet, we create a Google-hosted home page for every Custom Search engine that we create (even if you decide to host the results on your own website). Starting today, users who arrive at the home page for your Custom Search engine will be automatically served pocket-sized Custom Search results, along with your search engine customizations, like your labels and promotions.

All you need to do at your own end is redirect users who arrive at your website on one of the supported mobile devices to the hosted Custom Search home page. Another alternative is to provide a button or link on your web site that directs people to your Custom Search home page, whose URL looks like (you will need to replace the ID after "cx=" with your own Custom Search engine ID):

Of course, if you'd like to serve these mobile results from your own website, you can replicate the functionality of the mobile home page on your own website. This page uses the Custom Search Element. If you do, you will still need to take care of the redirection at your website so that mobile users receive mobile-friendly search results automatically.

If Google web search is the entry point for navigating the web, we hope you'll use this interactive Custom Mobile Search entry point to help people navigate your own web content when they need information on the go!

Posted by: Radu Cornea, Software Engineer and John Skidgel, Senior Interaction Designer

[Gd] AdWords API v200909 now available!

| More

AdWords API Blog: AdWords API v200909 now available!

We're happy to announce the newest version of AdWords API v2009 beta! v200909 introduces several new features to the AdWords API; we've highlighted the main points below. For a complete list of the changes in v200909, please see our release notes.

v200909 Highlights
  • Asynchronous calls - Asynchronous calls allow you to work with large sets of data faster and more easily. Instead of having to wait for our system to fully complete your request before you can make another one, you’re now able to make another call as soon as the API service confirms that it has received your previous call. No more waiting for the server to complete large requests. V200909 will continue to support Synchronous methods as well.
  • Keyword and placement ideas - With the new TargetingIdeaService, you'll be able to get keyword and placement ideas through the API, leveraging the functionality of the search-based keyword tool.
  • Location Extensions preview - Limited location extensions functionality is now available as a preview of the full functionality in development.
Coming soon: Over the next few months, we'll continue to introduce new features and additional AdWords functionality. Upcoming features include ReportService, AccountService and the ability to pre-check for errors.

v13 Sunset in 2010:
With the release of equivalent functionality in v200909, the following v13 services will be sunset on April 22, 2010: CampaignService, AdGroupService, CriterionService, AdService, InfoService, KeywordToolService, SiteSuggestionService.

Given that v2009 introduces new concepts and features, we have extended the sunset period for deprecated services to 6 months. If you haven't already begun migrating your systems to the v2009 API, we strongly encourage you to start right away. The deprecation of remaining v13 services (AccountService, TrafficEstimatorService, and ReportService) and accompanying sunset dates will be announced on a future date.

As with every new version of the AdWords API, we encourage you to review the resources in the Developer's Guide to learn more. Additionally, if you aren't using the AdWords API client libraries yet, this is a good time to check them out as they are designed to work with both v2009 and v13.


Shreyas Doshi, Product Manager and Adam Wooley, Product Marketing Manager

[Gd] Verifying a Blogger blog in Webmaster Tools

| More

Official Google Webmaster Central Blog: Verifying a Blogger blog in Webmaster Tools

Webmaster Level: All

You may have seen our recent announcement of changes to the verification system in Webmaster Tools. One side effect of this change is that blogs hosted on Blogger (that haven't yet been verified) will have to use the meta tag verification method rather than the "one-click" integration from the Blogger dashboard. The "Webmaster Tools" auto-verification link from the Blogger dashboard is no longer working and will soon be removed. We're working to reinstate an automated verification approach for Blogger hosted blogs in the future, but for the time being we wanted you to be aware of the steps required to verify your Blogger blog in Webmaster Tools.

Step-By-Step Instructions:

In Webmaster Tools
1. Click the "Add a site" button on the Webmaster Tools Home page
2. Enter your blog's URL (for example, and click the "Continue" button to go to the Manage verification page
3. Select the "Meta tag" verification method and copy the meta tag provided

In Blogger
4. Go to your blog and sign in
5. From the Blogger dashboard click the "Layout" link for the blog you're verifying
6. Click the "Edit HTML" link under the "Layout" tab which will allow you to edit the HTML for your blog's template
7. Paste the meta tag (copied in step 3) immediately after the <head> element within the template HTML and click the "SAVE TEMPLATE" button

In Webmaster Tools
8. On the Manage Verification page, confirm that "Meta tag" is selected as the verification method and click the "Verify" button

Your blog should now be verified. You're ready to start using Webmaster Tools!

Posted by Jonathan Simon, Webmaster Trends Analyst

[Gd] Find App Engine news and content at reddit

| More

Google App Engine Blog: Find App Engine news and content at reddit

We're pleased to announce that you can now submit and comment on App Engine news and articles on a new App Engine specific section of the popular social media site, reddit. Our subreddit is for any articles, blog posts, or other content relevant to App Engine, and is actively moderated and maintained by the App Engine team. Registration takes seconds and allows you to submit, vote, and comment on new App Engine content. The top articles, as selected by the App Engine community, are shown in a widget on

Be sure to check us out on the App Engine reddit -

Posted by Nick Johnson, App Engine Team

[Gd] Dev Channel Updated with Fixes and Extension Changes

| More

Google Chrome Releases: Dev Channel Updated with Fixes and Extension Changes

This week Printing and the Quicktime plugin make their initial appearance on Chrome for Mac.  Lots of important Extensions changes and quite a few bugs are also fixed.

Be sure to read the Known Issues if you are running Chrome for Mac.

All Platforms:
  • CSS rounded corners are now antialiased on Windows and Linux.  (They were already on Mac.)
    • Printing now works. (Issue: 13158)
    • [r28871] Autoupdates no longer cause problems if Chrome is already running. (Issue: 14610)
    • [r29388] Hitting backspace while IME is active does no longer go back in history. (Issue: 25000)
    • [r28837] QuickTime plugin no longer crashes, and often displays properly (though there are still bugs to be ironed out).
    • [r28837] Plugin whitelist has been removed, so that Chrome will attempt to load all NPAPI plugins.  Expect more plugin crashes.
    • [r29396] Ctrl-tab switches tabs again. (Issue: 24921)
    • [r29458] Cmd-` switches windows again. (Issue: 24817)
      • Minor visual polish (e.g. horizontal scrollbars show the proper grippy, omnibox highlighting fix).
      • [r28834] Create application shortcuts now works on Fedora 11. (Issue: 22966)
      • [r28869] Browser actions (extension buttons in toolbar) partly implemented. (Issue: 23882)
      • [r29102] Omnibox auto-complete popup stacks properly below SCIM IME candidate window. (Issue: 19082)
      • [r29261] Ctrl+F etc. no longer type other letters into edit boxes in non-English keyboard setups. (Issues: 10846221521471)
        Chrome Frame:
        • Fixes persistent IE 8 crashes. (Issue: 22768)
        • Fixed crashes when navigating with Web Inspector open. (Issue: 22993)
        • Fixes spurious errors when re-installing Chrome Frame. (Issue: 23444)
        • Fixes a crash in comctl32.dll, triggered by Google Wave. (Issue: 24115)
        • Fixes empty referrer issue for initial link navigations. (Issue: 22994)
        • Preview support for accessibility via MSAA, including ARIA role and state information. (Issues 23669, others)
        • Improved keyboard and accelerator handling.
        • IE text-size menu items now change text size in Chrome Frame.
        • Navigating to a site marked as restricted is now disabled in Chrome Frame. Chrome frame now updates the zone UI on the task bar.
        • Chrome Frame will now work for all other users on the machine, not just the user who installs it. (Issue: 23989)
        • Fixes for SSL certificate error issue.
        • Disables sending 'chromeframe' in the User-Agent if the Chrome Frame addon is disabled. (Issue: 22760)
        • Disables the 'Chrome has crashed - Restart?' message box.
        • Limited support for JavaScript history object for back/forward from content.
        • [r29068] *Breaking Change* Finalize browser actions API (Issue: 23879)
        • [r29284] *Breaking Change* Only one browser action or one page actions is now allowed per-extension. We are experimenting with the idea of a direct correspondence between extensions and visible UI features. We think this may improve managability. (Issue: 24473)
        • [r29335] Update page actions API to improve usability. Old API still supported. (Issue: 24635)
        • [r29495] Browser actions and page actions: Add chrome.browserAction.setIcon({path:...}). No longer need to prespecify images in manifest. (Issue: 22575)
        • [r29297] Add an options_page to the manifest. (Issue: 23801)
        • [r29365] You can now use (slightly) bigger icons in browser actions and page actions. Up to 19px square are now allowed (up from 16px). (Issue: 24881)
        • [r29046] Fix extension canceling. (Issue: 23405)
        • [r29143] Browser action button disappears when loading a new extension. (Issue: 23593)
          Known issues:
          • Mac: If an older version of Chrome is running when this version is automatically installed the running version will not quit cleanly and will spike the CPU at 100%.  It will be necessary to Force Quit the application.  Use Cmd-Option-Escape to open the Force Quit dialog.
          • Mac: Cmd-opt-left/right navigate history instead of switching tabs (Issue:25396). Use cmd-{/} as workaround.
          • Linux: Some fonts may look blurry or extra bold. (Issue: 25365)
          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:

          If you find new issues, please let us know by filing a bug at

          Jonathan Conradt
          Engineering Program Manager


          Wednesday, October 21, 2009

          [Gd] Come Join Us at the Ning Appathon!

          | More

          OpenSocial API Blog: Come Join Us at the Ning Appathon!

          To continue the momentum from our recent Ning Apps launch -- our Apps program based on OpenSocial -- we're excited to announce that we'll be holding a special developer event called the Ning Appathon at our offices in Palo Alto, CA on Thursday, November 5th from 6pm-10pm.

          The event will include:
          • An overview of Ning Apps and our OpenSocial implementation
          • Presentations from existing Ning Apps developers
          • A chance to meet members of the Ning Engineering and Developer Advocacy teams
          • Free pizza and beer :)
          Most importantly, we'll be announcing the start of a week-long app development competition which will include awards for new applications in addition to ported applications. Prizes and details will be revealed at the event.

          All attendees will receive a complimentary Ning hoodie, so be sure to tell us your shirt size when RSVPing. You can attend solo or bring one colleague, we only ask that you RSVP by 9pm PST on Thursday, October 29th through our website, All attendees must be at least 21 years of age.


          Posted by Ernie Hsiung, Lead Developer Evangelist, Ning

          [Gd] One million YouTube views!

          | More

          Official Google Webmaster Central Blog: One million YouTube views!

          Earlier this year, we launched our very own Webmaster Central channel on YouTube. Just today, we saw our total video views exceed one million! On the road to this milestone, we uploaded 154 videos, for a total of nearly 11 hours of webmaster-focused media. These videos have brought you conference presentations, updates on tools for webmasters, general tips, and of course answers to your "Grab bag" questions for Matt Cutts.

          To celebrate our one million views, we're sharing a fun video with you in which Matt Cutts shows us what happened when he lost a bet with his team:

          We're also pleased to announce that we've added captions to all of our videos and plan to do so for our future videos as well. Thank you to everyone who has watched, shared, and commented on our videos. We look forward to the next million views!

          Posted by Michael Wyszomierski, Search Quality Team

          Tuesday, October 20, 2009

          [Gd] The FedEx Tour

          | More

          Google Testing Blog: The FedEx Tour

          By Rajat Dewan

          I appreciate James' offer to talk about how I have used the FedEx tour in Mobile Ads. Good timing too as I just found two more priority 0 bugs with the automation that the FedEx tour inspired! It was fun presenting this at STAR and I am pleased so many people attended.

          Mobile has been a hard problem space for testing: a humongous browser, phone, capability combination which is changing fast as the underlying technology evolves. Add to this poor tool support for the mobile platform and the rapid evolution of the device and you'll understand why I am so interested in advice on how to do better test design. We've literally tried everything, from checking screenshots of Google's properties on mobile phones to treating the phone like a collection of client apps and automating them in the UI button-clicking traditional way.

          Soon after James joined Google in May 2009, he started introducing the concept of tours, essentially making a point of "structured" exploratory testing. Tours presented a way for me to look at the testing problem in a radical new way. Traditionally, the strategy is simple, focus on the end user interaction, and verify the expected outputs from the system under test. Tours (at least for me) change this formula. They force the tester to focus on what the software does, isolating the different moving parts of software in execution, and isolating the different parts of the software at the component (and composition) level. Tours tell me to focus on testing the parts that drive the car, rather than on whether or not the car drives. This is somewhat counter intuitive I admit, that's why it is so important. The real value add of the tours comes from the fact that they guide me in testing those different parts and help me analyze how different capabilities inter-operate. Cars will always drive you off the lot, which part will break first is the real question.

          I think testing a car is a good analogy. As a system it's devilishly complicated, hard to automate and hard to find the right combination of factors to make it fail. However, testing the dashboard can be automated; so can testing the flow of gasoline from the fuel tank to the engine and from there to the exhaust, so can lots of other capabilities. These automated point solutions can also be combined to test a bigger piece of the whole system. It's exactly what a mechanic does when trying to diagnose a problem: he employs different strategies for testing/checking each mechanical subsystem.

          At STAR West, I spoke about evolving a good test strategy with the help of tours, specifically the FedEx tour. Briefly, the FedEx tour talks about tracking the movement of data and how it gets consumed and transformed by the system. It focuses on a very specific moving part, and as it turns out a crucial one for mobile.

          James' FedEx tour tells me to identify and track data through my system. Identifying it is the easy part: the data comes from the Ads Database and is basically the information a user sees when the ad is rendered. When I followed it through the system, I noted three (and only three) places where the data is used (either manipulated or rendered for display). I found this to be true for all 10 local versions of the Mobile Ads application. The eureka moment for me was realizing that if I validated the data at those three points, I had little else to do in order to verify any specific localized version of an ad. Add all the languages you want, I'll be ready!

          I was able to hook verification modules at each one of these three data inflection points. This basically meant validating data for the new Click-to-Call Ad parameters and locale specific phone number format. I was tracking how code is affecting the data at each stage, which also helps in localizing a bug better than other conventional means...I knew exactly where the failure was! For overcoming the location dependency, I mocked the GPS location parameters of the phone. As soon as I finished with the automation, I ran each ad in our database through each of the language versions verifying the integrity of the data. The only thing that was left was to visually verify rendering of the ads on the three platforms, reducing the manual tests to three (one each for Android, iPhone and Palm Pre).

          The FedEx tour guided me to build a succinct piece of automation and turned what could have been a huge and error prone manual test into a reusable piece of automation that will find and localize bugs quickly. We're now looking at applying the FedEx tour across ads and in other client and cloud areas in the company. Hopefully there will be more experience reports from others who have found it useful.

          Exploratory Testing ... it's not just for manual testers anymore!


          [Gd] Introducing the Website Optimizer Experiment Management API

          | More

          Google Code Blog: Introducing the Website Optimizer Experiment Management API

          Today at the eMetrics conference in Washington DC we announced the new Website Optimizer Experiment Management API. The API allows for the creation and management of experiments outside of the Website Optimizer interface.

          If you're not familiar with Google Website Optimizer, it's a free tool for running A/B and multivariate experiments on a website. Website Optimizer handles splitting a website's traffic, serving different variations, and crunching the numbers to find statistical significance.

          Creating experiments with Website Optimizer usually involves a lot of back and forth between your website and the Website Optimizer interface. Using the API, you can integrate Website Optimizer into your platform. In short, you can create and launch experiments from whatever tool you use to edit your site.

          You'll find more about the GWO API on its Google Code site:

          You can also join the Website Optimizer engineers for a webinar on the Website Optimizer Experiment Management API. The webinar will be held on October 28th at 10AM PDT. During the webinar, Website Optimizer engineers will walk you through how the API works. Additionally, two platforms that have already integrated using the API will demonstrate their integrations.

          You need to register for the webinar, which you can do here. We'll record the webinar as well so you can reference it later.

          We're very excited about the Website Optimizer API and what it means for website testing. Let us know your thoughts in the comments.

          By Gary Kačmarčík and Erika Rice Scherpelz, Google Website Optimizer team

          [Gd] Google Wave is headed to Europe: Join us!

          | More

          Google Wave Developer Blog: Google Wave is headed to Europe: Join us!

          Back in May and June, members of the Google Wave team traveled the world meeting developers in the SF Bay Area, Asia, and South America. Now, we're heading to Europe, and we're eager to meet all the European developers that are hacking on the Google Wave APIs.

          There are many upcoming events — with links for registration and more details:

          We're looking forward to updating you on all things Google Wave, chatting with you about what you've already built, and hearing what else you'd like to do with Google Wave APIs.

          Posted by Dan Peterson, Product Manager, Google Wave


          Monday, October 19, 2009

          [Gd] The enterprise (apps) in your pocket

          | More

          Google Web Toolkit Blog: The enterprise (apps) in your pocket

          When building great enterprise apps for our users many of us often first target the desktop user. Did you know that GWT lets you just as easily build great user interfaces for your mobile users?

          Modern mobile phones such Android based devices and the iPhone ship will powerful web browsers which use the same Webkit rendering engine which GWT already supports and increasingly includes great capabilities like geo-location and offline storage.

          Today's guest blog post is from Navin Kumar, CTO of Socialwok who has offered to share some of their experiences around building mobile apps for the enterprise.

          If you have an enterprise story you'd like share please send me an email.


          Google Web Toolkit (GWT) is a great set of open source tools for developing powerful Ajax-enabled web applications.  Socialwok uses GWT on top of Google App Engine to provide a feed based group collaboration service for Google Apps users.  GWT makes development more efficient, particularly for Java developers who work on both the front-end and the back-end.  Since we use Java language support for Google App Engine, this is true for us.  By using the Java programming language, GWT can make you more efficient in many other ways too.  For example, after spending a couple of months developing the desktop web version of Socialwok, we developed the mobile HTML 5 web version in four days.

          To see the desktop web version of Socialwok go to and use any existing Google Apps domain email address to login.

          Once you have created your socialwok network, you can now access the mobile web version by pointing your mobile web browser to Login using your google apps domain email address.

          Here are a few pointers based on our experience in creating Socialwok's desktop and mobile web versions:

          1.  Think about the devices you want to support.

          75% of iPhone users say they browse the web more often from their iPhone now more than they ever did before.  40% of them browse the web more often from their iPhone than their own desktop. Hence, it is important to have a mobile web version of your application for different mobile web devices like iPhone and Android. Socialwok mobile web version supports mobile browsers based on the Webkit codebase like the iPhone's Safari and Android mobile web browsers. The first step was therefor to fix the user.agent in our module's .gwt.xml file to speed up compile time by having GWT only compile the Webkit permutation:

          <set-property name="user.agent" value="safari">

          Of course, during development we enjoy GWT's quick edit-refresh-test model thanks to Development Mode (formerly Hosted Mode) which lets us test our code in a real browser while executing and debugging in Java.

          Another thing to note is that with Mobile Safari on the iPhone and the Android Web Browser, you are now allowed to use webkit-specific CSS for mobile devices.  This allows you to use native accelerations that include transitions, border images, as well as natively-created gradients.  Here's an example of CSS used to create a native accelerated transition.

          .menuPanel {

              width: 100%;

              \-webkit-transition: opacity 500ms ease-out 100ms;


          Look for more info here. While the information is specific to the iPhone, the same rules do apply and work well on the Android browser as well.

          2. Optimize for the screen that your users are using.

          iPhone and Android devices use very powerful touch screen user interfaces. The user interface for all the iPhone applications is pretty well-defined; it involves a navigation header at the top, the content in the middle, and maybe a footer at the bottom.  If you're thinking in GWT widgets, you should be thinking VerticalPanel or FlowPanel.  These are the widgets of choice for the mobile web GWT developer.

          Screen real estate on mobile phones is precious. You have to optimize the amount of visible content on the screen.  Try to make things "expand" when you click on them.  For example, in Socialwok, when someone clicks a post from the listing screen, a new screen is given to the user with only the single "opened" post that lists all the attachments, comments, and other pieces of information right there.

          Unlike the desktop version, instead of one single widget for the feed item, we need one widget for the feed listing, and one "feed item" panel, that contains the single update along with the corresponding comment thread.

          Finally, understand that your users are looking at the mobile as a "complement" to your desktop version.

          While they might end up using the mobile version more often, they expect it to mirror the desktop interface in basic ways.  This is actually great because you have already developed your widgets using Java, and porting them to the mobile is only a matter of changing CSS classes, and removing a few unnecessary UI elements.

          3. Share as much code as possible between versions.

          This is the most important reason why mobile development can be done rapidly.  All of GWT's HTTPRequest, marshalled JavaScriptObject, and other non-UI code is shared between the mobile web and desktop web versions.  This concept is important in general for any GWT application that uses multiple EntryPoint modules.  The great thing about this is that the Java programming language makes this possible by it's own definition.  OOP developers tout code sharing all the time, and you should follow their advice nonetheless.  This page in particular is very useful to understanding how to organize your GWT code.

          I hope the above pointers help you get started on desktop to mobile web development on GWT. For more information on Socialwok and GWT, check out Google's developer GWT profile on Socialwok on YouTube.

          Finally, here are some useful classes and libraries you can use for GWT mobile web development:

          ImmutableResourceBundle - A great set of tools that was started in the GWT incubator project but has now made their way in the mainline GWT trunk development (soon to be known as ClientBundle).  ImmutableResourceBundle is the followup to the great ImageBundle interface.  Both seek to reduce greatly the number of round-trip times used by browsers to download cacheable resources such as images, CSS, and other resources.  The mobile browser is even more limited than the desktop browsers when it comes to downloading simultaneous resources, so the use of data: URLs and CssBundle are used heavily by the mobile version of Socialwok.

          FlowPanel - Unlike desktop browsers which are more optimized for

          tags that GWT uses for its CellPanel-based layout controls, mobile browsers like Safari and the Android browsers perform much better with

          tags.  Layouts also seem to be more predictable with these tags than the others on the mobile phone.

          GWTQuery - Ray Cromwell's excellent port of JQuery to GWT provides most of the JQuery functionality to allow you to modify CSS, and perform other actions with ease.  In the case of the mobile web interface, there are times when it is definitely necessary to modify CSS dynamically, and this library will make that process much easier on you as a developer.

          GWT Google APIs (Gears) - Google Gears is a browser plugin installed in the Android Web Browser used to provide extra functionality, particularly offline support which is very import for mobile browsers which don't always have a permanent connection.  Google provides a GWT library that can be used to access the Gears plugin.

          -- Navin Kumar, CTO, Socialwok


          [Gd] Hot off the press: gadgets.* migration guide

          | More

          iGoogle Developer Blog: Hot off the press: gadgets.* migration guide

          A little over a month, we announced the deprecation of the legacy gadgets API, and in the intervening time have been hard at work on resources to help with the transition. The first of these resources, a gadgets.* migration guide, has just been posted to

          The guide includes mappings between _IG_* and gadgets.* methods, helper functions, and pointers to third-party libraries that you can use in your updated gadgets.

          If you have any questions about the migration guide, or the transition from _IG_* to gadgets.*, please visit the iGoogle Developer Forum.

          Posted by Dan Holevoet, Developer Programs

          [Gd] Google Wave at GTUG London: Monday, October 26

          | More

          Google Wave Developer Blog: Google Wave at GTUG London: Monday, October 26

          I'm happy to announce that the Google Wave team will be presenting at a specially-arranged London GTUG meetup on Monday, October 26. Stephanie Hannon and Lars Rasmussen will give a talk about Google Wave and the APIs that are currently available, and discuss some of what we've learned as a result of the developer preview and where we're headed next. There will also be ample time for Q&A, and you're welcome to submit questions beforehand. We hope to meet a lot of current developers, and inspire others to get started building great extensions. No need to wait for the talk though — you can jump in and check out the docs and the samples.

          The event will be held at the Google London office at 6pm on Monday, October 26. We have limited seats, so act fast to request yours. Please sign up here.

          We look forward to seeing many of you there! If you're in Europe, but can't make it to London — stay tuned for another post talking about the rest of the European tour.

          Posted by Pamela Fox, Developer Relations