Friday, December 11, 2009

[Gd] Collaborate around OpenSocial gadget content using Atlassian Confluence

| More

OpenSocial API Blog: Collaborate around OpenSocial gadget content using Atlassian Confluence

Hello Readers, Mark Halvorson from Atlassian posting.  A while back Atlassian announced its commitment to bringing OpenSocial to the Enterprise, since that time we've been working hard to get OpenSocial working in all of our products.  In October we released JIRA 4.0, Atlassian's award-winning issue tracker.  With JIRA 4.0's new Shindig-based dashboards, JIRA acts as both an OpenSocial gadget producer and consumer.  Now we're happy to announce that Confluence 3.1 is now generally available for download from atlassian.com - and it too can now both produce and consume OpenSocial gadgets!

As many of you know OpenSocial gadgets make it easier to integrate with other applications on the web and behind the firewall.  Along with many other new features it is now possible to embed OpenSocial gadgets on any Confluence wiki page.  This will let groups of people collaborate around gadget content from virtually any application seamlessly.

  • Embedding OpenSocial Gadgets is Easy - Confluence 3.1 lets you embed Gadgets from other Atlassian tools like JIRA, Bamboo and FishEye directly into Confluence pages. You can add and configure gadgets in just a couple clicks using the Macro Browser, a visual editor available from any page:
    Adding JIRA Gadget4.png
    And because OpenSocial is an open standard, you can use Gadgets to integrate with 3rd party applications behind the firewall and thousands of applications on the web.

  • Add Confluence to other applications - Confluence also provides its own Gadgets that you can embed into other OpenSocial containers like JIRA or even Gmail. Confluence comes with three out-of-the-box gadgets: Activity Stream, QuickNav and Confluence News.
    confluence in gmail.png

See for yourself
Check out our brief overview video to see all of Confluence 3.1's new features in action:



Try it now!
Download Confluence 3.1 now to upgrade or get started a 10-user license for only $10, or a free 30-day evaluation. We've introduced simplified evaluation installers for Windows and OS X to get you up and running quickly.

If you need instant gratification, you can also check out our Online Trial (also free for 30 days) or play around with our live Sandbox.

Check out 3.1 and let us know what you think!

Posted by Mark Halvorson, Atlassian Software
URL: http://blog.opensocial.org/2009/12/collaborate-around-opensocial-gadget.html

[Gd] Dev Channel Update

| More

Google Chrome Releases: Dev Channel Update

The Dev channel has been updated to 4.0.266.0 for Windows and Linux.

No mac updates this week, we are working to get a version out soon.

All Platforms (but Mac)
Windows
Linux
  • [r32547] Extensions that use bubbles on page actions work. (Issue: 28061)
  • [r33132] Proxy settings should now work on newer KDE4 systems. (Issue: 25938)
  • [r32206] Use SSE2 optimizations in Skia.

Known issues:
Issue #30065
[Linux] Drop down menu for bookmark location is broken;Drop down menu opens for a second then close.

Issue #
30066
Once a folder is located in 'Other Bookmarks', user cannot move the folder out of 'Other Bookmarks'

Issue #
30067
[Linux] When creating Folder/Bookmark under the 'Other Bookmarks', Foler/Bookmark is created on the bookmark bar.

Issue #
30068
[Linux] When Folder is located under parent folder or 'Other Bookmarks', the folder icon color becomes gray.

Orit Mazor, Google Chrome
URL: http://googlechromereleases.blogspot.com/2009/12/dev-channel-update_11.html

[Gd] Come to Our Virtual Office Hours

| More

Android Developers Blog: Come to Our Virtual Office Hours

Starting this week, we're going to be holding regular IRC office hours for Android app developers in the #android-dev channel on irc.freenode.net. Members of the Android team will be on hand to answer your technical questions. (Note that we will not be able to provide customer support for the phones themselves.) We'll post transcripts on the android-developers discussion group shortly after each session for permanent archiving.

We've arranged our office hours to accommodate as many different schedules as possible, for folks around the world. We will initially hold two sessions each week:
  • 12/15/09 Tuesday, 9 a.m. to 10 a.m. PST
  • 12/17/09, Thursday 5 p.m. to 6 p.m. PST
  • 12/22/09, Tuesday 9 a.m. to 10 a.m. PST
  • 01/06/09 Tuesday 9 a.m. to 10 a.m. PST
  • 01/08/09 Thursday 5 p.m. to 6 p.m. PST and so on...
Check Wikipedia for a helpful list of IRC clients. Alternatively, you could use a web interface such as the one at freenode.net. We will try to answer as many as we can get through in the hour.

We hope to see you there!
URL: http://android-developers.blogspot.com/2009/12/come-to-our-virtual-office-hours.html

[Gd] Google Developer Days 2009 come to an end

| More

Google Code Blog: Google Developer Days 2009 come to an end

We've concluded Google Developer Days 2009, a set of one-day developer events that travel around the world. This year, they started in Beijing, China on June 5 and ended in Moscow, Russia on November 10. At each event, attendees had the opportunity to learn about Google's newest web technologies with products such as Google WaveAndroidChrome, Google Web ToolkitOpenSocial, and App Engine. They also interacted with Google developers during "office hours" and had the chance to see how other developers are using Google technologies for their own applications at various demo areas.

We have finished posting the presentations and photos from our final events of the year, and hopefully each location's page will continue to be a useful resource for you. Thank you for making these such great events! We look forward to seeing you in 2010...

By Alyssa England Sachs, Google Developer Team
URL: http://googlecode.blogspot.com/2009/12/google-developer-days-2009-come-to-end.html

[Gd] http://googlecode.blogspot.com/

| More

Official Google Data APIs Blog: http://googlecode.blogspot.com/

Good news, Google Data APIs are upgrading and moving to the official Google Code blog! From now on, we'll be posting all of our new and exciting news at http://googlecode.blogspot.com.

Unfortunately, that means there won't be any more posts here. However, if you need information from any of the older posts, they will all remain here indefinitely.

And of course, you can always find loads of information about all of Google's developer products at http://code.google.com/.
URL: http://googledataapis.blogspot.com/2009/12/httpgooglecodeblogspotcom.html

[Gd] What's the Difference Between Chromium OS and Google Chrome OS?

| More

Chromium Blog: What's the Difference Between Chromium OS and Google Chrome OS?

The last couple of weeks since we open sourced Chromium OS have been pretty exciting. The discussion groups have been buzzing and a number of sites have put up Chromium OS builds for download. While we're happy that developers have been building Chromium OS there are a few things we would like to clarify:
  1. This is not ready for consumers yet — everything you see can and probably will change by the time Google Chrome OS-based devices are available late next year.
  2. Please note that Google has not released an official binary for Chromium OS and therefore if you download Chromium OS binaries please ensure that you trust the site you are downloading them from.
  3. While we will try our best to help you through the Chromium discussion forums, we will not be officially supporting any of these builds. Remember that you are downloading that specific site/developer's build of Chromium OS.
We have also received a number of questions that we wanted to answer directly and so we put together the following FAQ to clarify some of these issues.

One of the top questions has been around the distinction between Google Chrome OS and Chromium OS. Google Chrome OS is to Chromium OS what Google Chrome browser is to Chromium. Chromium OS is the open source project, used primarily by developers, with code that is available for anyone to checkout, modify and build their own version with. Meanwhile, Google Chrome OS is the Google product that OEMs will ship on Netbooks next year. Therefore, dear developers who have built and posted Chromium OS binaries, you're awesome and we appreciate what you are doing, however we have to ask you to call the binaries you've put up for download "Chromium OS" and not "Google Chrome OS".

Thanks!
Posted by Martin Bligh, Software Engineer
URL: http://blog.chromium.org/2009/12/whats-difference-between-chromium-os.html

[Gd] Discover v2009: New Examples in Client Libraries

| More

AdWords API Blog: Discover v2009: New Examples in Client Libraries

Our Discover v2009 series has focused on introducing you to the new services and objects that come with the update to the API. And while we hope these posts have been informative we know there is nothing like running a code example yourself to bring the concepts to life. That's why we've spent the last few weeks completely re-hauling the examples in our client libraries to provide a more complete set of sample code to try out. The following client libraries now have over 30 examples for the v200909 version of the API:
If you haven't tried out the v2009 API there is no better time to get started. With our client libraries you can go from download to making requests in under five minutes, and the built-in logging and utility classes make learning v2009 a breeze. Many client libraries (Java, .NET, Python, and Ruby) even come bundled with v13 support, allowing you to take advantage of new v2009 features without having to update your entire application at once.

As always, we are here to answer your questions, collect feedback, and assist with migration to the v2009 API.

- Eric Koleda, AdWords API Team
URL: http://adwordsapi.blogspot.com/2009/12/discover-v2009-new-examples-in-client.html

Thursday, December 10, 2009

[Gd] [Libraries][Update] Chrome Frame 1.0.2

| More

Google AJAX API Alerts: [Libraries][Update] Chrome Frame 1.0.2

Chrome Frame was updated to version 1.0.2
URL: http://ajax-api-alerts.blogspot.com/2009/12/librariesupdate-chrome-frame-102.html

[Gd] New features for Google Web Elements

| More

Google Code Blog: New features for Google Web Elements

Earlier this year we introduced Google Web Elements, an easy way to embed Google products on your site by simply copying and pasting a snippet of code. Today we're excited to announce the addition of three new Web Elements:
  • Translate element

    The Translate element enables visitors to automatically translate your pages into their native language, extending the reach of your website to a global audience. Even better, it will know when their language doesn't match your site's. Have some multi-lingual visitors? Don't worry, they'll be able to turn it off completely.

    Note that whether or not the Translate element pops up is based on the language of your web browser. In order to test what other language visitors will see on your site, you'll have to follow the directions here to change your browser's language.


  • Reader element

    The Reader element embeds the headlines from your recent shared items on Google Reader right on your website. You can customize the element by choosing how many items to show and the color scheme. The headlines shown in the Reader element will automatically update as you share or unshare items.







  • Orkut element

    The Orkut element makes it easy for your website's visitors to share your site on their Orkut page. When visitors to your site click the button, they'll be able to share your website content with their Orkut friends with a couple clicks









We've also added a couple new features that we hope you'll enjoy:
  • Custom Search element themes:  The Custom Search element lets visitors search your site (or other content defined by you) and enables you to earn revenue (via AdSense) from highly relevant ads that are displayed in the search results. You've always been able to richly style this element (we described a couple ways in this blog post), but that required knowing JavaScript and CSS. Now you can adjust the look and feel of the element to better integrate with your site, without having to code anything.

  • Login integration:  The Google Web Elements website is now integrated with your Google account.  By logging in (if you're not logged in already), you'll be able to more easily select your Calendar, Presentation or Spreadsheet in creating your element.  Login is also required to personalize your Reader element.

  • Document selector: Once logged into the Google Web Elements website, you'll be able to easily search through your data when creating a Calendar, Presentation or Spreadsheet element.  All you have to do is click the "Choose" button and select the one that you would like to use with your element.  You still have the option of pasting in a URL (for instance, if you wish to use a document not associated with your account), but this is no longer required.

We hope you enjoy these new additions to the Web Elements family! To get started, check out www.google.com/webelements.

By Christine Tsai, Web Elements Team
URL: http://googlecode.blogspot.com/2009/12/new-features-for-google-web-elements.html

[Gd] WebGL Spec Initial Public Draft Released

| More

Chromium Blog: WebGL Spec Initial Public Draft Released

Google is one of the Khronos member companies helping to develop the WebGL specification, bringing hardware accelerated 3D rendering to the web via the Canvas element. Today is the release of the initial public draft of the WebGL spec. We're happy to announce that Chromium contains provisional WebGL support on Linux (32- and 64-bit), Mac and Windows. This implementation was developed in close collaboration with Apple Computer and utilizes much shared code from WebKit.

See Getting a WebGL Implementation for instructions on getting a Chromium build and enabling WebGL support. This is an early version with many caveats, but with it you can get a taste of the new functionality coming to the web.

Here are a few demos to whet your appetite:
The WebGL wiki is the central location for information about the evolving specification, including the draft spec, introductory articles, tutorials, mailing lists and forums. See the WebGL demo repository for more demos and instructions on how to check out their source code.

We're looking forward to finalizing the WebGL specification and making this functionality available to web developers, and look forward to your feedback. For Chromium-specific questions, use the Chromium-dev mailing list, for more general WebGL questions, use the WebGL forums or WebGL public mailing list.

Posted by Ken Russell, Software Engineer
URL: http://blog.chromium.org/2009/12/webgl-spec-initial-public-draft.html

[Gd] Optimize your layouts

| More

Android Developers Blog: Optimize your layouts



Writing user interface layouts for Android applications is easy, but it can sometimes be difficult to optimize them. Most often, heavy modifications made to existing XML layouts, like shuffling views around or changing the type of a container, lead to inefficiencies that go unnoticed.

Starting with the SDK Tools Revision 3 you can use a tool called layoutopt to automatically detect common problems. This tool is currently only available from the command line and its use is very simple - just open a terminal and launch the layoutopt command with a list of directories or XML files to analyze:


$ layoutopt samples/
samples/compound.xml
7:23 The root-level <FrameLayout/> can be replaced with <merge/>
11:21 This LinearLayout layout or its FrameLayout parent is useless samples/simple.xml
7:7 The root-level <FrameLayout/> can be replaced with <merge/>
samples/too_deep.xml
-1:-1 This layout has too many nested layouts: 13 levels, it should have <= 10!
20:81 This LinearLayout layout or its LinearLayout parent is useless
24:79 This LinearLayout layout or its LinearLayout parent is useless
28:77 This LinearLayout layout or its LinearLayout parent is useless
32:75 This LinearLayout layout or its LinearLayout parent is useless
36:73 This LinearLayout layout or its LinearLayout parent is useless
40:71 This LinearLayout layout or its LinearLayout parent is useless
44:69 This LinearLayout layout or its LinearLayout parent is useless
48:67 This LinearLayout layout or its LinearLayout parent is useless
52:65 This LinearLayout layout or its LinearLayout parent is useless
56:63 This LinearLayout layout or its LinearLayout parent is useless
samples/too_many.xml
7:413 The root-level <FrameLayout/> can be replaced with <merge/>
-1:-1 This layout has too many views: 81 views, it should have <= 80! samples/useless.xml
7:19 The root-level <FrameLayout/> can be replaced with <merge/>
11:17 This LinearLayout layout or its FrameLayout parent is useless
For each analyzed file, the tool will indicate the line numbers of each tag that could potentially be optimized. In some cases, layoutopt will also offer a possible solution.

The current version of layoutopt contains a dozen rules used to analyze your layout files and future versions will contain more. Future plans for this tool also include the ability to create and use your own analysis rules, to automatically modify the layouts with optimized XML, and to use it from within Eclipse and/or a standalone user interface.
URL: http://android-developers.blogspot.com/2009/11/optimize-your-layouts.html

[Gd] Discover v2009: validateOnly header

| More

AdWords API Blog: Discover v2009: validateOnly header

While making AdWords API calls, a common task that you have to perform as a developer is to ensure that the SOAP requests you make to the server are valid. This includes validation in terms of parameters required for an API call, as well as ensuring that your ads and criteria are in accordance with Adwords policies. AdWords API v200909 introduces a new RequestHeader field named
validateOnly to help you validate your API calls.

While making an API call in AdWords API v200909, if you include the validateOnly header in an API call, the servers will perform validation on the API parameters, but will not perform the requested operation like creating campaigns, ads, etc. For instance, the relevant parts of a SOAP request and response xml to validate a call to CampaignService::mutate() are given below.

SOAP Request

<soap:Header>
..<RequestHeader xmlns="https://adwords.google.com/api/adwords/cm/v200909">
....<!-- other headers here -->
....<validateOnly>true</validateOnly>
--</RequestHeader>
</soap:Header>

SOAP Response (Success)

<soap:Body>
..<mutateResponse xmlns="https://adwords.google.com/api/adwords/cm/v200909"/>
</soap:Body>

SOAP Response (Failure)

<soap:Body>
..<soap:Fault>
....<faultcode>...</faultcode>
....<faultstring>...</faultstring>
....<detail>
......<ApiExceptionFault
..........x
mlns="https://adwords.google.com/api/adwords/cm/v200909">
........<message>...</message>
........<ApplicationException.Type>ApiException</ApplicationException.Type>
........<errors.xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
...........xsi:type="BudgetError">
..........<fieldPath>operations[1].operand.budget</fieldPath>
..........<trigger/>
..........<ApiError.Type>BudgetError</ApiError.Type>
..........<reason>NON_MULTIPLE_OF_MINIMUM_CURRENCY_UNIT</reason>
........</errors>
........<!-- More errors here. -->
......</ApiExceptionFault>
....</detail>
..</soap:Fault>
</soap:Body>

As you can see, if the request were successful, then you would get an empty mutateResponse, which shows that the request was validated successfully, but no campaign was created. If the request had errors, then you would get back an APIException, and the errors field will contain a collection of ApiError objects, one for each error encountered on validation. The fieldPath contains the OGNL field path to identify cause of error, whereas other fields like reason and trigger gives you more information why the error occurred. For instance, the failed response xml shown above had an error in the second operation. It triggered a BudgetError since its budget was not a multiple of the minimum currency unit.

You can also use validateOnly headers to check if a batch of ads or criteria has any policy errors. AdWords API v13 exposed two methods, checkAds and checkCriteria to check a batch of ads or criteria for policy errors. The following java code snippet shows how you can use validateOnly headers to perform policy checks on ads, similar to checkAds.

AdGroupAdServiceInterface adGroupAdService = (AdGroupAdServiceInterface) ....user.getValidationService(AdWordsService.V200909.ADGROUP_AD_SERVICE);

TextAd textAd = new TextAd();
textAd.setHeadline(
"Luxury Cruise to MARS");
textAd.setDescription1(
"Visit the Red Planet in style.");
textAd.setDescription2(
"Low-gravity fun for everyone!!!"); // Force a policy violation.
textAd.setDisplayUrl("www.example.com");
textAd.setUrl(
"http://www.example.com");

AdGroupAd
adGroupAd = new AdGroupAd();
adGroupAd.setAd(textAd);
adGroupAd.setAdGroupId(Long.parseLong(
"INSERT_ADGROUP_ID_HERE"));
adGroupAd.setStatus(
AdGroupAdStatus.ENABLED);

AdGroupAdOperation
operation = new AdGroupAdOperation();
operation.setOperator(
Operator.ADD);
operation.setOperand(adGroupAd);

try
{
..AdGroupAdReturnValue result =
......adGroupAdService.mutate(new AdGroupAdOperation[] {operation});

..// No policy violations found. Add the ads using the non-validating service.
..adGroupAdService = (AdGroupAdServiceInterface)
......user.getService(AdWordsService.V200909.ADGROUP_AD_SERVICE);
..result = adGroupAdService.mutate(new AdGroupAdOperation[] {operation});
}
catch (ApiException e) {
..for (ApiError error: e.getErrors()) {
....if (error instanceof PolicyViolationError) {
......PolicyViolationError policyError = (PolicyViolationError) error;
......// Handle your policy violations here.
....}
..}
}


Finally, the use of validateOnly header will cost you only 0.05 units per validated item. All costs are rounded to the next greater or equal integer (i.e., both .05 and .95 are rounded to 1). This way, you can validate your calls and fix the errors without wasting a lot of API units on a failed API call. We've included support for validateOnly in all of our client libraries to help get you started, so please try it out and let us know of any feedback you may have on our forum.

-- Anash P. Oommen, AdWords API Team

URL: http://adwordsapi.blogspot.com/2009/12/discover-v2009-validateonly-header.html

Wednesday, December 9, 2009

[Gd] Web Sockets Now Available In Google Chrome

| More

Chromium Blog: Web Sockets Now Available In Google Chrome

Starting in the Google Chrome developer channel release 4.0.249.0, Web Sockets are available and enabled by default. Web Sockets are "TCP for the Web," a next-generation bidirectional communication technology for web applications being standardized in part of Web Applications 1.0. We've implemented this feature as described in our design docs for WebKit and Chromium.

The Web Sockets API enables web applications to handle bidirectional communications with server-side process in a straightforward way. Developers have been using XMLHttpRequest ("XHR") for such purposes, but XHR makes developing web applications that communicate back and forth to the server unnecessarily complex. XHR is basically asynchronous HTTP, and because you need to use a tricky technique like long-hanging GET for sending data from the server to the browser, simple tasks rapidly become complex. As opposed to XMLHttpRequest, Web Sockets provide a real bidirectional communication channel in your browser. Once you get a Web Socket connection, you can send data from browser to server by calling a send() method, and receive data from server to browser by an onmessage event handler. A simple example is included below.

if ("WebSocket" in window) {
var ws = new WebSocket("ws://example.com/service");
ws.onopen = function() {
// Web Socket is connected. You can send data by send() method.
ws.send("message to send"); ....
};
ws.onmessage = function (evt) { var received_msg = evt.data; ... };
ws.onclose = function() { // websocket is closed. };
} else {
// the browser doesn't support WebSocket.
}

In addition to the new Web Sockets API, there is also a new protocol (the "web socket protocol") that the browser uses to communicate with servers. The protocol is not raw TCP because it needs to provide the browser's "same-origin" security model. It's also not HTTP because web socket traffic differers from HTTP's request-response model. Web socket communications using the new web socket protocol should use less bandwidth because, unlike a series of XHRs and hanging GETs, no headers are exchanged once the single connection has been established. To use this new API and protocol and take advantage of the simpler programming model and more efficient network traffic, you do need a new server implementation to communicate with — but don't worry. We also developed pywebsocket, which can be used as an Apache extension module, or can even be run as standalone server.

You can use Google Chrome and pywebsocket to start implementing Web Socket-enabled web applications now. We're more than happy to hear your feedback not only on our implementation, but also on API and/or protocol design. The protocol has not been completely locked down and is still in discussion in IETF, so we are especially grateful for any early adopter feedback.

Posted by Yuzo Fujishima (藤島 勇造), Fumitoshi Ukai (鵜飼 文敏), and Takeshi Yoshino (吉野 剛史), Software Engineers
URL: http://blog.chromium.org/2009/12/web-sockets-now-available-in-google.html

Tuesday, December 8, 2009

[Gd] Introducing Google Web Toolkit 2.0, now with Speed Tracer

| More

Google Web Toolkit Blog: Introducing Google Web Toolkit 2.0, now with Speed Tracer


Earlier tonight, we wrapped up a very exciting Campfire One at which we announced that GWT 2.0 is now officially available. In addition to major improvements in the GWT SDK and the Google Plugin for Eclipse, GWT 2.0 includes a brand new performance analysis tool for Chrome called Speed Tracer.



Introducing Speed Tracer



We hinted at it a few weeks ago, and now it's available: Speed Tracer is a powerful new performance analysis tool for Chrome that gives you unprecedented insight into the inner workings of any web application — not just those created with GWT. Want to know why your web app feels sluggish? Speed Tracer can help you find the answer.



It's fun to see Speed Tracer in action, so here's a quick introductory video...







As an aside, Speed Tracer has a pretty snazzy user interface, eh? It was built with GWT.



Faster development, faster apps



Here's another quick overview video that highlights some of the cool new features in GWT 2.0...






Now let's talk in more detail about what's new in the GWT SDK and the Google Plugin for Eclipse...



Fast edit/refresh with new development mode and draft compiles




  • GWT 2.0 greatly improves the edit/refresh cycle by introducing a new method of debugging called development mode that allows you to debug your project with the browser of your choice — yes, your browser, not one dictated by GWT. Development mode relies on a new browser plugin, called the GWT Developer Plugin, that makes it possible for your Java project to create a debugging bridge to any browser into which it is installed. Technical details aside, this new way of debugging really just feels right.


  • By moving your debugging experience directly into the browser, development mode makes it possible to use each browser's own unique development tools in combination with Java debugging. That's right, you can now debug your Java source code in Firefox while simultaneously using great tools like Firebug to view DOM structures and experiment with CSS. Ditto for Safari and Inspector, and so on for other browsers.


  • The new Google Plugin for Eclipse includes streamlined support for launching and controlling development mode, including a new view that embeds development mode logging messages directly as an Eclipse view. It's also possible to launch development mode manually, which utilizes a Swing-based user interface and can work completely outside the context of Eclipse, including in IDEs other than Eclipse.


  • Development mode also supports multi-browser debugging, meaning that you can connect to more than one type of browser from a single debugging session. This dovetails especially well with the ability to leave a development mode session running for an extended period of time, allowing you to simply refresh the browser to see the results of changes to your Java source. It's a great way to quickly ensure that your project works properly across all the major browsers without needing to restart the Java debugger.


  • And, finally, development mode works across a network. Why is that cool? Because you can easily test browsers on operating systems different than the one on which you're developing. For example, suppose you are developing in an IDE on Linux. You can, in a single debugging session, connect across the network to see your app running — and debug it — in Internet Explorer on Windows as well as Safari on OS X. Or Chrome on Windows. Or Firefox on OS X. The point is that you can develop using whichever platform you prefer while still debugging on each of the browser/OS combinations that your users may have.


  • If you do need to compile to JavaScript often — though hopefully development mode will dramatically reduce your need to do so — you can use the GWT compiler's new -draftCompile flag, which speeds up compiles by skipping optimizations. To be clear, you definitely shouldn't deploy JavaScript compiled that way, but it can be a time saver during non-production continuous builds.



Declarative UI with UiBinder




  • GWT 2.0 introduces a powerfully productive new way to construct user interface code called UiBinder. UiBinder makes it easy to separate the visual aspects of the UI from its associated application logic. To construct your UI, simply mix HTML and widget elements declaratively in a UiBinder XML template — a .ui.xml file. You can then place application logic in an associated .java file.


  • UiBinder makes it much easier to involve web designers more directly into the development workflow. For example, developers can copy/paste from HTML mocks provided by a web designer. We've also seen that some web designers like to edit UiBinder XML templates directly and use development mode's fast edit/refresh cycle as they experiment with the UI design. It's a lot more fun to design using interactive widgets rather than passive HTML mocks.


  • It isn't as if there's a canned set of widgets that can be used with UiBinder, by the way. Incorporating your own custom widgets into a UiBinder template is exactly the same as using any of the built-in widgets.


  • UiBinder also helps prevent subtle bugs, such typos in IDs, from making it into production by validating all cross-references between the .ui.xml and .java files at compile-time.


  • The Google Plugin for Eclipse now provides UiBinder-aware wizards, code completion, red squigglies, and refactoring to help you use UiBinder effectively.



Pixel-perfect visuals with layout panels




  • Getting the exact look and feel you want in your UI is something that has traditionally been tricky with HTML and CSS. Prior to GWT 2.0, even GWT's widgets were not able to fully abstract away some of the layout headaches that can occur. However, GWT 2.0 introduces layout panels that actually do make it possible to reliably create the layout you want. The Mail sample application in the GWT SDK has been updated to show you how this works.


  • Layout panels create a predictable constraint-based layout system on top of standard CSS. Because it works with CSS, rather than in spite of it, layout panels continue to work predictably in the presence of custom CSS styles that you might need to include. And because CSS-based layout is handled natively inside the browser's rendering engine, no JavaScript needs to run during layout. As a result, layout is fast and fluid — you can especially notice the speed when resizing the browser window.


  • As you'd expect, layout panels work especially well with UiBinder. With only a few lines of XML, you can create really sophisticated layouts, including animated transitions, splitters, and more.



Compiler improvements




  • A key new feature in GWT 2.0 is developer-guided code splitting. It's easiest to explain with an analogy: when you're watching a movie online, you definitely don't want to download the whole thing before it starts playing, right? You want the movie to start instantly, and the rest should download incrementally. The same is true for web applications. Starting a web apps shouldn't feel like you're installing something; it should just start instantly when you click on a hyperlink. Code splitting is a very high-leverage tool to help you achieve exactly that.


  • It may sound complicated, but code splitting is actually easy. Just find a spot in your project where you'd like to chop out some code and use the magic new GWT.runAsync() method to create a split point. By continuing to add split points wherever it makes sense, you can easily and safely slice and dice your application to ensure that the initial download includes only the bare minimum of code necessary to start. The compiler automatically arranges for additional code fragments to be downloaded later. And, unlike manually splitting JavaScript across <script> files by hand, the GWT compiler does the hard work of ensuring that needed all expected dependencies are downloaded in the correct order automatically. For an example, see the Showcase sample application included in the GWT SDK, which has been updated to demonstrate code splitting.


  • In addition to code splitting, there are also fundamental improvements to the compiler's ability to produce JavaScript. With each new release of GWT, we add compiler optimizations to make compiled JavaScript smaller and faster. That's a big benefit if you have existing GWT projects, because you can simply upgrade, recompile, and — poof — your applications start and run more quickly. Indeed, GWT 2.0 includes some high-impact new optimizations, and we have already seen size reductions in compressed JavaScript ranging from 3% up to over 20%.



Optimized resources with ClientBundle




  • ClientBundle extends and generalizes the resource-bundling pattern that began with ImageBundle in GWT 1.4. With a simple interface declaration, you can at compile-time optimize and embed resources directly into your compiled JavaScript. For example, by bundling images, you can avoid costly HTTP round-trips. ClientBundle supports bundling a wide variety of resource types, including images, text, and even CSS.


  • You heard that right, CSS. CssResource is a powerful new framework for managing styles. It supports a new extended CSS syntax for defining sprites, named constants, scopes, conditional selectors, and more. It also aggressively optimizes your CSS by stripping comments and whitespace and by obfuscating class names.


  • ClientBundle is also extensible. You can create your own resource types and hook into the ClientBundle framework to keep resource interfaces coherent and succinct while bundling any sort of resource you can find a use for.



Special Thanks



GWT 2.0 is the culmination of many months of collaborative development, and on behalf of the the entire GWT team, we'd like to thank the WebKit team, with whom we've worked closely to add the low-level instrumentation necessary to make Speed Tracer possible.




And, as always, a huge thanks goes out to the GWT developer community, many of whom have bravely followed the tip of the GWT trunk in svn, trying out new in-progress features and helping find bugs — and even submitting patches to fix them.



Get Started



Believe it or not, we've still only scratched the surface of what's new. As always, GWT is open source and free to use. We hope you'll give GWT 2.0 a spin.




Download Google Web Toolkit 2.0




Happy coding! See you online.

URL: http://googlewebtoolkit.blogspot.com/2009/12/introducing-google-web-toolkit-20-now.html

[Gd] Google Web Toolkit 2.0 - now with Speed Tracer

| More

Google Code Blog: Google Web Toolkit 2.0 - now with Speed Tracer

Tonight at a Google Campfire One we released Google Web Toolkit 2.0, aiming to do two main things for developers:
  • Make it easier to build faster apps
  • Speed up the overall development cycle
This is a very exciting release because it's the cumulation of a year and a half working with teams like Google Wave, AdWords, and Orkut (among many others inside and outside of Google) to evolve GWT to meet the needs of today's web applications. There are many features and improvements, but let me call out three which we're especially excited about.

Faster Apps

Introducing: Performance profiling with Speed Tracer
The first thing you'll notice in 2.0 is that we've added a new tool called Speed Tracer. Speed Tracer is a performance profiler for Google Chrome that allows developers to see what's going on in a way which hasn't been possible before. We've worked closely with the Webkit community to add instrumentation in the browser to enable developers to gain deep insights into how code behaves, uncovering problems which have been hidden up till now.

Introducing: Incremental app download with code splitting
Another feature we've added into Google Web Toolkit is developer-guided code splitting. Code splitting allows a developer to split up their application for much, much faster startup times. Imagine if you have a settings page that users go to once a week. Why download that JavaScript when the application starts up? With code splitting, your users download just the JavaScript they need to get started.

Faster Development

Introducing: Declarative UI with UiBinder
UiBinder is a new declarative UI framework in Google Web Toolkit which enables rapid design iteration and a clean separation between presentation layer and application logic.

Dive into the details and more features in GWT 2.0.



By Andrew Bowers, GWT Product Manager
URL: http://googlecode.blogspot.com/2009/12/google-web-toolkit-20-now-with-speed.html

[Gd] Upcoming Webinar

| More

Google Testing Blog: Upcoming Webinar

By James A. Whittaker

If anyone is interested, I am giving a webinar through uTest. It's open to the uTest community and the public. You can register at https://www2.gotomeeting.com/register/793439307.

I'll be giving a talk about how we do testing at Google, specifically related to an update on our use of exploratory testing that I introduced at STAR East.

Look forward to seeing you online.


URL: http://googletesting.blogspot.com/2009/12/upcoming-webinar.html

[Gd] Google Chrome Extensions launched in beta!

| More

Google Code Blog: Google Chrome Extensions launched in beta!

Today, we launched Google Chrome's extensions system in the beta channel for Windows and Linux (Mac is in progress). We've also opened up our brand new gallery, which contains more than 300 extensions!

We aspired to create an extensions system that is easy to use, stable, more secure and that wouldn't slow down Google Chrome. We're really happy to release a beta that begins to deliver on our initial vision. If you want to learn more about Google Chrome extensions, you can start by reading our docs and joining our mailing list. You can also check out the videos below:



You can also meet us in person - let us know if you want to join us in a small get together tomorrow on our campus in Mountain View (or via VC in New York and Kirkland). Space is limited - we'd love to see many of you there so RSVP early and we'll email you more information if you are selected to attend. You can also meet the team at Add-on Con, where we will participate in a couple of panels.

Finally for those of you who are far away, we are planning some online developer tutorial sessions. If you are interested in attending, please fill in this form.

By Erik Kay and Aaron Boodman, Google Chrome Software Engineers
URL: http://googlecode.blogspot.com/2009/12/google-chrome-extensions-launched-in.html