2007 Conference Sessions

Pre-Conference Workshops

Start your week off with one or two of these focused workshops designed to teach specific skills and prepare you for the core conference.

Monday morning, December 3
JavaScript Bootcamp
Alexei White, Product Manager, Nitobi Software Inc.

Monday afternoon, December 3
Ajax: The Big Picture
Andre Charland, President and Cofounder, Nitobi Software Inc.

A Business Case for Ajax with Google Web Toolkit
Bruce Johnson, Software Engineer, Google, Inc.

Core Conference Session Descriptions

Tuesday, December 4

Productivity
Bruce Johnson, Software Engineer, Google, Inc. and Dan Peterson, Product Manager, Google, Inc.

It is a rare combination when the easiest approach produces the best results, but that's what GWT delivers. GWT lets developers leverage their Java expertise and productivity tools to easily create high-performance Ajax applications. Development teams can work surprisingly quickly when they can focus on the product that they are building instead of fighting browser quirks and performance oddities. Come learn how to take maximum advantage of GWT's productivity features such as reuse, UI templating and code generation to help your development team not only survive in the world of Ajax, but genuinely thrive.

Ajax Security and GWT
Billy Hoffman, Lead Researcher, SPI Dynamics

This presentation will demonstrate advanced attacks against Ajax applications, including JSON hijacking, function clobbering, data flow manipulation, logic manipulation, and denial of service attacks. We will examine how susceptible GWT applications are to these kinds of attacks and compare the security features of GWT with other Ajax frameworks such as Prototype and Dojo. We will also show some unknown attacks against another popular Google product.

Deployment Best Practices
Ryan Dewsbury, Software Development Consultant, and Bob Vawter, Research Actualization Engineer, Google, Inc.

Well-designed GWT applications can make near-optimal use of network and server resources. Application startup time, for example, is critically important in making a good first and subsequent impression on your users. But do you know how to tweak your HTTP response headers in exactly the right way to produce blissfully fast startup? (Hint: you can let the browser permanently cache nearly every file!) This session will focus on specific deployment strategies for both Apache and Tomcat as well as outline best practices for application deployment to ensure great performance and seamless upgrades.

Performance
Joel Webber, Software Engineer, Google, Inc.

A Google mantra: "Fast is better than slow." GWT's emphasis on end-user experience makes performance a critical requirement. When used appropriately, the GWT architecture can help you deliver sophisticated web apps that have unmatched startup speed and performance. However, it's easy to misuse GWT: Choosing a suboptimal architecture or writing unnecessarily generalized code can make your application run like a dog (a slow dog, that is). Join the co-creator of GWT as he demonstrates best practices for web application performance and explains how to implement them using GWT.

Client-Server Communications
John Tamplin, Software Engineer, Google

It's a rare Ajax application that doesn't need network access. To the despair of many a developer, though, there are almost as many ways of communicating with a server as there are servers. The usual alphabet soup applies (XML, JSON, SOAP, RPC, and others) but even once you pick one, you're really just getting started. Designing your services for scalability and performance is an art in itself, regardless of which format you choose to represent your data. Fortunately, many of us have lived this nightmare and survived to talk about it. Join John Tamplin as he shows you the path through the labyrinth of building client-server communications architectures.

Usability
Kelly Norton, Software Engineer, Google, Inc.

Another Google mantra: "Focus on the user and all else will follow." GWT's mission naturally centers on end users. In addition to sheer performance, there are many important usability considerations that GWT can help with. Come hear Google engineer and MIT Media Lab alumnus Kelly Norton discuss how to design GWT applications that make end users happy, if not ecstatic. This session surveys usability considerations, including UI design, history behavior, keyboard support, localization, and accessibility.

Remote Procedure Calls
Rob Jellinghaus, Chief Architect, Nimblefish Technologies

GWT includes an extensive RPC framework to let your GWT applications communicate using standard Java objects over the network. This framework is powerful and useful, but with great power comes great responsibility. Java persistence, Java 5 generics and annotations, data transfer of business objects, object graph pruning, and message ordering can all affect your APIs and your apps. In this session, Rob Jellinghaus discusses best practices that address these issues and others, to enable you to use GWT RPC effectively.

Applications Panel
Moderator: Bret Taylor, Co-Founder, FriendFeed
Panelists: Alex Moffat, Engineering Manager, Lombardi Software
Christopher Klundt, President, theClassConnection

You might think GWT is pretty cool technology, but you're probably wondering "who else is using it?" It turns out that application developers have used GWT for a wide variety of apps. Come listen to their experiences at this panel, moderated by Bret Taylor of Google Maps fame.

Wednesday, December 5

Deferred Binding
Ray Cromwell, CTO, Timepedia.org

What do you do when you want the benefits of modularity and abstraction during development, but you aren't willing to subject users with any runtime overhead to get it? If you're the GWT team, you invent deferred binding. Deferred binding is a pluggable compile-time type substitution and code generation mechanism. This unique approach to program modularization provides many of the benefits of Java reflection and dynamic class loading without compromising the GWT compiler's ability to optimize the heck out of your code. The GWT libraries leverage deferred binding to provide zero-overhead browser abstractions, highly optimizable internationalization, automatic image bundling, and high-performance, polymorphic RPC. Best of all, deferred binding is extensible, and this session will show you how you can take advantage of it to build powerful, reusable and, most importantly, efficient abstractions in your own libraries.

Using UI
Rajeev Dayal, Software Engineer, Google

So, you've heard about the Google Web Toolkit, but you've been wondering if it can make your application's UI look rich and fluid like some of the other toolkits you've heard about...Well, you've come to the right place! In this talk, we will take a look at some examples of slick user interfaces and demonstrate how to build them with GWT's UI library. Along the way, you'll learn about all of the different UI features that GWT has to offer.

GWT: Cool and Useful Stuff
David Geary, President, Clarity Training, Inc.

This session shows you how to flat out kick ass with GWT. You'll see how to create custom widgets, from low-level to high-level, and in between. You'll see how to implement: drag and drop; simple windows that pop up in the browser's client area; viewports that smoothly drag their views in reaction to user input; and tables with columns that you can dynamically resize.

Along the way, we'll explore some of the more advanced aspects of GWT, such as: telling the browser to butt out of event handling; using timers for iPhone-like animations; capturing events to increase performance; and how you can directly create and manipulate a widget's DOM element.

If you're looking to learn some advanced GWT techniques and add some more sizzle to your web applications, don't miss this nonstop barrage of code and killer demos.

Creating Widgets
Joel Webber, Software Engineer, Google, Inc.

GWT provides a lot of leverage on building complex user interfaces, but web browsers always do their best to make it harder than it should be. Fortunately, widgets provide a natural way to "wrap up" complex functionality, making it easy to reuse and share. In this session, Joel Webber will explain the inner workings of the widget library, as well as common patterns and pitfalls. Topics will include creating new widgets and panels, memory management, event handling, and interacting with the browser DOM.

Internationalization
Shanjian Li, Software Engineer, Google, Inc.

The need for information crosses all borders. Indeed, if you hang out with some Google engineers for a few hours, the odds are good you'll hear someone say "English is just another language." Although most developers appreciate the need for internationalization in theory, it's particularly hard to put into practice in Ajax code. Come learn how GWT addresses this challenge head-on by providing libraries and techniques that make I18N-aware applications easy to build, without sacrificing runtime performance.

Tour of GWT Core Libraries
Bruce Johnson, Software Engineer, Google, Inc.

GWT includes both a tool set (e.g. hosted mode, compiler) and a set of libraries (e.g. widgets, RPC, XML, JSON). It has always been a design principle that GWT users should be able to write and use their own libraries. Indeed, you could totally replace all of the GWT libraries if you chose to. In this session, Bruce Johnson explains why you probably wouldn't want to do that by pointing out the breadth of the GWT libraries and the sometimes subtle design decisions, and the resulting benefits that underlie them.

JavaScript Native Interface
Scott Blum, Software Engineer, Google, Inc.

The developers of GWT have often referred to it as a "necessarily leaky abstraction." Why is that a good thing? It means that GWT isn't a walled garden of functionality. Using the JavaScript Native Interface (JSNI), you can easily implement Java methods using handwritten JavaScript, making it possible to produce and consume pure JavaScript libraries even while using your favorite Java tools. Best of all, the GWT compiler actually optimizes your handwritten JavaScript! Learn from GWT compiler guru Scott Blum how JSNI works and how you can take advantage of it.

Architecture Best Practices
Joel Webber, Software Engineer, Google, Inc.

Ajax, taken to its logical extreme, is essentially a 1990's-style client/server architecture: one that has a vast, decentralized, and unpredictable network directly in its critical path. (The Internet, we're talking about you.) Application developers have to grapple with network failures, latency, asynchonicity, multi-session synchronization, scalability, failover, cross-site scripting, and server security—and that's in addition to actually being able to build an application in the first place. GWT gives you the plumbing to tackle these challenges head on, but finding the right architecture for your application can still be daunting. In this session, Joel Webber reviews some of the pivotal design decisions you'll want to consider when approaching a new project and gives advice about what to do when.

Unit Tests and Benchmarks
Toby Reyelts, Software Engineer, Google, Inc.

We all want to be able to deliver reliable applications to our customers, but how can we do that in the face of Ajax? Each browser has its own unique bugs, quirks, and performance characteristics. Learn how GWT's unique support for JUnit can help you squash bugs before they make it to your users. This session covers the entire gamut of testing, from basic test writing and execution, to asynchronous testing, and parallel remote web execution. Additionally, we'll tackle the use of benchmarking to improve your application performance, prevent regressions, and identify insidious performance problems in browsers.

Tools for GWT Panel
Moderator: Adam Houghton, Senior Software Developer, SAS
Panelists: Robert Hanson, Internet Engineer
Eric Clayberg, Senior Vice President, Instantiations
Ray Cromwell, CTO, Timepedia.org

The GWT charter "Making GWT Better" states that GWT centers on the Java language not for a "religious" reason, but instead for a pragmatic one: there are lots of great Java tools. It's good news, then, that GWT is operating system and IDE agnostic, so you can use the Java tools of your choice. The even better news is that a new generation of GWT-specific third party tools is now available. Come hear from the creators how each of these products can improve your productivity with GWT, simplifying everything from RPC to WYSIWYG to I18N (internationalization).

Thursday, December 6

Best Practices for Building Libraries
Kelly Norton, Software Engineer, Google, Inc. and Joel Webber, Software Engineer, Google, Inc.

Building libraries is often like piloting passenger planes. As tempting as it might be to perform some thrilling and daring acrobatic maneuver in mid-flight, there are a lot of people depending on a safe arrival who would prefer that you didn't. Writing software for general reuse requires discipline, empathy, and careful consideration of trade-offs. In this session, we'll fly along with Joel Webber and Kelly Norton as they discuss general best practices for building GWT-based libraries with an eye toward productivity, performance, usability, and security.

API Integrations: Maps and Gears
Pamela Fox, Support Engineer, Google, Inc. and Dan Morrill, Software Engineer, Google, Inc.

After toying around with GWT you'll hopefully realize "Hey, I can make really cool Ajax applications without needing a bottle of analgesics by my side!" A few weeks later you make the slickest Ajax web application out there where users can shop for alternative medicines, your No. 1 prescription for headaches being "use GWT." You start thinking, "Hmm, wouldn't it be great if users could browse prescriptions even while offline using Gears, and even look up shops around their area in Google Maps! If only I could integrate these Google APIs into my GWT code..." Lucky for you, Christmas came early! Check out how easy it is to integrate Maps and Gears into GWT applications thanks to the Google API Libraries for GWT!