Posted:


Ever wondered how to create maps like this Primary Election Results Map, created by Michael Geary? If so, please join us in at the Googleplex (Bldg 43, main campus, room Tunis) on the evening of April 2nd. Michael will be on hand to show you how. This gathering is being co-hosted by the Google GEO Developer Series and the recently formed Silicon Valley Google Technology User Group (which is not affiliated with Google). A networking hour with food and drinks starting at 5:30pm will be followed by Michael's talk at 6:30pm. Although this is a free event open to all, we do ask that you register in advance.

During the evening, we're also inviting community members to come forward and do short (no more than 5 minutes) demos of their own Google GEO applications during the networking hour. If you would like to participate in that way, please contact me. I'll be coordinating the networking hour demos. That's all, folks.

Posted:


If you've ever wanted to make your favorite software or website work with Google's Picasa software, there's a new Picasa Button API that lets you add your own buttons to the desktop interface.


The BlogThis! button in Picasa uses these APIs.

These buttons can send files to other applications on your PC, -- this tutorial (.zip) shows how to send files to Adobe Photoshop CS3 -- and they can also upload photos and movies to websites of your choice.

I'm most excited about our Web Uploader API. It uses a protocol we developed for posting photos to Blogger a couple years ago, and it shows a web-based preview of what you're going to upload before you send it. Using the web uploader, you can make user interfaces that feel more like sending an email and less like "Wait an hour to upload..." Picasa can also resize files before sending, saving time. There's some sample PHP code (.zip) to try out.

Also because these new buttons can be made by anyone, it means that there's no job too small for a Picasa button. You could make a button for your personal blog or for your major photo hosting service. See our demo video, which features Smugmug.

If you live near Mountain View, California, come out for Thursday's Youtube/Picasa Hackathon. We'll be showing off examples of these APIs, and answering questions to help you get started with them.

Posted:


Today we are pleased to announce that Google is joining together with Yahoo! and MySpace in the creation of a non-profit foundation for the open and transparent governance of the OpenSocial specifications and intellectual property. This foundation, modeled after the community-led and industry-supported OpenID Foundation, will seek to ensure that the technology behind OpenSocial remains implementable by all, freely and without restriction, in perpetuity. The establishment of the foundation is a necessary and exciting next step toward an open model for application syndication via an increasingly socially-enabled Internet, and we invite and encourage your involvement as we complete this process over the next several months.

Additionally we are pleased to be a part of the launch of opensocial.org, the new official home for the OpenSocial specifications and developer community. While we are still in the early stages of putting the new site together, we wanted to open the site and the process immediately for community feedback and review.

So please join us, Yahoo!, MySpace, and all of the other OpenSocial containers and application providers, in extending a warm welcome to the community in a spirit of collaboration and rapid iteration, as we move forward with the establishment of the OpenSocial Foundation and look ahead to the continued growth of the social web.

Posted:


I got to meet developers in Colorado this week. Working from the Google Boulder office with its fun climbing wall (*so* Boulder) was a treat, and there were several API announcements that were really exciting.

First of all we had the YouTube API update. The new APIs for YouTube are very broad. Not only do you have new access via AtomPub (e.g. to upload), but you can now have fantastic control of the player with a very simple JavaScript API.

In a matter of minutes I was able to create a simple HTML little language that allows me to annotate my YouTube videos with a table of contents that jump to the correct place.

To listen to the great new features, listen in below:



Then we had the rash of new AJAX APIs.

Google AJAX Language API:

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.

All this with a couple of simple JavaScript calls such as this:

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

Google Visualization API:

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.

Staying with visualization and charting... we had a great response to the initial Google Chart API launch, and the team came back with new features allowing very cool new graph types, and lifting the limits on chart calls.

All of these APIs share the same property of doing their thing very well, and providing a simple API to the developer. I hope you will agree, and if not, let us know what you need!

In the land of Google Gears, a couple of external libraries were features. Malte Ubl provided a nice little abstraction for cross domain messaging which uses HTML 5 postMessage(), else Gears, else a browser hack to make the beast work on all browsers.

That is for Worker pools, and with the Database API we saw Aptana releasing an update to their server-side JavaScript database API allowing you to use the Gears API on the server.

Google Code itself got some love. We have improved performance on the site and Jacob Moon shared how we did so.

Then we added an interactive developer guide that allows you to try code on the fly as you go through the GData JavaScript API. It feels good to be able to massage and play as you go.

Finally, we announced Google I/O which is "a two day developer gathering on May 28th & 29th in San Francisco. The purpose of the event is to bring developers together to learn about products, tools, and techniques which are moving the web forward as a platform." If you would like to mingle and join Google engineers, and other Web luminaries as we discuss how to move the Web forward, join us!

Posted:


Many of the features you've requested via Google Chart API forum are now live in the Google Chart API:

  • Easily create Sparklines (&cht=ls) without having to manipulate other kinds of graphs.

    sparkline

  • Support for Radar charts (&cht=r or &cht=rs) to display data in a polar coordinate system.

    radar chart

  • A new Map chart type (&cht=t) which makes it easy to colour countries and regions according to your data.

    thematic map of europe


Some other changes we've made:
  • Added scaling for text encoded data
  • Added support for negative numbers on bar charts
  • Added ability to draw data lines on bar charts

You can read more about all of this -- plus the fact that we've lifted the 50,000 queries per day limit -- on the Chart API site. And special thanks to our Technical Writer Lesley Burr, who put together this documentation in her 20% time.

Posted:


We spend a fair amount of time on data display and visualization projects at Google, and we have found that the "last mile" of these projects tend to become full projects in and of themselves.

Thus when we acquired Gapminder last year, we were excited by the opportunity to use Gapminder's powerful visualization techniques to bring new life and usefulness to Google datasets. And we were not alone -- the web is home to a vibrant community of developers who build amazing visualization applications.

With the community in mind, we're please to introduce the Google Visualization API, which is designed to make it easier for a wide audience to make use of advanced visualization technology, and do so in a way that makes it quick and easy to integrate with new visualizations.

There are a two key elements here: simplicity and ubiquity. We hope we nailed the first, but of course we want to hear your feedback on that. The second will take more time, but we hope we're on the right path. We're releasing this API at an early stage so we can get continuous feedback and be sure we're building it the right way.

This launch is in tandem and in cooperation with the Google Docs team, who just announced support for gadgets and the Visualization API in spreadsheets. This includes a set of gadgets created by Google and several other companies, including some that add pivoting, grouping, and other new functionality to your spreadsheets. You can see all of those in our 'featured' list within the visualization gallery, which includes the Gapminder Motion Chart that has proven especially popular among within Google.

We hope you're as excited about the Google Visualization API as we are -- please be sure to tell us what you think. We'll also be at Google I/O on May 28-29 for deeper discussions about the API or visualization techniques in general.

Posted:


Last summer we launched a site aimed to help educators and students alike become more familiar with the technology behind Google and the massive internet in general. Recently, we've redesigned that site and given it a fresh name: welcome Google Code University.

Google Code University is a growing repository of computer science educational material including tutorials, lecture slides, and videos. Since the initial launch last summer, we've added a lot of new content -- for example, a few months ago we blogged about course material that the University of Washington developed with us on large-scale distributed computing. Recently, we've added tutorials on MySQL and Subversion. And there's a new series of lectures from an introductory web programming class taught at the University of Washington. The site's still growing, and we'll keep adding more content in the coming months.

Most importantly, most of the course materials are Creative Commons licensed, so we encourage educators and students to reuse and build upon them. If you have questions, comments, or materials you'd like to share, please visit the forum. We'd love to hear your feedback and have you contribute to the site.

Posted:


We got a lot of feedback after releasing the Google Chart API in early December. By far the most questions were about the limit of 50,000 queries per user per day. Some of you who are webmasters of larger sites are afraid of overstepping this limit. We've heard your concerns, and have decided to drop that limit altogether.

However, should you expect to regularly cause more than 250,000 queries per day to the Google Chart API, we'd like you to let us know by mailing chart-api-notifications@google.com so that we can plan for the demand.

And with that said, from now on, if your site can't handle the Slashdot effect, it shouldn't be because of the Google Chart API. ;)

But why did we impose a query limit to start with? It was there to ensure that we could provide a reliable service for all legitimate users because we were able to lock out malicious users.

We work hard to provide reliable services, and even have a specific team of site reliability engineers (SRE) dedicated to keeping our services up and running (as well as fast). I cover the Chart API for SRE. A very important part of an SRE's work is capacity planning, because only a service with sufficient capacity can serve reliably and with low latency. For a new service, planning the capacity is naturally very hard, because there are a lot of unknown contributing variables. That's why we started with a quite conservative query limit. Now, that we've had the public API running for some time, we've collected enough experience to feel comfortable raising that limit without jeopardizing the service's reliability.

By the way, there's a lot more to what an SRE does. We also run, debug, optimize and troubleshoot very large scale distributed systems. If you're interested, come join Google SRE -- for instance the Zürich SRE team, where I work.

Posted:


As promised in my last post announcing the new YouTube developer offerings, we're hosting a hackathon for the YouTube and Picasa Web Albums APIs at the Googleplex on March 27th, 2008.

We'll give overviews of both APIs, go over new features, and run some codelabs to get you started. If you're already familiar with both the APIs, stop by to meet the teams, ask questions, and find other developers to work on projects with.

There will be two sessions -- one from 3PM - 6:30PM and another from 6:30PM - 10PM. Feel free to stay the whole day, or just come for the session you have time for. Don't worry about food and caffeine -- we've got you covered.

Interested? Please RSVP and let us know.

Hope to see you there!

Posted:


If you're a frequent visitor to code.google.com for product updates and reference materials for Google APIs you're working with, you might have noticed that the page loading time (or page rendering time depending on how you see it) has reduced in varying degrees in the past several weeks.

As you'll see below, we've made several changes to help reduce user-perceived latency. This is not an exhaustive list of all improvements we've made recently, but these are the major ones we've made.

As Steve Souders emphasizes as the "Performance Golden Rule" in his book High Performance Web Sites, "only 10-20% of the end user response time is spent downloading the HTML document. The other 80-90% is spent downloading all the components in the page (p.5)".

We agree. That's why we focused our effort on reducing the number and size of downloads (HTTP requests) for the "components" throughout Google Code.
  • Combined and minimized JavaScript and CSS files used throughout the site
Downloading JavaScript and CSS files blocks rendering of the rest of the page. Thus, to reduce the number of HTTP requests made on the initial page load, we combined frequently-used JavaScript and CSS files into one file each. This technique has brought down 20 HTTP requests down to just 2. We also minimized the files by stripping out unnecessary whitespace and shortening function/variable names whenever possible.
  • Implemented CSS sprites for frequently-used images
There are 7 images prominently used throughout Google Code, including the Google Code logo, the googley balls at the bottom of every page, the plus and minus signs as well as the subscribe icon inside each blog gadget.

Although browsers usually download several images in parallel, we concatenated these images into one image so only one HTTP request would be made. Of course, concatenating several images into one required us to make several changes in HTML/CSS. For example, instead of having:

<img src="/images/plus.gif" />


We had to change it to:

<div style="background-image:url(/images/sprites.gif); background-position:-28px -246px; width:9px; height:9px">&amp;</div></span>


where sprites.gif is the concatenated image and background-position and width/height carefully calculated.
  • Implemented lazy loading of Google AJAX APIs loader module (google.load)
We like to eat our own dogfood. Among other APIs, we use our very own AJAX Feed API on product homepages inside the blog gadgets and the AJAX Search API on the search page. These Google AJAX APIs require the Google loader module (google.load) to be loaded first before any of the specific AJAX APIs (i.e. AJAX Feed API, AJAX Search API, Maps API) can be initialized and used. Traditionally, the Google AJAX APIs loader module would be loaded by including the following <script> tag in the <head> section:
    <script type="text/javascript" src="http://www.google.com/jsapi"></script>
This works well in most cases, but when optimizing for the display of static content, this blocks the browser from rendering the rest of the page until it's finished loading that script, thus impacting the user-perceived latency. So instead of loading the Google AJAX APIs loader module upfront, we are now loading it lazily only on the pages where it's required. This is made possible as follows (please note that this is a stripped-down version of what we have on Google Code):

First, in the <head> section, we load the Google AJAX APIs loader module via DOM scripting only on the pages where it's required:

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);
}
It's important to add the 'callback' parameter in the src attribute, 'callback=googleLoadCallback'. This callback handler will then be called whenever the Google loader module is finished loading.

Then, in the Google loader callback handler (googleLoadCallback()), we initialize the AJAX Feed API and provide the function name that utilizes the AJAX Feed API (startUsingAjaxFeedAPI):
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);
...
}

In effect, we're loading the AJAX Feed API on-demand through the use of two consecutive callback handlers, first to load the Google AJAX APIs loader module (google.load) and then to initialize the AJAX Feed API before it's used. Similar technique can be used for the Maps API and the AJAX Search API.

By now you're probably wondering just how much of an impact did these changes have on Google Code anyways? According to our latency measurement stats, the user-perceived latency on Google Code dropped quite a bit, anywhere between 30% and 70% depending on the page. This is a huge return for relatively small investments we've made along the way, and we hope you'll find these techniques useful for your own web development as well.

Posted:


Ever wanted to get in on the online video craze? Now's a good time! We've just added upload, write, and authentication functionality to the YouTube Data API. Brand new player APIs and tools are also now available.

That means that if, for example, you run a site just for iguana enthusiasts, your users can upload videos of JubJub to their YouTube accounts, post comments, create iguana playlists, and more, all without leaving your site. And with the new player APIs and the new chromeless player, you can completely customize and skin the YouTube embedded player to match the look and feel of your site (a green theme, buttons that look like scales?).

So excited that you can't decide what to do next? Read more details over at the YouTube API blog, watch our engineers talk about the new features (on YouTube, where else?), check out the docs, then join the forum.

You can also mark your calendars -- we'll be holding a YouTube / Picasa hackathon on March 27th at the Googleplex in Mountain View. Stay tuned for more info.

Posted:



Its been about a year since I last blogged about a big Google developer event. During that time, we’ve seen a number of new technologies emerge which developers can use to build killer web applications. OpenSocial, Gears, and Android are a few that come to mind. But there is also a lot to learn if you really want to get the most out of these products.

That’s why I’m excited to announce Google I/O, a two day developer gathering on May 28th & 29th in San Francisco. The purpose of the event is to bring developers together to learn about products, tools, and techniques which are moving the web forward as a platform.

We've divided Google I/O into five topic areas: AJAX, APIs & Tools, Social, Geo, and Mobile. There's, of course, a focus on Google products, but the event won’t be limited to just Google APIs and developer tools. There is a lot of knowledge about web development in general at Google, and we’d like to share that expertise so that all applications on the web get better.

Over the two days, Google engineers and other leading software developers will share their knowledge in breakout sessions, hands-on Code Labs, and Q&A Fireside Chats.  Just a few of those speakers and what they'll be covering:

  • David Glazer, Director of Engineering - OpenSocial
  • Mark Lucovsky, Director of Engineering - AJAX APIs
  • Brad Fitzpatrick, Software Engineer - Social Graph API
  • Dion Almaer, Technical Program Manager and co-founder of AJAXian.com - AJAX
  • John Panzer, Technical Manager - Shindig
  • Guido Van Rossum, Software Engineer and creator of Python - Python and Google APIs
  • Chris DiBona, Open Source Programs Manager - Open Source
  • Bruce Johnson, co-creator of Google Web Toolkit - Google Web Toolkit


We're doing our best to make this a can't-miss event for web app developers. Visit the Google I/O website to learn more and register.  Space is limited, so be sure to make plans to attend now.

PS. If you are wondering whether we’re still having our global Google Developer Day series, the answer is a definite yes. We’ll be rolling out Developer Days to a number of countries outside the US. Look for an announcement of dates and locations soon.


Posted:


What a week for technology news. I feel like the industry is in overdrive this week as we have large announcements in mobile (e.g. iPhone SDK, Gears for Mobile), and we get to see a beta of IE 8 for the first time.

I was very happy to see the actual release of Google Gears for Mobile. I had just been visiting the London office where I got to chat with the team behind the mobile launch. I enjoyed hearing the story behind the birth of Gears for mobile, and their thoughts on where mobile development is heading. It seems like we hear people claiming the breakthrough of the mobile Web every year, but 2008 may finally be the right time. We are getting the combination of devices that are good enough, and better networks. The tools that Gears provides seem to almost make more sense in the mobile world, and I look forward to seeing the community build new Gears to unlock the power of the mobile devices and put that functionality into the hands of Web hackers.

Listen in to the conversation below:



The mobile release happened right as Brad Neuberg and myself were doing a mini mid-west tour of the University of Illinois Urbana/Champaign, and the University of Michigan. It was great to meet the students and see their views on the Web. Speaking on Gears at the birth of the Web browser was also a real honour.

Death to scrap-y

Whenever I see an application that asks for my Google username and password to scrape contacts I would cry. This isn't what we want users doing, but I really understand the users are asking for the functionality of mashing up their contact data, and no-one wants to re-enter it. You can't blame third party applications for offering the functionality, and now they don't have to do it insecurely. The release of the Google Contacts API offers an AtomPub based way of consuming your contacts.

Another feature that our users keep asking for is Google Calendar sync, and we just got the Outlook sync product out to you too.

There were a couple of interesting pieces of news in the Maps space. You now have access to a new static map API that gives you a snapshot image of the map instead of an embed-able interactive widget.

Pamela Fox also put together a rich Google Maps API Gallery that answers questions such as: "How do I draw a circle on the map?" or "How do I create groups of toggle-able markers?"

The open source side of Google has been busy too. The Summer of Code 2008 has launched, so start thinking of cool projects for the students to get hacking on!

We also have a group heading to PyCon 2008, so join us there as we give a talk titled: Use Google Spreadsheets API to create a database in the cloud.

Lindsey Simon created a very cool little tool, CSSJanus, that lets you take your CSS styled Web site and create a right-to-left version for locales that need it. He talked about the work behind it, gave a screencast showing it in action for you.

Finally, there are some other cool videos to check out too (it's Friday!)

As always, check out the latest tech talks, subscribe to the Google Developer Podcast and visit the Google Code YouTube channel.

After we take a breather from this week, see you next time!

Posted:


A common contact list has helped power applications like Gmail, Google Reader, and Google Calendar. And now, with the launch of the Google Contacts Data API, we're opening up this contact list to your applications as well.

Based on AtomPub, the Contacts API can be used to safely read, create, edit, and delete contact information stored with Google, all while keeping users' passwords private via delegated authentication and authorization. Learn the details from Sebastian Kanthak in his announcement post on the Google Data APIs blog, and join the conversation on the Contacts API Group.

Posted:


It's a mobile zoo out there. If you've ever tried coding up a mobile client application, you've probably noticed that the huge variety of mobile operating systems makes it tough to build rich applications that work on every device. We face the same challenges. But what if developers could deploy applications directly to mobile browsers rather than develop native applications? That would simplify the development process, as developers could use the same coding skills to create mobile applications. Even better, if these mobile web applications could work offline, users would be able to use them when they are disconnected from the network.

Developers, look no further. Today we're announcing the launch of Google Gears for mobile, a mobile browser extension for creating rich web applications for mobile devices. The first version is now available for Internet Explorer Mobile on Windows Mobile 5 and 6. It's a fully functional port of Google Gears v0.2 that can be used to develop offline capability into your mobile web applications. You can also create slick and responsive applications by hiding latency issues through controlled caching of data and storage of information between sessions. We're also working to bring Google Gears for mobile to Android and other mobile platforms with capable web browsers.

There are already a handful of Windows Mobile web apps that use Google Gears for mobile, such as the personal finance service Buxfer and online applications provider Zoho.  Read more about these applications and how they use Google Gears for mobile on the Google mobile blog.

For more on the vision for Google Gears for mobile and its origins, watch this video.

Posted:


It may only be March, but the heat is on — Google Summer of Code is back for 2008! Last year, nearly 900 students teamed up with over 2,000 mentors to write millions of lines of code. We're looking forward to another year of introducing university students to open source development and helping our colleagues in the open source world find new contributors and get more code written.

We're taking applications from open source projects who'd like to mentor students today through March 13th. For full details, see the program site.

We'd love to hear from you, so join us in #gsoc on Freenode or join the program discussion list.