Friday, April 10, 2009

[Gd] Google Narratives Series: Chirag Mehta

| More

Google Code Blog: Google Narratives Series: Chirag Mehta

It's time for another Google Narrative, highlighting a Google AJAX Search API developer, Chirag Mehta.

Chirag is developer in Gainesville, Florida who got started coding on a ZX Spectrum almost twenty years ago and has dabbled in graphics, animation, databases, ERP/CRMs, and productivity apps. He is currently working as an IT director and is in a graduate program in Technology Management at University of Tampa. He co-founded Chime.TV in 2007 and Sched.org in 2008. His favorite area of development is simple web utilities. Chirag and his wife love animals and when he's not coding or studying, he is either kayaking or playing with their pets.Q: Tell me about how you used Google AJAX Search API for Wiki Search and Drop Search and how you came up with the ideas.

A: My wife's currently in medical school and constantly doing searches online for medical terms. Wikipedia offered tons of information but she found their search feature to be insufficient for her needs. 90% of the time, you have no idea what you're searching for or guessing at it - it doesn't do anything to help you out. I wanted to help my wife have a faster, more dynamic experience so I brainstormed how to build a XML-type of search feature, similar to Google Search Suggest, while you were on Wikipedia. (It also helped that I'd always found Wikipedia interesting and researched databases that used it as a source of information.) That also led me to start looking at implementation options and of them all, AJAX Search seemed the easiest to integrate in a quick manner. Instead of taking two weeks to research documentation and then implement with other APIs, it took about an hour with Google AJAX Search. Also, I had worked with many Google APIs on other projects before, but the Google AJAX API was the best. The speed was amazing!

The idea for creating Drop Search came soon after fiddling with more Google AJAX search documentation. My implementation gives the everyday person without a programming background the ability to add a customized search engine to any site. It's code that you can copy and paste into your application and customize for your own needs using CSS, which I did for my own blog. A friend of mine at Rutgers University saw what I did and wanted the same type of feature for their professional development site so I released the code that I created to everyone on my projects page.

Q: Describe any obstacles you had with implementation.

A: There were none. Actually I had a couple of questions at first but I looked at the forums and got the answer fairly quickly. They were around legal issues - Am I allowed to query as I type? Is it legal that I'm doing this with Wiki search? I wish legal terms were much clearer on Google Code. I had some assumptions, only to find out they were recommendations rather than requirements. I do have to say that the documentation on Google Code is perfect. One minute you're reading documentation, the next you're in the forums reading about other developers' experiences. Help pages are broken down into every bit so it makes coding a cakewalk. It's a really good experience compared to other sites.

Q: Can you provide any tips for other developers using Google AJAX Search API?

A: Before you try to build something, find out if Google already has. Google will build 98% of your needs on the back end, leaving you 2% of the work to focus on making your user interface exactly what you need for the front end. Also, another tip... listen to your wife's complaints.
Thanks for your time Chirag! We love hearing from developers in our community about inspiring stories, so if you have something you'd like to share, visit our online submission form. Or better yet, come to Google I/O and tell us your story in person.

By Christine Songco, Google Code Team
URL: http://google-code-updates.blogspot.com/2009/04/google-narratives-series-chirag-mehta.html

Thursday, April 9, 2009

[Gd] Deprecation policies posted for 5 more APIs

| More

Google Code Blog: Deprecation policies posted for 5 more APIs

We just posted updated terms of service for 5 more APIs to include transparent deprecation policies. This is part of their increased commitment as graduates of Google Code Labs. As we mentioned in March when we introduced Labs, each of these deprecation policies states that we'll support each version of the API for a guaranteed length of time from when it's deprecated or a newer version is introduced. While it's 3 years for most, it might be less for some. With this batch of updates, for example, the Checkout API has a policy of supporting old versions for 1 year while all of the others will support old versions for 3 years.

You can see the updated terms for all 5 APIs:

By Neel Kshetramade, Google Developer Programs
URL: http://google-code-updates.blogspot.com/2009/04/deprecation-policies-posted-for-5-more.html

Wednesday, April 8, 2009

[Gd] eBay's Farhang Kassaei announces "Selling Manager" as an OpenSocial gadget implementation

| More

Google Code Blog: eBay's Farhang Kassaei announces "Selling Manager" as an OpenSocial gadget implementation

In this video, eBay Platform Architect Farhang Kassaei explains the details behind the launching of eBay's new Selling Manager (beta), which uses OpenSocial's gadget technology to Google Developer Advocate Chris Schalk at the Web 2.0 Conference in San Francisco, CA on April 1st, 2009.

Farhang describes both why they chose to use OpenSocial and Apache Shindig, and how they integrated its gadget server technology into their platform. He also provides information on where gadget developers can go to learn more about eBay's new platform and how to get started building applications.



Farhang Kassaei is a principal architect at eBay Marketplaces where he leads eBay platform design and architecture. During his career with eBay Farhang has been responsible for multiple infrastructure initiatives including identity and access management, open platform, user verification and risk, messaging, user generated content and user graph analysis and infrastructure. He is also a member of eBay Enterprise Architecture team.

Chris Schalk is a Developer Advocate on Google's Developer Programs team.

By Neel Kshetramade, Google Developer Programs
URL: http://google-code-updates.blogspot.com/2009/04/ebays-farhang-kassaei-announces-selling.html

[Gd] Dev Channel Update: 2.0.173.1

| More

Google Chrome Releases: Dev Channel Update: 2.0.173.1

Google Chrome's Dev channel has been updated to 2.0.173.1. This was mostly a bug fix crash/ release.

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

Notable Changes:
  • Fixed a plugin crash related to FoxIt reader. (Issue: 9539)
  • V8 proxy resolver support is now enabled by default, and is no longer behind a flag. (Issues: 2764, 74)
  • Added a localizable font family and font size for rendered web content. This allows Chrome to display larger characters for certain international font families (e.g. Malayalam and Bengali). (Issue: 7319)
  • Fixed a crash which occured when canceling a save page operation. (Issue: 9738)

Last Week's Known Issues Fixed:
  • Cannot drag bookmarks on then New Tab page (Issue 9674).

Known Issues
  • Mouse wheel scrolling does not scroll windows that aren't focused (9647).
  • Google Calendar widget not updating properly (Issue 8935)

Please let us know about the issues you find by filing a bug, but please search the open issues first.

A detailed list of changes in this release is in the release notes.

--Anthony Laforge
Google Chrome Program Manager
URL: http://googlechromereleases.blogspot.com/2009/04/dev-channel-update-201731.html

[Gd] AdWords Downtime: April 11, 10am-2pm PDT

| More

AdWords API Blog: AdWords Downtime: April 11, 10am-2pm PDT

We'll be performing routine system maintenance on Saturday, April 11 from approximately 10:00am to 2:00pm PDT. You won't be able to access AdWords or the API during this time frame, but your ads will continue to run as normal.

Cheers,
-Jeffrey Posnick, AdWords API Team
URL: http://adwordsapi.blogspot.com/2009/04/adwords-downtime-april-11-10am-2pm-pdt.html

Tuesday, April 7, 2009

[Gd] Seriously this time, the new language on App Engine: Java™

| More

Google App Engine Blog: Seriously this time, the new language on App Engine: Java™

Today, we're very excited to announce the availability of a new programming language for Google App Engine. Please welcome the Java runtime!

When the two of us first heard the promise of Google App Engine, we realized that the chance to bring this kind of simplicity to Java developers was too good of an opportunity to pass up. When App Engine launched publicly, we were excited to see that Java language support was both the first and the most popular request filed in the Issue Tracker. We were also thrilled to see that this enthusiasm extended beyond the Java language to all of the various programming languages that have been implemented on top of the Java virtual machine -- not to mention all of the popular web frameworks and libraries.

But we also knew that Java developers are choosy:

  • They live by their powerful tools (Eclipse, Intellij, NetBeans, Ant, etc.).
  • They try to avoid lock-in and strive for re-use. Standards-based development (defacto or otherwise) is key.
  • They harness sophisticated libraries to perform language feats which are nearly magical (GWT, Guice, CGLIB, AspectJ, etc...).
  • They even use alternate languages on the JVM, like Groovy, Scala, and JRuby.

We wanted to give developers something that they could be ecstatic about, but we knew we would have to marry the simplicity of Google App Engine with the power and flexibility of the Java platform. We also wanted to leverage the App Engine infrastructure -- and by extension Google's infrastructure -- as much as possible, without giving up compatibility with existing Java standards and tools.

And so that's what we did. App Engine now supports the standards that make Java tooling great. (We're working on the tooling too, with Google Plugin for Eclipse). It provides the current App Engine API's and wraps them with standards where relevant, like the Java Servlet API, JDO and JPA, javax.cache, and javax.mail. It also provides a secure sandbox that's powerful enough to run your code safely on Google's servers, while being flexible enough for you to break abstractions at will.

There is a vast amount of Java code out there, much of it written without consideration of sandboxing, and we can't test it all. We know that there will be some rough edges when it comes to compatibility, but we're looking forward to working with you to smooth those out. To that end, we're giving the first 10,000 interested developers an early look at Java language support, so please sign up, give it a whirl, and give us lots of feedback.

The team has also been working on many other improvements to App Engine, which we're really excited to launch to you as well:

  • Access to firewalled data: grant policy-controlled access to your data behind the firewall.
  • Cron support: schedule tasks like report generation or DB clean-up at an interval of your choosing.
  • Database import: move GBs of data easily into your App Engine app. Matching export capabilities are coming soon, hopefully within a month.

Last but not least, the App Engine team will be at the upcoming Google I/O developer event on May 27-28 in San Francisco, so please come meet us in person.

We look forward to seeing your applications. Get coding!

Posted by Don Schwarz and Toby Reyelts, Software Engineers, Google App Engine Team

Java is a trademark or registered trademark of Sun Microsystems, Inc. in the United States and other countries.

URL: http://googleappengine.blogspot.com/2009/04/seriously-this-time-new-language-on-app.html

[Gd] Introducing GWT 1.6 and friends

| More

Google Web Toolkit Blog: Introducing GWT 1.6 and friends

Starting today, there is a simpler way to use the JavaTM language to develop and deploy world-scalable web applications. We are very happy to announce today:



What does this mean for you? It is easier than ever to create sophisticated web applications entirely in the Java language with Google Web Toolkit while working productively in Eclipse. And the
moment you're finished, with only a few button clicks you can upload and publish your application to the world on App Engine.


In GWT 1.6, we've tried to make common tasks simpler while making it possible to do even more advanced things. If you're brand new to GWT, some of this is going to sound like gibberish, so
you'll also want to take a look at the Product Overview as a gentler introduction.


Direct support for war output and related tools



  • GWT 1.6 changes the conventions for project organization to center on the standard Java web archive deployment structure. This new war support makes it easier to introduce GWT modules into
    existing web applications. It also makes GWT development more flexible by allowing hosted mode to work easily with any standard servlet container. 

  • In conjunction, there is a new webAppCreator tool which replaces the older projectCreator and applicationCreator tools. It is a unified, war-aware tool that can quickly create a working GWT
    module, configuration files, source files, and an ant build file that you can use as a starting point for your own code.

  • And, of course, it's pretty easy to create a war directory layout that you can upload to App Engine.



Hosted mode and compiler enhancements



  • Hosted mode has been enhanced to take advantage of the new war-centric project structure to provide additional conveniences. For example, the new "Restart Server" button reloads server-side
    code without you having to restart your debugger, which can save you time when you're developing RPC services. Also, for you GWT experts out there using hosted mode with your own custom servers —
    if you know what "-noserver" is, I'm talking to you — you'll be glad to know that hosted mode integration "just works" now; generated resources such as bundled image files are automatically
    recreated when you refresh the hosted browser. This, too, can help speed up your development cycle.

  • Hosted mode has also been modified to work smoothly with EMMA's on-the-fly instrumentation, so that you can easily generate code coverage reports. If you're an Eclipse user, in addition to using the new Google Plugin for
    Eclipse, you should also look at EclEmma, which makes it easy to enable code coverage for any launch configuration. 

  • Finally, the GWT compiler has gone parallel. It can compile multiple output permutations in parallel using the new -localWorkers flag, which can speed up web mode compiles noticeably on
    multi-core machines. In more elaborate build systems, it is also possible now to do parallel distributed compiles using the new compiler lifecycle classes Precompile, CompilePerms, and Link.



New widgets and a shiny new approach to event handling



  • A big change that you will surely notice is GWT's overhauled event handling. The new Handler pattern for managing widget events is easier to understand and more succinct
    than in previous releases. Widget writers can also easily create their own custom events.

  • The customizable and internationalized DatePicker is now a standard widget, and the new LazyPanel helps you speed up your code by delaying the creation of widgets until they're actually
    needed.

  • There's also a new API for triggering browser native events programmatically, which is a real boon for unit testing. 



As usual, there are many more improvements than we can list above. The issue tracker has the
full list of changes
. We hope that these new features in GWT 1.6 will seem like only the beginning, though, as you start to using GWT alongside the new Google Plugin for Eclipse and deploying your
code on App Engine. There's lots more to come on how these technologies work together to help you do cool new stuff faster.


Last but not least, the GWT team will be at Google I/O on May 27-28,
giving in-depth sessions on GWT and eager to hear your feedback on these new features. We hope you'll join us.



Download Google Web Toolkit 1.6

URL: http://googlewebtoolkit.blogspot.com/2009/04/introducing-gwt-16-and-friends.html

[Gd] Google Plugin for Eclipse™ — Peanut Butter to Eclipse's Chocolate

| More

Google Web Toolkit Blog: Google Plugin for Eclipse™ — Peanut Butter to Eclipse's Chocolate

Eclipse™ is a delicious Java™ IDE. However, developers using it to create Google Web Toolkit (and now Google App Engine for Java) web applications have found themselves wanting better integration.

That's why we are very happy to announce the first release of the Google Plugin for Eclipse. Not only does the plugin make it easier to work with App Engine for Java and GWT; it also makes projects using both easier. A few key features:

New Web Application Wizard

Quickly create web applications that use GWT and/or App Engine. Your new application is fully configured and ready to go.

Run/Debug Web Application
With a single click, you can run or debug your web application locally. No more command-line headaches!

Google App Engine for Java

Deploying your application to the cloud is easy with the deploy wizard...


As-you-type validation ensures that your code is compatible with App Engine.

Google Web Toolkit

We've enhanced Eclipse's Java environment to integrate seamlessly with GWT:

  • Recognition of inline JavaScript (JSNI): syntax highlighting, auto-indenting, Java Search and Refactoring integration
  • GWT compiler shortcuts and configuration UI
  • Wizards to create entry points, modules and HTML pages

Ready to dig in?

URL: http://googlewebtoolkit.blogspot.com/2009/04/google-plugin-for-eclipse-peanut-butter.html

[Gd] Standards-based Persistence For Java™ Apps On Google App Engine

| More

Google Code Blog: Standards-based Persistence For Java™ Apps On Google App Engine

When I sat down to write this post I decided to glance back at my last post on this blog. One sentence in particular jumped out at me: "...I would never again feel compelled to build an [Object-Relational] Mapping framework in Java." Well, friends, never say never. Now that we've unveiled an early look at Java support for Google App Engine, I'm thrilled to announce the availability of a JDO and JPA implementation for the App Engine datastore under the Apache 2 open source license.

The App Engine datastore is an incredible piece of technology. Based on Google's own Bigtable, it's one of the key reasons App Engine enables developers to write web applications that scale without infrastructure headaches. But, it isn't necessarily what most of us are accustomed to using for persistence. Wouldn't it be lovely if we could use an existing programming model on top of the datastore API? And wouldn't it be even lovelier if that existing programming model simplified the process of porting web applications on and off App Engine?

Fortunately for us Java developers we have not one, but two persistence standards at our disposal, JDO and JPA. And, to make adopting these persistence standards easier, we have the DataNucleus project (formerly JPOX), which provides plugins that connect these standards to various types of datasources. Andy Jefferson, founder of the DataNucleus project, was not only enthusiastic about our effort to add an App Engine plugin to his project, he was also incredibly helpful (thanks Andy!). I hope you're as excited about the results as I am: Standards-based persistence for the App Engine datastore!

Since App Engine for Python launched almost a year ago I've admired not just the applications that have been built by the developer community but the infrastructure as well. Even though the DataNucleus App Engine plugin was developed by Googlers, it uses the public App Engine APIs that are available to everyone. It uses no backdoors or special privileges. Rather, it is merely the first instance of what I hope will be a torrent of Java infrastructure developed for App Engine for Java. Feel free to peruse the code at http://code.google.com/p/datanucleus-appengine. If you find a bug, send us a patch. And if you think you can do better, do better! There's absolutely nothing stopping you.

By Max Ross, Software Engineer
URL: http://google-code-updates.blogspot.com/2009/04/standards-based-persistence-for-java.html

[Gd] New features for App Engine announced at Campfire One

| More

Google Code Blog: New features for App Engine announced at Campfire One

I'm excited to announce new, highly requested features for App Engine which we unveiled a few minutes ago at Campfire One.

First, we're giving developers an 'early look' at Java™ language support for App Engine. The team has taken a standards based approach, implementing standard Java APIs on top of App Engine where possible. So instead of using the underlying App Engine datastore API, developers can program against Java Data Objects or Java Persistence API.

Developers will also be able to easily build AJAX web applications end-to-end in Java through integration with a new version of Google Web Toolkit and a Google Plugin for Eclipse to support the development experience.

In addition to the Java features, we've also released cron support , data import support, and secure access to data behind the firewall. To learn more, read the full announcement on the App Engine Blog and watch the videos from Campfire One below: (Note: The video will be live soon)



Still needing a developer fix? If you want to dive deeper into these new features, and how to get more out of App Engine and Google Web Toolkit, we encourage you to come talk to us at Google I/O on May 27-28 in San Francisco CA. We'll be there conducting in-depth App Engine and Google Web Toolkit technical sessions and talking to developers. We'd love to hear your feedback about the features, and just see what you are up to.

*Java™ is a trademark or registered trademark of Sun Microsystems, Inc. in the United States and other countries.

By Andrew Bowers, Google Developer Team
URL: http://google-code-updates.blogspot.com/2009/04/new-features-for-app-engine-announced.html

[Gd] HTML5 and WebKit pave the way for mobile web applications

| More

Google Code Blog: HTML5 and WebKit pave the way for mobile web applications

When I first started at Google, we were building a Java ME email client for the phones of the day. It's an excellent product - still the fastest, slickest way to get your Gmail on many devices because of Java ME's widespread penetration. Yet it always bothered us that this client didn't really leverage the core strength of the desktop Gmail platform: sheer ease of access from anywhere, and constant updates and improvements. To use the client, you have to figure out how to install it and possibly navigate confusing network permission pop-up dialogs, and improvements could only be rolled out a few times a year in upgrades that required every user to download and reinstall their software.

The mobile team started thinking about how we could bring the benefits of the server-side approach to these clients. We started thinking about a world where we could deliver a GUI specified in XML to a Java ME client, enabling us to iterate on the server side and deliver new features that could delight users when they were ready, rather than on a lengthy release cycle. I was especially struck by a friend who said "What I like about Gmail is that it just constantly keeps getting better. It's like waking up to a new little present from Google each month!" We wanted our mobile users to feel the same way, so we felt the logical thing to do would be to build a general client that could be controlled by the server.

Not too long after, the team first saw the new Android browser. Still in its early stages, the Android browser was built on the latest version of WebKit and could render desktop pages with ease. The XHTML, images, JavaScript, and CSS that could be rendered on this platform presented great potential for building very high-end web applications. However, this was ages before Android was due to ship and Android would only be one of many mobile platforms.

Those drawbacks aside, we couldn't help but think that new browsers in Android's league would eventually become a reality. These powerful browsers could have the kind of functionality we needed to build top-notch, offline user interfaces that didn't need to be "installed" by users or "upgraded". Gmail could be Gmail: a constantly evolving way to handle lots of email quickly and efficiently. The only fly in the ointment was the need for Gears: users would have to download a browser plug-in, and most web browsers on mobile devices don't even support that. What we really needed was for Gears to inspire innovation in HTML itself, so that the whole web could move forward.

Enter HTML5. We're very excited about the evolving HTML5 standard because it enables mobile and desktop website designers to deliver the advantages of client-side and server side development to their users simultaneously! New APIs let web applications start offline and store data on the client. The canvas API lets you draw complex user interfaces, or you can use advanced CSS tricks to get the browser to render a rich UI. In addition, the W3C Geolocation API is being adopted and implemented by browser developers, enabling entire new categories of web applications to be built. The benefits are clear: you can develop fantastic new applications, benefit from server-side analytics and iteration to deliver features that your users want, and know that offline functionality keeps things running as the user moves in and out of coverage. Your users can enjoy fast, capable web apps that they can access from any device, without the need to copy their data from place to place or worry about installing software or being online.

We decided to build new versions of mobile Gmail and mobile Calendar on top of this functionality. First, we built a small javascript wrapper around the database functionality in HTML5 and Gears. This wrapper abstracts away the differences between the two APIs, so that our applications are supported on the broadest set of browsers possible while older browsers get updated with implementations of the new offline APIs. We noticed that we weren't the only ones thinking about this: a quick search shows that other developers saw the similarities too. The main difference between the Gears database API and the HTML5 database API is that the Gears API is synchronous, requiring separate worker threads to do the database calls, while the HTML5 database API uses callbacks and is asynchronous. With the wrapper built, we knew our code would run on all high-end mobile browsers today, and look forward to even more distribution as everybody implements HTML5.

We knew we could apply various approaches to building better experiences for Gmail and Calendar. The key principle we kept in mind is an age-old one: KISS. Simply caching responses in the database for re-use is surprisingly effective: you can get a lot of improvement with just a read-only environment. This approach worked well for Calendar, where usage is predominantly read-only and we can rely on the user being online to make edits.

For Gmail, more complexity was needed. A queue of user actions needs to be maintained in the database (in case the user runs out of battery or powers down for their flight). Later, when the device is back online, it can execute that queue of mails to send, archive or delete, and so on.

Having the ability to store your data and actions offline isn't much good if you can't start the application while offline. So besides making use of the database API, we needed a way to get the application itself loaded without an internet connection. The HTML5 specification comes to the rescue here, with an application cache that is capable of storing all resources in your web app so that the browser can load them while offline. This API has just one small drawback: once you've decided you're going to override how HTTP GET works to fetch resources from the application cache, you also commit to never issuing a GET for a resource the cache doesn't know about. The specification contains methods for extending what URIs the cache knows exist, but these entry points are not widely implemented in production browsers. Instead, it's important to use HTTP POST requests for all dynamic data, since POST requests are never cached and therefore do reach the network.

The end result is an incredible thing: a web app that loads offline, and lets you read your Gmail or view your events provided the data have previously been cached. The experience is seamless as you ride the subway or the bus through terrible coverage: your data are ready, quickly, all the time. To see the new Gmail for mobile web app, go to gmail.com from an Android-powered device or iPhone (OS 2.2.1 or above).

Of course we didn't get there without a few hard knocks. As an evolving standard, HTML5 has been fast-changing target and we've skinned our knees and bruised ourselves along the way. So rather than just deliver the fruit of all those bumps and scratches to end users in our own products, we decided we wanted to write a few blog posts to share what we've learned so that others can take advantage of HTML5 as well. In addition, we look forward to opportunities like our upcoming developer conference, Google I/O (May 27-28 in San Francisco, CA) where we'll be hosting a few sessions, to meet you in person and share demos and know-how.

Whether or not you can make it out to Google I/O, stay tuned to the blog for upcoming posts with examples such as how to avoid making your databases too large, handle upgrades gracefully, and tune performance.

By Alex Nicolaou, Engineering Manager, Google Mobile
URL: http://google-code-updates.blogspot.com/2009/04/html5-and-webkit-pave-way-for-mobile.html

[Gd] Latest Release Notes: Playlist Search, Time, and More

| More

YouTube API Blog: Latest Release Notes: Playlist Search, Time, and More

Enjoy a few new tidbits in the latest release.

Search for playlists

Yup, the same way you can search for videos and channels , you can now use the API to search for playlists:
http://gdata.youtube.com/feeds/api/playlists/snippets?q=soccer&v=2
The query above will return a list of playlist snippets that match the query 'soccer'. Searching in playlists is an excellent way to find YouTube videos about a specific point of interest (e.g. dancing, cooking, sports etc.).

Time filtering for video search

You can now restrict the video search result to a specific time interval (today, this_week, this_month, all_time):

http://gdata.youtube.com/feeds/api/videos?q=soccer&time=today&v=2

The default is 'all_time'.

More results

You can now request past the 100th video in a playlist and past the 200th video in a favorite list. Additionally, you can now get 1000 videos in a search feed instead of 999! Enjoy that last video, guys.

As always, post in the forum if you have any feedback or questions!

Posted by Daniel Danciu, Software Engineer
URL: http://apiblog.youtube.com/2009/04/latest-release-notes-playlist-search.html

Monday, April 6, 2009

[Gd] Congratulations to Prithvi Prabhu!

| More

Google Desktop APIs: Congratulations to Prithvi Prabhu!

A new gadget by Prithvi Prabhu is featured on the Inside Google Desktop blog. See the post Featured gadget: Resource Hog Tracker.

Posted by Kathy Walrath, Technical Writer (Google Desktop Team)
URL: http://googledesktopapis.blogspot.com/2009/04/congratulations-to-prithvi-prabhu.html

[Gd] Google Developer Days 2009: the first three locations

| More

Google Code Blog: Google Developer Days 2009: the first three locations

Google Developer Days 2009, a set of one-day developer events, are returning again and will take place in various locations around the globe. Like last year, we've designed these events for developers with strong coding experience so we can discuss our APIs, developer tools and applications.

We'll host Google Developer Day in these locations:
  • Beijing, China (June 5)
  • Tokyo, Japan (June 9) -- more information coming soon
  • Sao Paulo, Brazil (June 29) -- more information coming soon
If you're based in the US, we encourage you to come to Google I/O, on May 27-28 in San Francisco.

At Google Developer Day, attendees will learn about Google developer products from the engineers who built them. They will share their inside knowledge on our developer tools and APIs, including Android, Chrome, Ajax APIs , GWT, and App Engine. We will also do deep dives into our products at "office hours," during which developers can bring their own snippets of code or specific product questions to the Google engineers behind the product.

We've posted detailed information for China and will be adding more information for other locations soon. Space is limited so make sure you sign-up early. Hope to see you there!

By Alyssa Sachs, Google Developer Programs
URL: http://google-code-updates.blogspot.com/2009/04/google-developer-days-2009-first-three.html

[Gd] AJAX APIs Playground Ver. 2

| More

Google AJAX APIs Blog: AJAX APIs Playground Ver. 2

I am very pleased to announce version 2 of the AJAX APIs Playground. For those of you not familiar with it, the Playground is an educational application designed to show interactive code samples for some of Google's coolest Javascript APIs. Of the new changes, the most obvious is the sweet new UI, thanks to help from Roman Nurik of the Google Earth team.

The new features are:
* Break points (simulated in Javascript)
* Firebug Lite in output for debugging
* Line numbers in code editor
* Ability to edit HTML of samples



The breakpoints and Firebug Lite additions are my favorite new features. But why did I include Firebug Lite when all web developers (should!) have Firebug installed? Because when code runs on the Playground, it runs in an iFrame. That iFrame does not have the Firebug object initialized in it. Since it is a cross-domain iFrame, there's no simple way to add Firebug to the iFrame's window object, so adding Firebug Lite was the best approach. This makes it so you can now use all of your favorite Firebug debugging convenience functions in the Playground!

To use Firebug Lite and breakpoints, simply click on the line number you want to add a breakpoint to and hit "Debug Code". This will insert Firebug Lite into the output and pause the execution on the breakpoint line number until you to click the play button to continue. Try adding a breakpoint to a line, clicking "Debug Code", then opening Firebug Lite and typing in a variable name to inspect the contents/value of the variable at that point in the code.

Adding breakpoints and forcing Firebug into a local function context were really fun engineering problems, so if you want to check them out (or contribute code to the Playground) go to the open source repository for it, come chat it up on IRC, or talk with me in person at the quickly approaching Google I/O conference (early bird registration runs until May 1).

Also, it's really important that you share your feedback so that I know what you'd like to see in the next version of the Playground! Thanks, and enjoy the Playground!
URL: http://googleajaxsearchapi.blogspot.com/2009/04/ajax-apis-playground-ver-2.html

[Gd] AJAX APIs Playground Ver. 2

| More

Google Code Blog: AJAX APIs Playground Ver. 2

I am very pleased to announce version 2 of the AJAX APIs Playground. For those of you not familiar with it, the Playground is an educational application designed to show interactive code samples for some of Google's coolest Javascript APIs. Of the new changes, the most obvious is the sweet new UI, thanks to help from Roman Nurik of the Google Earth team.

The new features are:
  • * Break points (simulated in Javascript)
  • * Firebug Lite in output for debugging
  • * Line numbers in code editor
  • * Ability to edit HTML of samples



    The breakpoints and Firebug Lite additions are my favorite new features. But why did I include Firebug Lite when all web developers (should!) have Firebug installed? Because when code runs on the Playground, it runs in an iFrame. That iFrame does not have the Firebug object initialized in it. Since it is a cross-domain iFrame, there's no simple way to add Firebug to the iFrame's window object, so adding Firebug Lite was the best approach. This makes it so you can now use all of your favorite Firebug debugging convenience functions in the Playground!

    To use Firebug Lite and breakpoints, simply click on the line number you want to add a breakpoint to and hit "Debug Code". This will insert Firebug Lite into the output and pause the execution on the breakpoint line number until you to click the play button to continue. Try adding a breakpoint to a line, clicking "Debug Code", then opening Firebug Lite and typing in a variable name to inspect the contents/value of the variable at that point in the code.

    Adding breakpoints and forcing Firebug into a local function context were really fun engineering problems, so if you want to check them out (or contribute code to the Playground) go to the open source repository for it, come chat it up on IRC, or talk with me in person at the quickly approaching Google I/O conference (early bird registration runs until May 1).

    Also, it's really important that you share your feedback so that I know what you'd like to see in the next version of the Playground! Thanks, and enjoy the Playground!

    By Ben Lisbakken, Google Developer Programs
  • URL: http://google-code-updates.blogspot.com/2009/04/ajax-apis-playground-ver-2.html