Gundrota: that's moving,
and it's gonna do that in the background
so the app's still responsive.
Watch this.
The boxes in the right are differentials.
How crazy is that?
Did you ever think you'd see background processing--
Uh, you'd see video motion detection
done in JavaScript in the browser?
You know, I certainly didn't.
This is just fantastic, and a great demonstration
of these capabilities all coming together,
and the kind of rich app that we can now start to build
within the browser.
So I hope you liked that.
[applause]
Let's go back to slides. Very good.
And once again, that capability,
broadly available in these modern browsers.
So I hope you've enjoyed that section of the talk.
That was about a more powerful web,
and how as an industry we are creating new capabilities
and, uh, but it's still up to us as a community
to build the applications
that take advantage of that more powerful web.
I'm going to pivot at this point,
and now talk about making it easier
to build those kind of apps
and how Google Services can help you.
Obviously if you came to last year's development conference,
or attended any of our Google Campfire Ones
or watched them online,
you know that Google's deeply interested
in making it easier for you to build web apps.
Two of our offerings in this space
have been Google App Engine and Google Web Toolkit.
Google App Engine's value proposition was very simple.
We said, let us provide the hosting for your app
so you don't have to worry about machine instances,
you don't have to worry about the app's scaling,
you don't have to carry a pager; we'll do that for you.
And we're gonna give you an update on that in a moment.
Google Web Toolkit had a different, uh, proposition.
It said, write in Java, and we'll compile down,
understand which browser's being used,
and push down the appropriate JavaScript,
and do it in a fantastic way
that allows you to target multiple browsers.
To give you an update
on Google App Engine and Google Web Toolkit,
let me invite up Andrew Bowers and Kevin Gibbs.
[applause]
Thank you, guys.
both: Thanks, Vic.
Gibbs: You know, the interest in adoption that we've seen
in Google App Engine over the past year
has been truly remarkable.
We've had over 200,000 developers sign up
to use Google App Engine,
and not a single one of those developers
had to purchase or provision a server to get started.
They were able to develop their application locally
on their own machine, be it Mac, Windows, or Linux,
and leave the servers to us.
Now, our SDK is just three megabytes.
If you haven't tried out App Engine before,
I encourage you to download it. Give it a shot.
Now, since we launched App Engine last year,
we've also had over 80,000 applications
deployed on Google App Engine.
Now, often these applications have been created
by small and agile teams
like many of you in the audience here,
and they can be because with App Engine
you don't have to worry about your configuration,
your up time, or usage spikes, or re-architecting
your application once it finally starts to get popular.
In fact, we were able to put this, uh--
this policy to the test ourselves
when the White House decided to use Google Moderator,
which runs on Google App Engine,
for President Obama's live town hall event.
Despite a traffic peak of 700 requests per second,
and promotions on all the major search engines and news sites,
the application scaled to meet the traffic,
and none of the other applications were affected.
Now, over the past year we've also launched
a number of features and improvement to App Engine,
including things like our SSL support,
memcache API, the system status site,
uh, access to secure data behind the firewall,
and the ability to pay for usage beyond our free quotas.
Now, we've also found that there's a number
of additional things that we'll launch to you
in the coming months.
They include things like
background processing for your jobs
and large object support for your application.
If you'd like to learn more,
I'd urge you to come to our sessions here at Google I/O
over the next two days.
Now, certainly the feature that we've launched recently
that's generated the most noise and the most buzz
is our Java language support.
The interest in our Java support since we launched it
a month and a half ago has been remarkable.
In a matter of days,
even hours since we launched our Java support,
we saw developers--many of you in the audience here today--
dive in and get not only Java frameworks
working on App Engine, but also other JVM languages.
Including things like JRuby, Groovy,
Scala, and even PHP.
And that, we thought, was truly amazing.
I'd like to say thank you
for all of you early adopters who gave us a try
and gave us the feedback with the system.
Now, we found that the demand for Java on App Engine
has been so overwhelming, and the response so positive,
we think that we're ready to take the next step
with Java on App Engine.
So I'd like to announce--
sorry, let's skip this slide.
I'd like to announce that we are opening sign-ups
for Java on App Engine as of right now.
Anyone can now log in and create a Java application immediately.
[applause]
Thank you.
Now with that, I'd like to stop telling you
about our Java support in App Engine,
and start showing you.
So I'd like to pull over Andrew Bowers.
Andrew is gonna demonstrate to you
how we have an NTN Solution for creating Java applications
using Google Web Toolkit and Google App Engine.
Andrew's gonna demonstrate to you how we think we have
a way to make applications both more scalable
and easier to use
with back-ends running on Google App Engine,
and front-ends built with Google Web Toolkit.
Andrew.
Bowers: Thanks, Kevin.
So if any of you have ever done Java development,
you've probably experienced the frustrating lag
between getting a development environment set up
and actually deploying something to the web.
And if you're working on a weekend project,
maybe you decided to go ahead and use something
like Ruby on Rails 'cause you wanted to actually
get something out there.
So we definitely recognize that pain and frustration
in our own lives, and tried to make the on-ramp to a new app
as quick as possible.
So to demonstrate, I'm going to create the starter project
from the Eclipse plug-in;
I'm gonna deploy that to the web.
And I'm gonna use Google Web Toolkit and App Engine
and hopeful--it should take me about 2 1/2 minutes,
so somewhere around there's my goal.
So here I have the Eclipse development environment.
and let's just get started.
I'm gonna go ahead and open up the new project wizard.
I'll create something called "com.google," create a package.
And I'm gonna use Google Web Toolkit and App Engine.
And this is gonna create the starter project for me.
Looks like we already had something running.
We'll go ahead and stop that.
And now I'm gonna start that on a local server.
So this is a--
Has everything I need already.
I didn't have to install Tomcat,
all I did was I installed the Google plug-in for Eclipse
into my Eclipse development environment.
That downloaded the App Engine SDK,
the Google Web Toolkit SDK, and the local development server
which mimics the production environment.
So now I have a, uh, very simple Ajax application.
It takes some text here.
It synchronously sends that to the server,
echoes the text back, as you can see,
and then gives me a little information
about the server that I'm running.
Just so we can tell that it's actually going to the server.
So if we look at the code for that...
Open up the project here.
You can see I have a client package and a server package.
Now, all of the code inside my client package
is Google Web Toolkit code
that's Java code that's going to be compiled into JavaScript
in the final step.
And it's using--
Uh, it's using widgets and it's using events
so they're abstracted away so that it'll work across browsers.
So I could change the text on the button here to "Post."
Inside my server package I have Java classes
that are grown as bytecode on the server
and you can see that I'm getting RPC,
and I'm echoing it back,
so we'll say, "Hello from Google I/O."
And we'll save that there.
Now if I go back--
So I've just edited Java code.
I'm gonna go back to my browser, I'll click "Refresh."
And I see it says "Post,"
and I see it says, "Hello from Google I/O."
So I just edited Java,
but I'm seeing those changes now on my browser.
Okay, so I've got a-a small, functioning app.
Let's go ahead and deploy that out to the web.
Go back into Eclipse, I'll go up to the deploy wizard,
and you'll notice there's an error here right now.
That's 'cause I haven't set an application ID.
So I'm gonna go to the App Engine console,
and I'll create a new application ID.
We'll say, "demoforio."
And we'll save that,
and hope no one beat me to it out there.
Okay. You're not fast enough.
Great, so we'll go back.
I had some backups just in case.
So we'll set the application ID here in the environment.
And all I need to do now
is enter in my username and password.
Then hit the "Deploy" button.
The SDK has taken care of the rest for me.
So it's going to convert that Java code
from Google Web Toolkit in the client package to JavaScript,
it's going to compile the, uh, Java code to bytecode,
for the server side stuff,
package all of that up into a web archive directory
and deploy it to the server.
There's no FTP involved by me, no server configuration;
everything's handled within the SDK.
And I could do this from the command line
if I wanted to as well.
And so now we should have a deployed app.
And hopefully within a few minutes, here.
So let's go to that demoforio.appspot.
And so I've got a fully functioning,
if not very functional, app out on the web.
[applause]