Campfire One: App Engine’s 1st Birthday (pt. 1)
Campfire One: App Engine’s 1st Birthday (pt. 2)
Campfire One: App Engine’s 1st Birthday (pt. 3)
Campfire One: App Engine’s 1st Birthday (pt. 4)
Campfire One: App Engine’s 1st Birthday (pt. 5)
Campfire One: App Engine’s 1st Birthday (pt. 6)
Campfire One: App Engine’s 1st Birthday (pt. 7)
Campfire One: App Engine’s 1st Birthday (pt. 8 )
Campfire One: App Engine’s 1st Birthday (pt. 9)
This video introduces the latest features of App Engine, including an early look at Java language support. Andrew Bowers will walk through the development of a sample Java application, from creation to deployment.
Join us at Google I/O, Google’s largest developer event, happening May 27-28, 2009 in San Francisco. The App Engine team will be on hand to answer any questions and hold deep-dive technical sessions. Register to attend: http://code.google.com/io
June 04, 2007
Special Session: Building Better AJAX Applications: Nuts & Bolts… and Gears
Dan Morrill, Brad Neuberg
AJAX frameworks have allowed developers to improve the web by making it easier to build high quality applications that users love. This session discusses how the Google Web Toolkit (GWT) can be combined with new technologies to build even better applications. More details on this session will be provided at Developer Day.
Speaker Bio: Dan joined Google Developer Programs in 2006 to help developers become successful with the Google Web Toolkit and other products. Before joining Google, Dan was a computer scientist at GE Research, where he gave himself headaches by switching between web development in JavaScript and circuit design in Verilog. Dan lives in Atlanta with his wife, two cats, and lots of video games.
Brad Neuberg is an internationally-recognized software inventor in the fields of collaboration and online applications. His passion is inventing amazing ideas and then doing the hard work to make them real. He has extensive experience in the open source community, contributing code to Dojo, Mozilla, JXTA, the Jakarta Feed Parser, and more.
June 06, 2008
Server-side JavaScript on the Java Virtual Machine
Steve Yegge (Google)
After over a decade in the browser space, JavaScript is making a surprise move into the server programming space. Mozilla Rhino is turning JavaScript into a compelling option for Java programmers. Will JavaScript be the next server-side programming language? In this talk I will do a deep dive into Rhino’s technology, and I’ll demonstrate some of its many uses in server-side computing.
October 08, 2007
Google TechTalks
May 31, 2006
Richard Hipp
ABSTRACT
SQLite is a small C library that implements a self-contained, embeddable, zero-configuration SQL database engine. SQLite implements a large subset of SQL-92 and stores a complete database in a single disk file. The library footprint is less than 250 KB making is suitable for use in embedded devices and applications where memory space is scarce.
This talk provides a quick overview of SQLite, its history, its strengths and weaknesses, and describes situations where it is much more useful than a traditional client/server database. The talk concludes with a discussion of the lessons learned from the development of SQLite and how those lessons…
June 10, 2008
Surprisingly Rockin’ JavaScript and DOM Programming in GWT
Bruce Johnson (Google)
You may already know about GWT’s nifty JavaScript Native Interface (JSNI), which allows you to define native Java methods with handwritten JavaScript. In GWT 1.5, there’s an even more powerful way to program close to the metal. You can now model arbitrary JavaScript types directly as Java classes (specifically, as subclasses of GWT’s JavaScriptObject class), yet there is no overhead in size or speed. You can code against any JavaScript object as if it were a regular old Java object. So, what does that buy you?
* It’s never been easier to integrate with external JS libraries; just define a Java class that models the JS object you want to interact with. Nice Java syntax, no overhead.
* Freely use low-level native JS data structures (JS arrays, for example) by exposing them with a Java-friendly API. You can even apply Java generics to JS types!
* Superimpose strongly-typed Java classes on JSON objects, giving you IDE code completion, refactoring and compile-time type checking.
* GWT uses this new ability to provide a complete cross-browser DOM class hierarchy based on the W3C’s Java HTML bindings. Programming straight to the DOM has never been more productive.
Come learn about this unusual and powerful new capability that you can use to squeeze every drop of performance and interop out of your GWT projects.
June 10, 2008
Faster-than-Possible Code: Deferred Binding with GWT
Bruce Johnson (Google)
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.
In this Code Lab, we’ll examine how the GWT libraries leverage deferred binding and GWT compiler optimizations to provide zero-overhead browser abstractions, highly optimized internationalization, automatic image bundling, and high-performance, polymorphic RPC. Did we mention that deferred binding is extensible? We’ll also use deferred binding to create a new library from scratch.
June 10, 2008
GWT Extreme!
Ray Cromwell (Timepedia.org)
In this session, see Google Web Toolkit used in exotic and creative ways to solve interesting engineering problems, from authoring OpenSocial apps that run as both Web gadgets and native Android applications, to developing Adobe AIR applications using GWT, compiling CSS selectors to Javascript at compile time, running multithreaded code with GWT and Gears workers, or exporting GWT libraries for JavaScript users. Learn the secrets of writing “faster than possible” GWT code, how to use Generators and Linkers in harmony, and make seamless procedure calls from GWT code to other environments like Flash, Gears, or Android.
June 09, 2008
GWT and Client-Server Communication
Miguel Mendez (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, a few of us have lived this nightmare and survived to talk about it.
June 09, 2008
Using GWT to Build a High Performance Collaborative Diagramming Tool
Alex Moffat and Damon Lundin (Lombardi)
Lombardi Blueprint is a browser based business process documentation and diagramming tool written using GWT and Java. It supports simultaneous viewing and editing of process definitions by multiple users in different locations with multi level undo and a rich editing experience including drag and drop, inline editing and, automatic diagram layout. Implementing these features presented several technical challenges.
Damon and Alex will describe two of the most interesting: 1) synchronizing multiple client object models with the server, and 2) providing a highly responsive diagram editing experience.
Creating a complex user interface poses particular performance problems using today’s javascript engines over what can typically be performed with a native Java VM. The two main challenges we faced with our process diagram were speed of rendering in the browser and automatically laying out and routing large diagrams. Efficient rendering requires us to use a flyweight pattern to handle large html documents, while layout and routing dynamically switches between client and server execution depending on the time required to layout the diagram.
To support multi user editing and viewing Blueprint must keep client and server object models in sync. Our repository design supports doing this efficiently by only requiring us to transfer the differences between two model states in either direction. This same approach allows us also to support rollback to previously saved versions by having the server compute the set of commands required to move between any two states.