• You must instrument your site (one example tool is jiffy-web).
• You must isolate changes.
  • The most straight-forward way to do that is to release only one change at a time. That avoids having multiple changes altering performance numbers--for better or for worse--at the same time.
• Consider releasing changes to a subset of users.
  • That helps safe-guard against real-world events like holidays, big news days, exploding hard drives, and, perhaps the worst possible fate of all: a slashdotting.

• Firefox Throttle (Firefox plug-in, windows-only, free)
• Fiddler: Web Debugging Proxy (free)
• Charles: Web Debugging Proxy (shareware, $50)

• October 18th -- Bangalore, India
• October 21st -- Milan, Italy
• October 24th -- Prague, Czech Republic
• October 28th -- Moscow, Russia

• A News Search:
  http://ajax.googleapis.com/ajax/services/search/news?v=1.0&q=Barack%20Obama%20unitedstates_uselections
• A channel search for the YouTube tab:
  http://ajax.googleapis.com/ajax/services/search/video?v=1.0&q=ytchannel:barackobamadotcom
• And, a Custom Search Engine was created for the blog search:
  http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q=Barack%20Obama&cx=010222979794876194725:pqldevwuapa.

Google XML Pages (GXP) is a templating system we use at Google. Its main focus is markup: we mostly use it for generating HTML and XHTML, but it can work with other flavors of XML, like Atom, KML, and RSS. It also has some support for a few non-markup languages (JavaScript, CSS and plain text), though mostly for embedding them within markup.

• Google Calendar supports CalDAV: This is experimental, but means that you can kick up iCal and have bi-directional sync.
• QR Code in Charts API: QR codes are 2D bar codes. You can store anything you want, but commonly people put URLs and contact information in there, that mobile phones can quickly scan.

Using iTunes?

ruby script /plugin install http://gearsonrails.googlecode.com/svn/trunk/acts_as_local

def create_local
 '
   post = Post.build(params("post"));
   Post.create_local(post);
   window.location.reload( false );
 '
end

cht=qr
chl=<text>
choe=<output>

An open protocol to allow secure API authentication in a simple and standard method from desktop and web applications.

https://www.google.com/accounts/AuthSubRequest?
       next=http://localhost/authsub
       &scope=http://www.google.com/calendar/feeds%20
              http://picasaweb.google.com/data
       &secure=1
       &session=1

Protocol buffers are a flexible, efficient, automated mechanism for serializing structured data – think XML, but smaller, faster, and simpler. You define how you want your data to be structured once, then you can use special generated source code to easily write and read your structured data to and from a variety of data streams and using a variety of languages. You can even update your data structure without breaking deployed programs that are compiled against the "old" format

message Person {
  required string name = 1;
  required int32 id = 2;
  optional string email = 3;

  enum PhoneType {
    MOBILE = 0;
    HOME = 1;
    WORK = 2;
  }

  message PhoneNumber {
    required string number = 1;
    optional PhoneType type = 2 [default = HOME];
  }

  repeated PhoneNumber phone = 4;
}

Person person;
person.set_name("John Doe");
person.set_id(1234);
person.set_email("jdoe@example.com");
fstream output("myfile", ios::out | ios::binary);
person.SerializeToOstream(&output);

<JavaScript>
  // tells the swf if gears is installed
  function isGearsInstalled() {
    if (window.google && google.gears) { //gears is installed
      thisMovie("FlexGears").testForGears(true);    
      return;
    }
    //gears is not installed
    thisMovie("FlexGears").testForGears(false);    
  }

            
  function thisMovie(movieName) {
    if (navigator.appName.indexOf("Microsoft") != -1) {
      return window[movieName];
    } else {
      return document[movieName];
    }
  }
  // ....
</JavaScript>

<JavaScript>
  // tells the swf if gears is installed
  function isGearsInstalled() {
    if (window.google && google.gears) { //gears is installed
      thisMovie("FlexGears").testForGears(true);    
      return;
    }
    //gears is not installed
    thisMovie("FlexGears").testForGears(false);    
  }

            
  function thisMovie(movieName) {
    if (navigator.appName.indexOf("Microsoft") != -1) {
      return window[movieName];
    } else {
      return document[movieName];
    }
  }
  // ....
</JavaScript>

• Improving Browsers in New Ways: Gears++
• Google Gears for Mobile
• HTML 5, Brought to You by Gears
• Gears and MySpace - Search on the Client
• Taking Large-Scale Applications Offline
• Gears Case Studies

• Using GWT to Build a Diagramming Tool
• GWT and Client-Server Communication
• GWT Extreme by Ray Cromwell
• JavaScript and DOM Programming in GWT
• Resource Bundles and Linkers in GWT
• Deferred Binding with GWT

• Alex Russell on “Can We Get There from Here?”
• Spice up Your Apps with Google AJAX APIs
• Yours truly, Dion and Ben, State of Ajax: The Universe Is Expanding
• Steve Yegge on Server Side JavaScript

• Improving Browsers in New Ways: Gears++
• Google Gears for Mobile
• HTML 5, Brought to You by Gears
• Gears and MySpace - Search on the Client
• Taking Large-Scale Applications Offline
• Gears Case Studies

• Using GWT to Build a Diagramming Tool
• GWT and Client-Server Communication
• GWT Extreme by Ray Cromwell
• JavaScript and DOM Programming in GWT
• Resource Bundles and Linkers in GWT
• Deferred Binding with GWT

• Alex Russell on “Can We Get There from Here?”
• Spice up Your Apps with Google AJAX APIs
• Yours truly, Dion and Ben, State of Ajax: The Universe Is Expanding
• Steve Yegge on Server Side JavaScript

With the next release of the SDK, Appcelerator's javascript servicebroker will now automagically (and transparently) switch to using a Gears-enabled servicebroker when talking to your service-backend. That means your application will perform faster because the AJAX communication between client and server (especially for apps using fast polling) will be out-of-process using Gears' worker pool.

You have to do nothing to enable this in your application. When you Appcelerator application loads, a small piece of code will check to see if Gears is enabled and will dynamically load the gears-enabled servicebroker code.

With the next release of the SDK, Appcelerator's javascript servicebroker will now automagically (and transparently) switch to using a Gears-enabled servicebroker when talking to your service-backend. That means your application will perform faster because the AJAX communication between client and server (especially for apps using fast polling) will be out-of-process using Gears' worker pool.

You have to do nothing to enable this in your application. When you Appcelerator application loads, a small piece of code will check to see if Gears is enabled and will dynamically load the gears-enabled servicebroker code.

• Google Web Toolkit 1.5 Release Candidate: The new release candidate is a big one, with big new features. The GWT sessions at I/O were all packed, and I heard a lot of people walking out talking about how the difficult nature of Ajax development means they will be giving GWT a try.
• Google Visualization API update: The "GViz" API was launched within Google Spreadsheets, but now it has been expanded to live elsewhere. This includes a new JavaScript API to create add-hoc data tables on the client.
• Google Contacts API update: The Contacts API now supports contact groups, photos, extended properties, and batch processing

• Developers won't have to worry about getting caching setup correctly, as we will do that for you
• If another application uses the same library (much more likely), they there is a much better chance that it will be already caching on the users machine
• The network and bandwidth of the users systems will not be taxed.

• jQuery
• prototype
• script.aculo.us
• MooTools
• dojo

I've always hoped that I could release Mondrian as open source, but it was not to be: due to its popularity inside Google, it became more and more tied to proprietary Google infrastructure like Bigtable, and it remained limited to Perforce, the commercial revision control system most used at Google.

What I'm announcing now is the next best thing: an code review tool for use with Subversion, inspired by Mondrian and (soon to be) released as open source. Some of the code is even directly derived from Mondrian. Most of the code is new though, written using Django and running on Google App Engine.

I'm inviting the Python developer community to try out the tool on the web for code reviews. I've added a few code reviews already, but I'm hoping that more developers will upload at least one patch for review and invite a reviewer to try it out.

Using iTunes?

• What restrictions are there for serving your applications?
• What Web frameworks are available?
• Can you develop Web services as well as Web applications? How about gadget and widget?
• What kind of traffic can be expect with the free accounts?
• Can I run these applications on my domain, and integrate with Google Apps?

• Quick & Dirty KML Creation: With Mano Marks, Pamela Fox, and Christiaan Adams
  A demonstration of creating KML visually in Google Earth & Google Maps, and using Spreadsheet Mapper 2.0
• Creating Custom Maps: With John Coryat
  A comparison of various ways of overlaying data in the Maps API and an in-depth explanation of creating tile layers and custom map types
• GigaPan In-Depth: With Randy Sargent & Ted Morse
  A demo of the GigaPan panorama-browsing website and KML files, plus a technical explanation of PhotoOverlay
• Dynamic KML: With Mano Marks & Brian Hamlin
  An exploration of using dynamic queries from KML, using the NetworkLink, httpQuery, and viewFormat elements, plus a demo of a PostGIS-generated NetworkLink
• Mars, Moon, and Sky Map Types: With Noel Gorelick
  A talk introducing the non-Earth Maps API map types, plus cool demos of other types of projections used with planetary imagery
• Mapping the Votes: With Michael Geary
  A whirlwind tour of what it took to create the Elections 2008 Map/Mapplet/Gadget, including SHPfile conversion, Javascript optimization, centroid calculations, Twitter updates collection, Mapplet API tricks, and more.
• Google API Talks - Android, KML, Google Maps, Gadgets
  A series of 5-minute talks by various developers and Googlers given before Geary's presentation, including an intro to Gadgets/Mapplets.
  

• Amit Singh on the Google Mac team talked about how you can manipulate keyboard LEDs through software and receive Apple infrared remote control events
• I got to interview Bob Lee about his Twubble app, built using GWT
• Dave Astels talked about flakey tests on the toilet
• Google Code now speaks a lot of languages which apparently caused some students to fix their RSS feed parsers as they didn't grok Unicode

This post is one in a series that previews Google I/O, our biggest developer event in San Francisco, May 28-29. Over the next two months, we'll be highlighting sessions and speakers to give Google Code blog readers a better sense of what's in store for you at the event. - Ed.

• PubTools: Brad developed this set of tools to enable offline caching of content in minutes. This is perfect if you have a set of content that you want to make available offline.


• Google Gears for Mobile: Just yesterday we launched our first Google mobile application using Gears, with Picasa


• Cross Domain Web Services: A good example using Flickr search


• Dojo Storage has just had a new release so it plays in the new Dojo 1.x land, and has a Gears storage engine


• blog.gears: Pamela Fox did a great job with this GData/Gears blogging application


• Gears + Greasemonkey = GearsMonkey

• PubTools: Brad developed this set of tools to enable offline caching of content in minutes. This is perfect if you have a set of content that you want to make available offline.


• Google Gears for Mobile: Just yesterday we launched our first Google mobile application using Gears, with Picasa


• Cross Domain Web Services: A good example using Flickr search


• Dojo Storage has just had a new release so it plays in the new Dojo 1.x land, and has a Gears storage engine


• blog.gears: Pamela Fox did a great job with this GData/Gears blogging application


• Gears + Greasemonkey = GearsMonkey

Class("HardWork", {
    meta: Joose.Gears,
    has: {
        data: {is: rw, init: {}}
    },
    methods: {
        onDoWork: function (result) {
            ok(result == 1001, "Gear Worker returns correct result")
        }
    },
    workers: {
        doWork: function (start) {
            var counter = start;
            for(var i = 0; i < 1000; i++) {
                counter++
            }
            return counter
        }
    }
})

var hw = new HardWork();

hw.doWork(1)

Class("HardWork", {
    meta: Joose.Gears,
    has: {
        data: {is: rw, init: {}}
    },
    methods: {
        onDoWork: function (result) {
            ok(result == 1001, "Gear Worker returns correct result")
        }
    },
    workers: {
        doWork: function (start) {
            var counter = start;
            for(var i = 0; i < 1000; i++) {
                counter++
            }
            return counter
        }
    }
})

var hw = new HardWork();

hw.doWork(1)

The AJAX Search and Feeds team is happy to announce a new member to their API family -- the Language API. This new API boasts two functions, language translation and language detection - which cover 13 languages and 29 translation pairs.

google.language.translate('Gato', 'es', 'en', function(result) {
  alert(result.translation);
});

We are excited to launch the Google Visualization API, a new API designed for visualizing structured data. The API adds the ability to send queries to data sources and process the response. The first data source that already supports this API is Google Spreadsheets. We are also launching a set of visualization gadgets that use this API.

With this API, you can read data from a data source that supports the API. You can read an entire table, or you can run a query on the data source using the API's query language. The query response is an easy to process data table designed to simplify data visualization. It includes both the underlying values and the formatted values, column types, headers and more.

var timer = google.gears.factory.create('beta.timer');
timer.setInterval(function() {
  // get a new db handle on each iteration
  var db = google.gears.factory.create('beta.database');
  db.open('database-xssinterface');
 
  db.execute("BEGIN TRANSACTION");
 
  // find new messages for meps
  var rs = db.execute('select id, message from XSSMessageQueue where recipient_domain = ? and channel_id = ?', [recipient, channelId]);

  // there are new messages for the recipient
  while(rs.isValidRow()) {
          var id   = rs.field(0);
          var text = rs.field(1);
          wp.sendMessage(text, message.sender);
          db.execute("DELETE from XSSMessageQueue where id = ?", [id]); // unqueue message
          rs.next()
  }
 
  rs.close();
 
  db.execute("COMMIT")
 
  db.close();
}, 300);

• Combined and minimized JavaScript and CSS files used throughout the site

• Implemented CSS sprites for frequently-used images

• Implemented lazy loading of Google AJAX APIs loader module (google.load)
  

    <script type="text/javascript" src="http://www.google.com/jsapi"></script>

if (needToLoadGoogleAjaxApisLoaderModule) {
    // Load Google AJAX APIs loader module (google.load)
    var script = document.createElement('script');
    script.src = 'http://www.google.com/jsapi?callback=googleLoadCallback';
    script.type = 'text/javascript';
    document.getElementsByTagName('head')[0].appendChild(script);
}

function googleLoadCallback() {
  // Initialize AJAX Feed API
  google.load('feeds', '1', {callback: startUsingAjaxFeedAPI});
}

function startUsingAjaxFeedAPI() {
  // Start using AJAX Feed API
  var feed = new google.feeds.Feed(someFeedUrl);
  ...
}

• A way to run your Gears code on server, for example, if the user doesn't have Gears installed. In certain use cases, you could decide to run the code back on the server, and offer the user to "speed this all up by installing Gears"
• One API means that you can take tools and code that you have written on top, and have it automatically work on the server too. For example, we have already seen a GearsORM that works behind the scenes

• Mission: Possible - Building a Google Gadget is a fun one, showing you how to build Gadgets in a creative way
• Google IPv6 Conference 2008: What will the IPv6 Internet look like? gives you a look at the future of the internet thanks to a panel discussion
• JRuby: The power of Java and Ruby is a talk given by Ola Bini on the JRuby run time, which follows on from Yukihiro Matsumoto (Matz) talking to us about Ruby 1.9.

• New modules: HttpRequest and Timer. The main reason for these modules was that developers told us they wanted to make HTTP requests and create timers inside Gears workers. But these modules can also be used outside of workers. For example, one advantage to using the Gears HttpRequest module instead of normal XMLHttpRequest is that Gears HttpRequest module addresses a common problem making comet-style applications work on IE.


• Improved support for handling errors in workers. This is an area where we received a lot of good feedback. Now, errors from workers are automatically bubbled up to the main page by default so that you can see them in the error console or in Firebug. Or, you can handle them explicitly with the new onerror event.


• Ability to load workers from a URL, even cross-domain URLs. We've long wanted the ability to load workers from a URL. We've also wanted to provide a way for different domains to communicate safely. This is useful in the case of mashups, or when an application spans multiple domains. The new createWorkerFromUrl API solves both these problems.

var netCheck = new NetworkDetection("ping.html");

netCheck.addEventListener("online", function(eAja){
 $("display").innerHTML = "";
 $("display").removeClassName("offline");
 this.connected = true;
});
netCheck.addEventListener("offline", function(eAja){
 $("display").innerHTML = "d\ni\ns\nc\no\nn\nn\ne\nc\nt\ne\nd";
 $("display").addClassName("offline");
 setHelp("You are disconnected from the Project Draw server.");
 this.connected = false;
});

• How happyhour increases developer productivity when building OpenSocial components
• How designers have been able to work with his OpenSocial applications with happyhour
• How happyhour differs from another open source container, Apache Shindig
• His experience, and lessons learned using Gears
• How he added support for ISO dates for Gears using SQLite

opensocial.HappyHourContainer.prototype.toISO8601String = function (date) {
    var zeropad = function (num) { return ((num < 10) ? '0' : '') + num; }

    var str = "";
    str += date.getUTCFullYear();
    str += "-" + zeropad(date.getUTCMonth() + 1);
    str += "-" + zeropad(date.getUTCDate());
    str += "T" + zeropad(date.getUTCHours()) +
               ":" + zeropad(date.getUTCMinutes())+
               ":" + zeropad(date.getUTCSeconds());
    var ms =  date.getUTCMilliseconds();
    str += "."+(ms < 10 ? "00"+ms : (ms < 100 ? "0"+ms : ms));
    return str;
};

• What Ning is all about
• Why Ning and Brian think about OpenSocial, and why developers should be interested
• The parts and pieces of OpenSocial from the standpoint of a developer, and a third party container
• How Brian thinks that we will get more than just "Write one, learn everywhere"
• What Apache Shindig is all about
• How Shindig allows you to do simple local development, which changes the game with respect to your development lifecycle

• Google Gadgets: Experiences of a Top Developer
• Making the most of maps
• Zoho Writer: Read Write
• Upcoming Changes to the JavaScript Language
• Poker Teaches (for something a little different)

Using iTunes?

• Some history behind the project
• The high level architecture of Android. For example, how Linux processes handle the VM and manage security (the VM doesn't handle it)
• Details on the Dalvik VM and how it is optimized for small devices
• The architecture: From Intents to Views to Permissions and more
• How XML is slow, but the tools convert the XML to a nicer format for you
• The tooling and steps for building an application on Android
• How so many objects have a URL, and how the environment is like a mini-SOA (Services across processes instead of across the network)
• Thoughts on how you program for small devices, and things to watch out for if you move from the desktop
• The control, or lack of control that you have over the application lifecycle
• "Everything you do drains the battery"
• The thread story: they exist, you don't have to deal with them if you don't want too, and the UI
• Using XMPP for messaging

• Use JavaScript, not JScript
• WebKit is case-sensitive, JScript is not, which can lead to problems if you assume can you do things like interchange SetTimeOut() and setTimeout().
• Avoid JScript-only features like collections and ActiveX.
• Avoid IE-specific DOM extensions, just as if you were writing a multi-browser web application.
• Avoid Windows-specific APIs
• You shouldn't assume ActiveX or certain DLLs are available. Neither WebKit nor Mac OS X supports ActiveX, so these gadgets must be rewritten.
• Avoid Windows-only APIs such as Google Talk. These APIs are not (yet) available on Mac OS X.
• Understand how Dashboard is different
• The Dashboard environment is very different from a web page or the Desktop sidebar on Windows in that it comes and goes as the user activates it. Don't rely on your gadget always being visible. Your gadget won't run or update when Dashboard isn't in the foreground.
• Don't rely on access to the file system. The security model for Dashboard doesn't allow arbitrary file access to the hard disk, although your gadget does have access to files in its own archive. Things like file pickers won't work. Note that while restricted file system access is a departure from how gadgets work on Windows, it's consistent with Dashboard's security model and the behavior of other widgets developed for Mac OS X.