-
man: Ladies and gentlemen,
-
please welcome Vice President, Engineering, Vic Gundotra.
-
[cheers and applause]
-
Gundotra: Well, good morning, everyone.
-
Welcome to day two of Google I/O.
-
I hope you all had a great time yesterday.
-
I hope you enjoyed your sessions,
-
and I hope you enjoyed those Android phones.
-
[audience whoos]
-
[cheers and applause]
-
Yesterday, we promised you a surprise for this morning.
-
And this morning, Google will surprise you.
-
We are about to unveil
-
a personal communication and collaboration tool
-
in a very early form.
-
We decided to do this at this forum
-
for a couple of reasons.
-
This unbelievable product,
-
one that I'm very, very excited about,
-
will be open-sourced.
-
It's open-sourced for many reasons.
-
Not only do we want to contribute to the Internet,
-
but frankly, we need developers
-
to help us complete this product,
-
and we need your support.
-
So we hope after you see this
-
you're as excited about it as we are.
-
And number two,
-
we decided to unveil this product
-
in its early form at this conference
-
because it is an unbelievable, powerful demonstration
-
of what is possible in the browser.
-
I guarantee you that over the next hour and a half,
-
as you see this product, you will forget
-
that you are looking at the browser.
-
And I want you to repeat after me.
-
"I am looking at an HTML 5 app.
-
I am looking at what's possible in the browser."
-
And I hope you are as excited and delighted as I was
-
when I first saw the thinking behind this product.
-
Now, it shouldn't have surprised me
-
that this product would be magical.
-
After all, the engineering leadership
-
had already produced a magical product.
-
The engineering leadership behind what you're about to see
-
is the work of two brothers,
-
and an amazing engineering team with them.
-
Those two brothers are Lars and Jens Rasmussen.
-
You might remember those names,
-
because those were the same amazing people
-
that did another magical app called Maps--Google Maps.
-
And so you'll see what they've been working on
-
unveiled for the first time today.
-
So why don't we go ahead and get started?
-
Remember, this is an early developer preview
-
for this audience.
-
Everyone in this room will get accounts to give us feedback,
-
and we'll talk about that a little bit later.
-
We have your email addresses, so you will get those passwords
-
a little bit later on, likely tomorrow.
-
With that, let me just go ahead and get started.
-
Let me introduce Lars Rasmussen and Stephanie Hannon.
-
Thank you.
-
[cheers and applause]
-
Lars Rasmussen: Thank you.
-
Thank you. Thank you.
-
Thank you very much.
-
I shall wake up my laptop.
-
Good morning, everyone.
-
Thank you very much for coming early.
-
I know you've been here partying all night.
-
Uh, we're going to show a demo today
-
of a product that we've been working on
-
for a couple of years down in Sydney, Australia.
-
It's called Google Wave,
-
and it's a communication and collaborations tool
-
that we're launching later in the year.
-
Uh, like Vic said, it's a little unusual for us
-
to be showing it to the world this early.
-
The reason we're doing it is very simple.
-
We're starting a developer preview today.
-
You guys will all get accounts
-
on a sandbox build of the system.
-
You are the first outside of Google to see this,
-
and you'll be the first to get accounts on the system.
-
And we're doing that because as you will see from the demo,
-
Google Wave comes with a set of really nice APIs,
-
and we're hoping we can persuade you guys
-
to start building cool things with those APIs
-
while we're getting the product ready for launch,
-
which is going to happen later this year.
-
Because that way, when we do launch,
-
our users and your users can enjoy both Google Waves
-
and all the cool things that we hope you'll build
-
at the same time.
-
Let me introduce Stephanie Hannon.
-
She's quite possibly the best PM in the world.
-
[cheers and applause]
-
Hannon: [laughs]
-
Good morning, I/O.
-
Thank you, Vic, for the invitation to be here.
-
We couldn't imagine a better audience
-
to show our product to first.
-
Lars Rasmussen: I second that.
-
Hannon: Our presentation today is in three parts.
-
First, we're going to show you a demo of the product.
-
Second, we'll show you the APIs that Lars talked about.
-
You can use Waves to enhance your Web site
-
and you can build extensions to Wave itself.
-
Third, we'll show you that Wave is also a protocol.
-
We are very passionate about this being
-
an open system of communication.
-
We hope other people build Wave services
-
that interoperate with ours
-
so users have choice in their provider.
-
We affectionately call this the three Ps.
-
Product, platform, protocol.
-
And we'll talk about them all today.
-
Lars Rasmussen: Okay, so communication.
-
Um, email today is by far the most popular way
-
for us to communicate on the Internet,
-
which is remarkable,
-
because email was invented more than 40 years ago.
-
before the Internet, before the Web,
-
and it was done without the experience
-
of things like SMS, and instant messenging,
-
and blogs, and Wikis, and bulletin boards,
-
and discussion groups, and social networks, and Wikis,
-
and media sharing sites, and collaborative editors--
-
All of these different kinds of communication
-
that we take for granted today.
-
Also, of course, computers and networks
-
have dramatically improved in those four decades,
-
and so when we started this project--
-
and it's been more than two years--
-
we asked ourselves the question,
-
"what might email look like if it was invented today?"
-
And needless to say, there is about a million
-
different ways you can answer that question.
-
What you're going to see today, Google Wave, is our attempt.
-
And so let me start by briefly contrasting
-
email from Wave.
-
Email essentially mimics snail mail.
-
The basic metaphor is you write a message
-
and you send it to one or more recipients,
-
and then email systems--
-
and we like to think Gmail does this particularly well--
-
can collate related messages into conversations or threads.
-
Wave, by contrast, starts out
-
with the definition of a conversation,
-
which is simply a lightweight tree structure of messages
-
and a set of users participating in that conversation.
-
And then instead of thinking of individual messages
-
as being sent back and forth,
-
we think of the entire conversation object
-
as being a shared object hosted on a server somewhere.
-
And users that participate can open up that wave,
-
leave their replies, go away,
-
and then when the next user comes,
-
she can open up that same shared object,
-
see those replies, and add her own.
-
That's how the wave grows.
-
That's how the conversation builds up.
-
And you'll recognize that this is a model
-
that came to how bulletin boards work.
-
We found that with a tight enough implementation,
-
you can use that to build a single communication tool
-
that has functionality spanning quite a lot further
-
than what you can do with email today.
-
And so we'll show you a demo.
-
It'll take you through a series of usage scenarios
-
that you'll be familiar with,
-
but where today we would use different tools for each one,
-
and we'll show you how it all fits neatly
-
in this one metaphor of hosted conversations.
-
Stephanie.
-
Hannon: So what you are looking at is an HTML 5 app
-
that we built with the Google Web Toolkit.
-
On the left side is Lars running Chrome.
-
On the right side, I'm running Safari.
-
And a little bit later we're going to throw in Firefox.
-
So the same thing is being shown on each pair of screens,
-
you can just choose one to look at.
-
Lars Rasmussen: Okay, so we'll start
-
with plain vanilla-type email conversations,
-
and we'll show you how it looks in Wave.
-
We're planning a boat trip.
-
And I'm going to start by clicking "New Wave" here,
-
and then I'll type my title in the first line.
-
Hannon: Watch your spelling, Lars.
-
There's a lot of people.
-
Lars Rasmussen: [laughs] There is a lot of people.
-
They can't see what I'm typing anyway.
-
"Are you ready for the boat trip?
-
Hey, Steph."
-
Did you guys like the spell-checker?
-
[applause]
-
You do.
-
We'll talk more about that later.
-
Since you don't want to watch me type for an hour,
-
we put canned messages in there.
-
We'll try hard to pull them out before we launch.
-
I click "Done," it asks me for more users.
-
I'll add Stephanie.
-
And since she is offline,
-
I'm going to go stare at a blank page.
-
Hannon: So I will open Wave.
-
And you'll see in my Search panel, the middle panel,
-
will be an unread message from Lars.
-
He's asking me if I want to go shopping,
-
uh, before this boat trip,
-
so I'll do something very email like,
-
which is hit "Reply,"
-
and say, "I looove shopping."
-
Lars Rasmussen: I wrote the script.
-
Hannon: "I need new fins. Let's go."
-
The first benefit I want to show you
-
of this being a hosted conversation
-
is it's easier to keep track of structure.
-
If this was email and I wanted to reply
-
to the middle part of Lars's message
-
where he asked which bus to take,
-
I would hit "Reply," the email client would copy the message,
-
and I'd hand-edit in the response.
-
Because this is a hosted conversation
-
that lives in one place,
-
I can just instruct the server to split the message apart
-
and say, "You never wake up early,"
-
which is true.
-
"Let's take the late bus."
-
Okay, Lars isn't online; I'm going to close this wave.
-
Lars Rasmussen: So a little bit later I come back online,
-
and you'll see, for starters, that that wave is now bold
-
to show me there is new material in it.
-
When I open it up, Stephanie's first message gets the highlight
-
and I can navigate the conversation with my keyboard,
-
and of course, continue her thread here.
-
"You know me too well."
-
Like that.
-
And that's how plain vanilla email-type conversations
-
work in Wave.
-
So you've noticed that we have carefully avoided
-
having the wave open on both screens.
-
When we do have the wave open at the same time,
-
my message bounces right off the server
-
into Stephanie's browser.
-
The effect is that you can also
-
do Instant Messaging-type conversations in Wave.
-
In fact in the same wave you can switch back and forth
-
between these different ways of communicating.
-
I'll show you that now.
-
Shiny. You must know a good store.
-
[cheers and applause]
-
Hannon: There is a new one over on George Street.
-
Lars Rasmussen: Cool. Let's go at 7:00.
-
Hannon: "Sounds good. Let's invite Jens too."
-
Lars Rasmussen: "Okay."
-
So you noticed that it didn't wait for me to hit "Done"
-
before showing Stephanie the message,
-
but rather--and this was difficult to do--
-
we transmit live almost character by character
-
what I'm typing.
-
Why did we do that?
-
It's because with today instant messaging tools
-
you spend half of your time looking at it saying,
-
"Stephanie is typing, she's typing, she's typing,
-
she's typing," and then you see what she said.
-
Thank you. [laughs]
-
But because in general you can start formulating your own reply
-
before Stephanie is done typing hers,
-
by doing this live transmission,
-
you end up spending 100% of your time either reading or writing,
-
which dramatically speeds up the conversation.
-
Now needless to say, there are times
-
you don't want everyone to see every keystroke,
-
in particular if you spell like I do.
-
Um, and so we have this checkbox here.
-
All you have to do is check it
-
and now no one can see what you're typing
-
until you hit that "Done" button.
-
This is one of the features we haven't implemented quite yet.
-
[laughter]
-
Okay, so that's how email conversations,
-
or rather email-type conversations
-
and instant messaging-type conversations
-
no longer require two separate tools.
-
Next thing we want to show you is how easy it is
-
to add a new person to an ongoing conversation.
-
Can I just introduce my brother Jens, by the way?
-
Give him a hand, please.
-
[cheers and applause]
-
So we want to--
-
We want to add Jens to the conversation.
-
If this was email, I would take the last message here,
-
reply to it and add Jens to the recipient list.
-
There's two problems with that.
-
For starters,
-
because we branched the conversation up here,
-
that last email message
-
would not contain the entire conversation.
-
But also, if Stephanie then later
-
went and replied to an earlier message of mine,
-
Jens wouldn't get that anyway.
-
You end up with these cat and mouse games.
-
In the Wave model, all you have to do
-
is make Jens a participant in the wave like that.
-
And now I'll switch over to Firefox here
-
where Jens is already signed in.
-
Jens Rasmussen: So now that I'm on the wave,
-
um, I'm going to open it,
-
and, of course, everything is going to be marked
-
as unread for me.
-
But because I was added late,
-
I didn't get to see Lars's message in one piece,
-
and by the time I'm added they could be arbitrarily far apart.
-
So we added a feature called Playback.
-
So I get to see Lars's original message,
-
Lars asks Stephanie, Stephanie replies,
-
Steph does in-line reply, and so on, and so on.
-
[applause]
-
Thank you.
-
So Playback turns out to be a really useful feature,
-
particularly when the wave
-
starts picking up more structure,
-
and we'll show you more of that later.
-
But now that I've caught up on this wave,
-
I'm going to just add my reply.
-
"Me too."
-
Oh, I think I crashed.
-
Lars Rasmussen: Did I mention that it's a developer preview?
-
[laughter]
-
So we made sure to inject a few bugs
-
so that you wouldn't have too high expecta--
-
I'm just kidding.
-
Jens Rasmussen: Did you notice how quickly it reloads?
-
[laughter]
-
Did we mention we used GWT?
-
All right, so I'm going to add my reply.
-
"Me too.
-
Don't forget your keys."
-
And then I'll hand it back to Lars.
-
Lars Rasmussen: Thank you.
-
So that's how easy it is to add a new person
-
to an ongoing conversation.
-
And so often we end up having
-
very nice group conversations in Wave.
-
And then occasionally you want to say something
-
in a wave that's not visible to all the participants.
-
We call that a "Private Reply,"
-
and I'll add one down here at the bottom,
-
and I'll say,
-
"Let's buy Steph a reeeally nice present."
-
Hannon: I wrote this part.
-
Lars Rasmussen: And then I will add just Jens,
-
and you will see,
-
if I just quickly flip over to Jens's browser,
-
and scroll down,
-
he sees that private reply,
-
but if you look at Stephanie's screen,
-
she doesn't see it.
-
If you remember, I've explained
-
that a wave is a tree structure of messages.
-
Essentially you can take any sub-tree of the wave
-
and restrict access to a subset of the participants.
-
Okay, I switch back to my own account, here.
-
The next thing we want to show you
-
is how attachments work in Wave.
-
So we've been on a boat trip--
-
It was very nice, thank you--
-
And we all got pictures.
-
I have six of them sitting here on my desktop,
-
and I'm going to drag them onto the wave like this.
-
[applause]
-
Hannon: You might not have noticed,
-
but the thumbnails appeared on my screen
-
long before the full images were uploaded from Lars's computer.
-
I'll show you that again
-
by dragging in my own photos from iPhoto.
-
Ready? Here we go.
-
Lars Rasmussen: And you can see them show up over on my screen.
-
audience member: Yeah.
-
[applause]
-
Lars Rasmussen: Don't be shy, you guys.
-
If you like what you see, don't be shy letting us know.
-
[cheers and applause]
-
We can--we can handle pretty much any amount of applause.
-
[laughter]
-
Hannon: This feature--
-
drag and drop from the desktop to the browser--
-
is the one part of Wave that HTML 5 can't support yet.
-
We're working on a proposal to add it to the standard.
-
In the meantime, you need to download Gears
-
for this specific feature to work.
-
It's the only part of Wave that you need Gears for.
-
When Lars dropped in his images,
-
you might've noticed at the bottom of the Wave panel
-
there's an Image menu
-
with actions you'd probably do on images,
-
like upload or download.
-
What's important is these actions
-
apply to all the images in the wave,
-
not just the ones I dropped in,
-
which makes Wave really an easy, lightweight way
-
to create a group photo album together,
-
which is surprisingly hard to do with today's tools.
-
Lars Rasmussen: And so here's the photo album.
-
This is Captain Athena.
-
Here's the hard life down under.
-
And as advertised, you'll see over here
-
Stephanie's images show up in my slideshow
-
so that I can show you
-
just how much fun life down under is.
-
And that's images.
-
So that's how easy it is to share photos in Wave.
-
This was a group trip.
-
We'll all throw our photos in here.
-
We'd probably share it with the rest of the office
-
to make them envious.
-
In this particular case, it's not clear
-
that we want everyone to know that we went shopping together.
-
And so one of the features down here
-
lets me copy just the images
-
from this wave into a fresh wave.
-
"Boating in January.
-
Enjoy all, here and yonder."
-
And then I'll add Stephanie to this.
-
I could now share that with the rest of the office.
-
Now, this feature here of extracting images
-
from a wave and putting them in a new one
-
is actually part of a very important
-
design principle for us.
-
Namely that we care just as much
-
about the product of the wave as we do the wave itself.
-
And we'll show you more examples of that later.
-
Yes, we will.
-
Um, I forgot what's next.
-
Hannon: How 'bout we show them the embedding APIs?
-
Lars Rasmussen: Excellent idea.
-
Okay, thank you. So...
-
[laughter]
-
She's right.
-
We should've rehearsed this before coming this morning.
-
Just kidding.
-
So the first--
-
The first category of, um, APIs that we want to show you
-
are APIs that let you embed waves onto your webpage.
-
It is very similar to the Maps API,
-
which, by the way, um, thank you, everyone who used it.
-
We consider your enthusiasm for that API
-
an enormous factor in that product's success,
-
and we're hoping, obviously, to repeat that with Wave.
-
Hannon: Give a round of applause to themselves.
-
Lars Rasmussen: Oh, yeah, a round of applause to yourself.
-
Well done. [applause]
-
Lars Rasmussen: Okay, so... Hannon: Yay, developers!
-
Lars Rasmussen: Here's an example application.
-
It's a little blogging site we've built.
-
It's over on Google App Engine,
-
but you could build it anywhere you host your website.
-
And this blogging site--
-
In addition to embedding waves on its pages,
-
it provides me with this robotic participant
-
that we affectionately call Bloggy.
-
All I have to do is add Bloggy to the wave,
-
and now you'll see--
-
You can probably not read that,
-
but on that yellow banner,
-
all users on the wave is now warned that Bloggy,
-
this new participant, has published the blog
-
on a page which we built over an app engine.
-
Can I just introduce Gregory Delasander?
-
He's another PM on the team.
-
[cheers and applause]
-
And he's going to show you the blog site now.
-
Delasander: Hi, I'm Greg,
-
and I'm a huge fan of Lars's blog,
-
just like everybody on the team is told they should be.
-
I'm going to show you... Hannon: He makes us read it.
-
Lars Rasmussen: It's a good blog. Come on.
-
Delasander: Oh, hold on just a second.
-
Did we lose...
-
Hannon: Did we lose VPN?
-
Delasander: Yes, I think we might have.
-
Hannon: Lars, this is where you do the dance.
-
Delasander: Lars, dance a little bit.
-
Lars Rasmussen: Everyone look at me.
-
Don't look at his screen.
-
[humming]
-
The Wave dance.
-
Delasander: I think we lost all connectivity.
-
Lars Rasmussen: Neener, neener. Neener, neener.
-
There's not a-- Delasander: And then...
-
Lars Rasmussen: There's not a lot of people in the world
-
that can have their demos as spectacularly fail
-
in front of 4,000 people and not break a sweat.
-
Hannon: It wasn't the demo, it was the network.
-
Lars Rasmussen: We wish we were one of them.
-
Delasander: Excellent.
-
Lars Rasmussen: I think your proxy server might be missing.
-
Oh, there we go. Hannon: All right, we're back.
-
Delasander: So as I was saying...
-
The blog.
-
So in the blog, one of the cool things you'll s--
-
you can see is that we're not just embedding the images,
-
we're actually embedding the whole wave
-
with all of its UI.
-
This means that I can respond.
-
"Hey, that looks fun. Why wasn't I invited?"
-
[cheers and applause]
-
The same way we embed--
-
And we--we do--
-
You can respond in the same way you do in the Wave client.
-
Lars Rasmussen: Exactly.
-
And so now, I can see, obviously, uh,
-
Greg's question from inside my Wave client.
-
I can answer from in here.
-
I don't have to go to the blog site to do that.
-
I could if I wanted to, but I can stay here.
-
"Um, I lost the phone with your number."
-
I really, truly can't spell.
-
Here we go.
-
Delasander: So one of the things you just saw
-
is that I happened to be online when Lars was online,
-
and I saw his response coming in live on his blog.
-
That's not always going to be the case.
-
Since I responded to this blog,
-
it'll show up in my Wave client.
-
Right after I refresh my Wave client.
-
Um, it will show up in my Wave client
-
and I can continue the conversation in there.
-
"But, Lars, I live next door."
-
[laughter]
-
And, um-- And then we can--
-
That response shows up on the blog,
-
we can continue the conversation from there,
-
and anyone else can join in that conversation.
-
Lars Rasmussen: Thank you, Greg. Delasander: No problem.
-
[applause]
-
Lars Rasmussen: Thank you.
-
And so this, again, is an example
-
of how to use our embedding APIs to put blogs on your web pages,
-
and here we showed you with a blogging site,
-
but you could imagine discussion group sites,
-
community forums--
-
if you have a rich-media site
-
you can let your users discuss that using waves.
-
The benefit for developers, of course,
-
is you get to provide this very live, rich experience
-
with very little code.
-
For your users, for starters, they get to use a familiar UI,
-
but for those of your users that have Wave accounts,
-
they get to walk around the Web
-
and aggregate the conversations they're interested in
-
into the Wave client so that they don't
-
have to go check back on 10,000 different pages
-
whether someone responded to them.
-
Which will make flame wars so much more effective.
-
[laughter]
-
She hates that joke.
-
Hannon: I hate it. [laughs]
-
Lars Rasmussen: Okay.
-
So that was an example of how to embed waves.
-
The embedding APIs can do other things,
-
and Stephanie will show you that now.
-
Hannon: So we invited some of our colleagues
-
from Brazil and India to Sydney
-
who work on one of our social networks called Orkut.
-
We wanted to build a demo of what it could look like
-
to put waves inside of Orkut.
-
Obviously, it's a place where lots of discussions happen.
-
It demonstrates three important principles,
-
or features, of our embed API.
-
Let me load up the demo.
-
So here's my Orkut account.
-
And you can see there's a Wave panel in the middle.
-
And the first thing is I can create a wave on Orkut.
-
So I'm starting a new wave, and I'll say, "Brazil trip?
-
Wonder when Lars will let me go."
-
The second important feature is that you can
-
use contacts other than your Wave contacts.
-
In this case, the authors of the site
-
chose to use the Orkut contacts,
-
so I can add some of my Orkut friends
-
like Sid, Torston, and Rodrigo,
-
who all helped build this demo.
-
The third principle is that I can embed a "Search" panel
-
inside of Orkut using the embed API.
-
I'll show you that now.
-
I can search for all my waves from here.
-
And so on. And look at them.
-
So that's waves embedded in Orkut.
-
What's important is that our embed API
-
is powerful enough for you to build your own Wave client.
-
In this case, the Orkut team
-
chose to focus on waves created inside of Orkut.
-
But just like in the blog example,
-
I can go back to my Wave client,
-
and I can see the wave I started there.
-
"Wonder when Lars will let me go to Brazil."
-
So that's the embed API.
-
Lars Rasmussen: You guys-- [applause]
-
Thank you.
-
Are you guys feeling inspired yet?
-
So remember that we're all going to give you accounts
-
on a sandbox build,
-
which is in fact the build that we're demo-ing from later today,
-
and this is all sample applications
-
that we're hoping you'll pick up
-
and build much, much cooler things with.
-
Okay, so the next thing I want to show is
-
of course you're going to want Wave on your mobile devices,
-
and I have an Android and an iPhone here,
-
and I was going to show you how well it works communicating
-
from mobile devices to the desktop,
-
but you guys are all on Facebook, aren't you?
-
Because I can't get on the wireless.
-
[laughter]
-
So if it doesn't work, it's your fault.
-
Okay, so you can see my inbox over here.
-
This is on the Android device.
-
Here's an open--
-
uh, the same open wave we saw before.
-
You see the pretty pictures here.
-
And then I can click the "Reply" button like this,
-
and you'll see over on Stephanie's screen,
-
which I can't see.
-
You will see a reply.
-
Imagine I was actually on a network,
-
and then I could type in, "I am on the boat."
-
Done.
-
Notice again my spelling.
-
And nothing is going to show up over there
-
because we haven't yet figured out
-
squeezing this through without a connection.
-
Maybe we'll show you that.
-
[laughter]
-
Hannon: As long as it's your fault that it's not working.
-
Lars Rasmussen: We are--
-
Hannon: I just don't want to screw up the--
-
Lars Rasmussen: We are working on it.
-
Okay, so that's mobile.
-
Hannon: How 'bout we talk about editing?
-
Lars Rasmussen: Oh, that's a brilliant idea.
-
Thank you.
-
Okay, so the next thing we're going to show.
-
Again because, um, there's only--
-
Back to my desktop. Thank you.
-
There is only one copy of the wave out there.
-
Even though we put these pictures on my blog,
-
I discussed them with Greg,
-
uh, we had them on my mobile device.
-
Now I notice that some of the captions
-
are kind of wonky.
-
And all I have to do is click this "Edit" button here,
-
and then I can fix that.
-
Kayaks. Beer Man.
-
Thank you. [applause]
-
Hannon: And as you notice,
-
the captions are updating on the blog.
-
Lars Rasmussen: Yes, hopefully you saw that the captions
-
were actually updating live on the blog as I was typing.
-
So, here I edited my own message,
-
but we actually let users edit each other's messages as well,
-
which is a very nice effect that in addition
-
to everything we showed you already,
-
you can use waves
-
to collaboratively author documents,
-
which we'll show you now.
-
So let's leave the boat behind, and let's go to work.
-
Stephanie.
-
Hannon: As Lars mentioned, I'm a product manager,
-
and I often have to take notes in a meeting.
-
Today I have to decide if I want to send those notes
-
out on email because I want people to discuss them,
-
or if I'm going to put them in a dock or a Wiki,
-
'cause I want other people to help me edit them.
-
With Wave you don't have to make that choice.
-
You can do both discussion and content collaboration
-
in one tool.
-
So these are our meeting notes.
-
I'm going to add Lars,
-
Jens, Greg, and ACD.
-
[Lars Rasmussen and Hannon speak over each other]
-
Lars Rasmussen: Pardon me.
-
Hannon: Then you open it.
-
Lars Rasmussen: Then I open it.
-
And even though this is Stephanie's message,
-
I can click that same "Edit" button
-
and change this to "glorious."
-
And then I can add an action item.
-
"AI. Make more better AIs, already."
-
Whoo, like that.
-
Thank you.
-
[applause]
-
Thank you.
-
And so that's how easy it is
-
for me to edit Stephanie's message.
-
We want to show you now how it looks
-
to the other participants on the wave--
-
the fact that I edited her message.
-
We'll start with Stephanie.
-
Hannon: So you can see the wave pop back into my inbox
-
because there's new material.
-
If I open it, I see the markups.
-
So I see the changes that Lars made.
-
Lars Rasmussen: Thank you.
-
[applause]
-
Hannon: We haven't implemented it yet,
-
but we'll also have a little description at the top
-
that says Lars edited this message.
-
What's important is I see these markups
-
not because I wrote the original message,
-
but because I saw the original message.
-
Anyone who saw my original message
-
would see these same markups
-
the next time they visited the wave
-
after Lars made his edits.
-
Jens Rasmussen: All right, now,
-
I didn't get to see the original message,
-
so when I open up this wave,
-
I just see the current version of it.
-
But I do get to see
-
that both Stephanie and Lars wrote this message.
-
Most of the time I'm not going to care,
-
but if I do care, then Playback is my friend again.
-
So I see Stephanie's original message,
-
she adds Lars,
-
and then I get to see Lars's edits.
-
[applause]
-
Thank you.
-
So now that we have accountability--
-
accountability in place,
-
we're going to allow everybody on a wave
-
to edit everything by default.
-
When something is changed,
-
the author is notified immediately,
-
and, if needed, can take action.
-
and everybody who's on the wave can find out who did what.
-
So Stephanie promised that we were going to do
-
collaboration and communication using the same tool.
-
Hannon: I did. Jens Rasmussen: So I'm going--
-
Now that I know that Lars made this--the request for more AIs,
-
I'm going to use the in-line reply tool we showed earlier,
-
um, to add my reply here.
-
"No, enough AIs already."
-
My spelling is not doing well either.
-
Lars Rasmussen: It's hard when 4,000 people are watching.
-
Jens Rasmussen: Typing and talking?
-
It's a little bit too much.
-
There we go. So I'll hand it back to Lars.
-
Lars Rasmussen: Okay, thank you.
-
So notice--
-
Notice that we never said, "Let's start a document, here."
-
These are all just waves.
-
The only thing different here
-
is that we chose to think of that opening message
-
more like a document we're collaborating about
-
than a message that starts a conversation.
-
And then we're choosing to think about that in-line reply
-
more like the beginning of a conversation
-
about the point in that document.
-
But to the system, they're all just waves,
-
and in fact, you can collaboratively edit
-
any message in the tree.
-
Doesn't have to be, uh, document-like at all.
-
Stephanie often comes and very friendly fixes
-
all of my spelling errors.
-
And so we think this combination of collaborative editing
-
and in-line discussion
-
makes for a very powerful collaboration tool.
-
And I want to show you that with a design document
-
that the team wrote a while back.
-
Let me just reconfigure my client, here.
-
I'm going to go do a safe search, find the document here,
-
Let me make some more space for it.
-
And you'll see here that it's a RISTEX document.
-
It's got headlines, it's got bullet points.
-
It's got illustrations, different types of fonts.
-
And then it's interrupted
-
by these little snippets of conversation
-
that help facilitate the collaboration.
-
And as always, the best way to see how this happened
-
is to play back the wave.
-
And you'll see Steven, our trusted server guy,
-
started out with a terse draft.
-
He added the rest of the team
-
Lars the manager says, "Please do more work."
-
Steven grudgingly adds another paragraph.
-
He says, "Yeah, whatever."
-
Then Stephanie the PM makes an edit here.
-
She adds a comment there,
-
starts a discussion there, and so on.
-
I can use the slider here to drag it
-
to anywhere in the history of the wave.
-
And we're planning a bunch of power tools
-
that come with Playback.
-
For example, I might ask it
-
only to play back Stephanie's contribution.
-
So I might ask it to only play back a single message
-
or even a single paragraph inside a message.
-
we're definitely going to let you take
-
one change in the history
-
and revert it at the end of the history.
-
Maybe name aversion so that you can find it again and so on.
-
Playback is going to be a really powerful tool
-
for investigating and manipulating
-
the entire history of the wave.
-
Thank you.
-
[applause]
-
And so now imagine we're done with the design document.
-
Or we find we're in a good state;
-
we want to share it with a wider audience.
-
You'll notice it's not super comfortable reading a document
-
interrupted by all this discussion,
-
so we added this widget here
-
that lets you hide and show some discussions,
-
but also, just like we extracted images from a wave earlier,
-
we let you extract the current version
-
of any message in a tree into a fresh wave.
-
Like this.
-
And now I have a fresh wave
-
with the pristine product of our work,
-
which I can now submit to the server
-
and share with whomever I like,
-
put on a mailing list internal blog or even keep working on.
-
And in fact, we're planning more features here
-
for document production.
-
Imagine you go back and do more work
-
in the original wave.
-
Then you'll be able to merge just those changes
-
into that same product wave.
-
The product wave will just have a two-step history now,
-
where each step is attributed to whoever did the copy.
-
In fact, and you guys will recognize this as, um,
-
inspired by source-controlled systems.
-
We'll have you--
-
We'll let you have a whole string of work waves,
-
all pointing to the same product wave.
-
You can have different themes
-
working on different parts of a wave,
-
and then when one team merges
-
and that changes into the product wave,
-
the other teams can pull that down,
-
merge it with the local changes, and so on.
-
So this is going to become
-
a very powerful document production tool.
-
Thank you.
-
[applause]
-
We showed you this, of course, with, um,
-
with, uh, rich text documents.
-
There's no reason we shouldn't
-
later add spreadsheet-type functionality in there,
-
or presentation building-type functionality in there.
-
In fact as we'll show you later, we've taken great care
-
to make the content model inside Wave extendable,
-
both by us and by you.
-
Okay, the next thing I want--
-
Hannon: Why don't you just talk for a minute
-
before you open it?
-
Lars Rasmussen: Talk for a minute...
-
Hannon: You know.
-
Lars Rasmussen: Before I open it.
-
Hannon: 30 seconds.
-
Lars Rasmussen: We could do a little interpretive dance
-
while we open it.
-
It's not that there's anything wrong
-
with the thing I was about to open,
-
it's just that--
-
How're you guys doing?
-
[laughter]
-
Are you having a good time?
-
I know it's a long demo. Thank you.
-
Don't be shy if you like it.
-
Hannon: All right, we're ready.
-
Lars Rasmussen: There's a whole bunch of people
-
in blue shirts working feverishly over there.
-
[chuckles] And we're ready.
-
Okay, so here is a wave, um...
-
Here is a wave. That's right.
-
So my little introduction here is the following:
-
We're going to show you now
-
the thing we had the most fun working on.
-
As in this was the hardest thing we did.
-
Um, which is to let more than one person
-
edit the same message at the same time
-
and still transmitting the characters live on the wire.
-
So we have a set of pictures here,
-
and Stephanie is going to start
-
at the top-left editing the captions.
-
You can see on my screen
-
I can see exactly where that orange label--where she is,
-
and I'm going to start from the lower-right.
-
Hannon: "Thumbs up."
-
Lars Rasmussen: "Spelling Google."
-
Hannon: "Lars in the lead."
-
Lars Rasmussen: "Smiley David."
-
Hannon: "Wave crew hiking." Lars Rasmussen: "Kapow."
-
[applause]
-
Thank you.
-
Now we're very close to each other.
-
I'll add some styling here.
-
I'll make this italic.
-
Oh, boy, if someone can add some color.
-
We can do this.
-
Notice how close we can edit to each other.
-
You can see we've got a couple of--
-
of our team has joined us.
-
We've got three people here.
-
Casey, Steph, Ophir and Dan.
-
We have four people now,
-
editing the same document right next to each other.
-
[applause]
-
Thank you.
-
Thank you.
-
And so apart from hours and hours of fun
-
just chasing each other's carrots around on the screen...
-
[laughter]
-
Hannon: It's a lot of fun. Lars Rasmussen: A lot of fun.
-
Um, the--the--this sort of live, concurrent editing
-
opens up a whole set of new ways of using the tool.
-
We're actually still discovering some.
-
Imagine you're in the same room,
-
you're taking notes from a meeting.
-
Oftentimes people don't even come to the meeting,
-
they just open up the wave, see the notes being taken,
-
they just pop their questions in the wave, and so on.
-
I want to-- while I'm showing off our edit,
-
I want to make sure you see
-
that it supports right-to-left languages.
-
This is Ophir speaking in Hebrew.
-
Thank you.
-
[applause]
-
You see up at the top-left that the editor supports languages
-
that require international input method editors as well.
-
I'm pretty sure that's Chinese.
-
Okay. That's collaborative editing.
-
And now...
-
Man, this is a long demo.
-
You guys want to stand up a little?
-
Stretch. Hannon: Any stretching?
-
Lars Rasmussen: Stretch a little.
-
Hug the person next to you.
-
[laughter]
-
You don't have to do that.
-
Hannon: A hug break. Make some friends.
-
Lars Rasmussen: Um, I want to take a little break.
-
We have lots more to show you,
-
but I want to take a little break,
-
and I want to, um, call out to our friends and colleagues
-
on the Google Web Toolkit team.
-
So--Thank you.
-
[applause]
-
Thank you.
-
So Google Wave is 100% built with the Google Web Toolkit
-
from the first line of code we wrote in a prototype
-
back in early 2007.
-
And as I'm sure you know, the Google Web Toolkit
-
lets you write HTML 5 applications in Java.
-
And then GWT, as we call it,
-
automatically translates that into HTML, JavaScript, CSS,
-
all of those things that then run
-
in all of the modern browsers.
-
And I think that we couldn't possibly have built
-
something this rich without the Google Web Toolkit.
-
In fact, I don't think we would even have thought to do that.
-
I think using modern tools like this
-
changes your way of thinking.
-
When I was still hand rolling JavaScript for Google Maps,
-
I found too much of my brain cycles
-
were used worrying about the constraints of programming
-
in a scripting language in a browser.
-
But by using GWT, I get to write in Java
-
and have this amazing set of tools
-
that come with writing in Java,
-
and we found that our programmers
-
can now spend most of their time
-
thinking about the amazing potential of the Web.
-
And by the way, this is both if you're on a desktop
-
or if you're on a mobile device,
-
when I showed you on the Android and iPhone here,
-
Wave was running in the browser in both of those phones.
-
GWT makes that fairly easy to do.
-
It's actually the same code
-
that runs in those mobile devices,
-
it's just a different layout.
-
We estimate that the extra requirement of serving this
-
both into desktop browsers and mobile browsers
-
only adds about 5% extra engineering effort,
-
which I find remarkable.
-
Okay.
-
Hannon: And that graph from yesterday.
-
Lars Rasmussen: Pardon me.
-
Oh, the graph from yesterday. Did you see that?
-
How we built 1.4 megs of code and then all of a sudden
-
it went down to 200k?
-
We like GWT for that.
-
[applause]
-
Hannon: All right. So back to the demo.
-
Let's talk about organization.
-
We learned from our own use of Wave
-
that you get a lot of waves, which is great,
-
but you need tools to organize them.
-
We have things you're familiar with
-
like folders and saved searches.
-
We also have tags and they're shared
-
by all the participants on the wave.
-
So you have just as much incentive
-
to put a great tag on a wave as a great subject.
-
For example, Lars is way too lazy
-
to organize his own stuff.
-
Lars Rasmussen: Oh, yeah.
-
Hannon: So we have a team help him do it.
-
Lars Rasmussen: Thank you. Hannon: [laughs]
-
But the most powerful way to organize waves
-
is with waves themselves.
-
Let me open a wave we used to organize this demo.
-
You can see it has links to other waves in it
-
and you can combine, uh, them in sections, formatting.
-
You can discuss them.
-
And if I click on one of these links,
-
it'll take me to that wave
-
and I can use the back button to go back.
-
So let me show you how easy it is
-
to create one of these wave links.
-
If I missed one, I can just pick it up
-
from the search panel and drop it in.
-
[applause]
-
I'll do that one more time 'cause I think it's cool.
-
Drop it in.
-
So we found on our own team
-
links--wave links are good for more than just lists.
-
We're actually interlinking a lot of waves on our site
-
almost like a Wiki, uh, on our team.
-
Before we get to Wave extensions,
-
which I know this audience is really excited about,
-
I want to show you one more thing
-
that we worked really hard on.
-
I'm going to go up here and search for Google Wave.
-
Lars Rasmussen: I have a feeling, uh, you're going
-
to want to refresh your browser before we do this.
-
Hannon: Just like my inbox, when a wave matches this search,
-
it will pop into the panel.
-
Lars Rasmussen: And so Stephanie has a search
-
for Google Wave over there.
-
I'm teeing up a new wave here.
-
Said, "Wow.
-
I am finally demo-ing Google Wave."
-
Now the reason this hasn't showed up
-
in Stephanie's search yet is I didn't type the E.
-
So what I'm going to do, I'm going to count to three,
-
then I'm going to hit the E,
-
and you guys can count how many seconds it takes
-
before it shows up in Stephanie's browser.
-
One, two, three.
-
[applause]
-
You guys want to-- you guys want to see that again?
-
[laughter]
-
Hey, Stephanie, can you open up that wave for me?
-
Hannon: All right, let me go over there.
-
Lars Rasmussen: Backspace.
-
Hannon: [laughs]
-
[laughter and applause]
-
Lars Rasmussen: E, backspace, E,
-
backspace, E, backspace, E, backspace.
-
We call that the Wave dance.
-
So we've worked really hard on this.
-
We're pretty proud of the result.
-
I should just say after we started using it,
-
we found this is almost too fast.
-
Sometimes, uh, it draws your attention
-
to unfinished work.
-
And we're actually looking for the right balance
-
between speed and not being interrupted too often.
-
Okay, what's next?
-
Hannon: Extensions. Lars Rasmussen: Extensions.
-
The reasons you guys came here.
-
Okay. So the next thing we want to show
-
is the other category of APIs
-
that we're making available today,
-
which is about extending the functionality of Wave.
-
So we have tried hard to maintain a discipline
-
on the team that even significant offerings
-
of our own should be built with our own extension APIs
-
so that your extensions will live
-
as first-class citizens inside Wave.
-
It's similar, actually, to how browsers like Firefox
-
let you extend them.
-
This is just the web site you're extending
-
instead of the browser.
-
So let me show you some examples.
-
You've undoubtedly noticed how all morning,
-
I've been pretending my spelling is bad
-
just so that we could show off our spell-checker.
-
So normally spell-checkers work
-
by matching words up against a dictionary.
-
If they find there's-- if they don't find a word
-
that is in error,
-
the problem is that oftentimes
-
spelling mistakes hits other dictionary words.
-
And so our spell-checker actually takes the context
-
of the word into account
-
and then it matches it up
-
against an enormous language model
-
that we've built from the entire web.
-
Let me show you how powerful that is.
-
We call this the "Bean Soup Demo."
-
"Can I have some been soup?"
-
It puts a red on the line
-
and it knows that I meant "bean soup."
-
Thank you.
-
[applause]
-
Okay, now watch carefully.
-
"It has bean so long."
-
Did you see that?
-
So it is--it has become so good at spell-checking
-
that often, it has enough confidence
-
that we let it automatically correct my errors.
-
Let me show you that again.
-
"Icland is an icland."
-
[applause]
-
"You are to kind."
-
Pretty cool, huh? [laughs]
-
You didn't see that last one.
-
Okay, so that's our spell-checker,
-
or Spelly as we affectionately call it.
-
Let me show you another simpler one
-
that detects links in what you're typing.
-
And we call it Linky.
-
"I love google.com."
-
It immediately puts an underline--.a--
-
ooh, that's not a link-- .u--now it's a link again.
-
[applause]
-
You're wondering what's this all got to do
-
with extensions and let me explain that.
-
So you remember we showed you a robot earlier
-
called "Bloggy."
-
All that one did was publish a blog
-
that let you use the embedding API.
-
But robots are really powerful ways
-
of extending Wave's functionality.
-
They're server-side programs that participate in Wave
-
with all the power of the human participants.
-
You can see from your robot the live changes in the wave.
-
You can make live changes to the wave
-
including adding and removing messages,
-
collaboratively edited messaging,
-
adding and removing participants.
-
You can even start new waves from robots.
-
And the way Spelly works
-
is that it uses our robot APIs to watch what I'm typing.
-
It sits on the server. It watches what I'm typing.
-
It takes every so many words and matches it up
-
against a language model.
-
And then when it finds an error,
-
it uses collaborative editing to edit the content.
-
And in fact, when it doesn't have enough confidence
-
and it put that red underline,
-
if Steph and I were editing the message at the same time,
-
she would also see the red underline
-
and she could be the one taking the suggestion.
-
Linky works in the same way.
-
But who wants to be typing in links all day?
-
We had a very good friend of ours
-
from the Google Search Team build this extension for us here
-
called Searchy.
-
Let's search for Australia.
-
Hannon: We have a really clever naming convention.
-
Lars Rasmussen: And here you can do a Google search
-
from right inside Wave and add the link like that.
-
[applause]
-
You guys want to see that again?
-
I search for Bora Bora. It's so pretty there.
-
I add an image to the wave just like that.
-
Thank you.
-
[applause]
-
Let me just quickly return to our friend Linky.
-
I've got a video sitting here.
-
Let me copy the URL.
-
And inside my wave,
-
I'm going to type "Check this out."
-
And then I'm going to copy the link in there.
-
And then I'm going to dance a little bit
-
while the system spectacularly fails.
-
[laughter]
-
Maybe we'll return to that later.
-
Okay, so that's extensions that we built
-
with internal APIs.
-
And what we're doing today as part of the developer preview
-
is--is make external versions of these APIs
-
available to you guys.
-
The external APIs have almost all the power
-
of the internal APIs.
-
There is a few things we haven't quite figured out
-
how to secure the export.
-
We're working very hard to close the gap.
-
We're going to show you now a series of examples
-
of things that are built with the external APIs.
-
These are all sample codes
-
that are going to be on code.google.com
-
where we'll host the API.
-
Stephanie.
-
Hannon: Any open social gadget can sit inside a wave.
-
In fact, we were about to show you one
-
which might come a little bit later.
-
But we also make an additional API available
-
that lets you the developer make your gadget
-
live and collaborative.
-
I want to show you that.
-
But before I do, I'll digress and tell you a little story.
-
Even though we on this team have been building Wave
-
and thinking about Wave for a year and a half,
-
when we first started using it ourselves,
-
it took awhile for us to discover all the ways
-
Wave can make you more productive
-
because we were so used to older tools.
-
In fact, we're still discovering new ways all the time.
-
I'll show you that by opening a wave
-
and using Playback to tell you what happened.
-
Uh, someone on our team wanted to create a movie outing
-
and we should all go see the Transformers.
-
So he sent a wave out and people did something
-
very email-like and responded.
-
"I'm interested." "What place are you going to?"
-
"Is that really a good movie?" And so on.
-
I tried to get them to see Confessions of a Shopaholic.
-
Nobody went for that.
-
Lars Rasmussen: She's still trying.
-
Hannon: Still trying.
-
So when you look at this wave,
-
it's sort of hard to parse out the important information
-
of who wants to go.
-
So somebody suggested we should all edit
-
the opening message instead of putting it
-
in individual messages.
-
And we cleaned up the wave.
-
Everyone started editing the opening message and so on.
-
This was a much better way to construct this RSVP list.
-
And we could still have discussions
-
about which car to take and so on.
-
Now, we're all engineers,
-
and you can look at this workflow
-
and think there are better ways
-
or there are ways to make this even better
-
using our extensions.
-
So another engineer on our team wrote a gadget.
-
We call this the "yes-no-maybe gadget."
-
Hey. [laughs]
-
[applause]
-
So if you--it's hard to see for you guys, I know.
-
But I'm currently in "No" in the middle column
-
and I'm to change it to "Maybe."
-
And you see it update on Lars' screen.
-
[applause]
-
Lars Rasmussen: And I'm currently
-
in the "Maybe" column.
-
And I click the "Yes" over here.
-
And you'll see it quickly updates
-
on both our screens.
-
Hannon: So you the gadget developer
-
only have to worry about two things.
-
When I click the button,
-
update the state of the gadget in XML and the wave,
-
then we automatically transmit through the server
-
to Lars' client where your gadget
-
has to update the UI to reflect the new state.
-
Now, of course we did all this--
-
ooh, it's a secret though--
-
I, um, uh, don't tell anyone,
-
but we did all this so we could build
-
impossibly fun, addictive games.
-
And we'll show you a few of those now.
-
Lars and I are going to open Sudoku.
-
Lars Rasmussen: Hmm. Hmm.
-
Hannon: And we intended for this to be a collaborative game
-
so we could solve the puzzle together,
-
but somehow it turned competitive.
-
[laughter]
-
And, uh, you get a point for making a good move
-
and a negative point for doing something wrong.
-
You can see Lars' score is going negative.
-
Lars Rasmussen: How can you play Sudoku
-
in front of 4,000 people?
-
Come on.
-
Hannon: Then, uh, back in 1851,
-
Lars and I played this chess game
-
that became very famous.
-
It ended in 23 moves.
-
And it illustrates how well Playback works with gadgets.
-
So if I go into playback and I click forward,
-
you can actually step through the whole game.
-
[applause]
-
So as we mentioned in the beginning,
-
we come from the Maps team.
-
So probably wouldn't be a good demo
-
if we didn't do a Maps gadget as well.
-
It's been a lot of work to prepare for this demo.
-
So I'm going to send Lars a wave about taking a vacation.
-
Lars Rasmussen: Stephanie's favorite topic.
-
She wants to go on vacation in Bora Bora.
-
She's asking me for recommendations.
-
I highlight the term Bora Bora here.
-
And then I click this button that's provided
-
by an extension that you guys could've written
-
that inserts a map to Bora Bora.
-
Thank you. [applause]
-
Hannon: Now, the important thing
-
is my hands are off of my computer,
-
but my screen is still on the right.
-
Lars Rasmussen: And now I click the satellite button
-
and it changes on both screens.
-
And I go zoom, zoom, zoom, zoom, zoom, zoom.
-
[applause]
-
[laughs] Thank you.
-
[applause]
-
And now, Stephanie loves swimming with sharks.
-
And I happen to know that the lemon sharks hang
-
over here.
-
And you can see that I put that marker on.
-
Shows up live over on Stephanie's screen.
-
Now my hands are off.
-
Hannon: And I'll pick up the polygon tool
-
and I'll tell Lars, actually, I want to stay in this area.
-
Lars Rasmussen: And you see that showing up on my screen too.
-
And so again, all you guys have to do with your gadgets
-
is to store updates to the state
-
in the local XML.
-
And then we transmit on the wire
-
and then the other instance of your gadget
-
just updates its state when it gets notified
-
of that change.
-
And so those are client-side, um, extensions.
-
I want to just show you, actually,
-
the team in blue over here is scrambled.
-
And they brought back up Linky.
-
And I wanted to show you what happened
-
when I dropped that YouTube URL into the old extension wave.
-
So you'll see that Linky didn't just recognize
-
it was a link,
-
but it recognized it was a link to a video.
-
It puts this little friendly light bulb
-
on my screen where I can open up
-
a set of suggestions for what I might want to do.
-
Like, for example, I might want to embed the video
-
right inside my wave
-
and play it for you guys.
-
[wobbling noise]
-
Dah nah. Pretty cool, huh?
-
[applause]
-
Thank you.
-
Okay. What's next?
-
So Stephanie showed you a bunch of gadgets.
-
They're all client-side extensions.
-
We want to show you next what you can do
-
on a server side with robots.
-
And we're going to show you three examples.
-
The first one is an application--
-
a collaborative application built entirely within Wave
-
with our extension API.
-
So let me just open up my inbox again.
-
And instead of clicking "new wave,"
-
I'm going to hit this drop-down button here.
-
And I'm going to hit this item
-
called a "new poll."
-
New poll is just a new wave,
-
but with a special robot that comes from an extension
-
that you guys could build called Polly the Pollster.
-
I'll add Steph to the wave as well.
-
Polly added a form to the wave.
-
Yes. And so this is not a gadget.
-
Forms are native to wave.
-
You can put them in there.
-
And now I can fill out the form
-
starting with the title of the poll
-
that I want to conduct.
-
And you'll see as I'm typing in the form,
-
Polly sits on the server side.
-
She saw that letter by letter,
-
and she updated the title of the wave.
-
Now the really cool thing about having forms in waves
-
is that you can fill them out collaboratively.
-
So Stephanie's going to fill in the choices
-
while I add the question here.
-
"Which movie is the best ever?"
-
And you see that Stephanie's filling in the options
-
in the field below.
-
Hannon: Star Wars.
-
Lars Rasmussen: Star Wave. [laughs]
-
Hannon: Not on purpose. [laughs]
-
Lars Rasmussen: Confessions of a Shopaholic.
-
So now Stephanie's going to fill out a number of people
-
that we're going to send the poll to
-
in the recipient list there.
-
She's putting in--
-
Hannon: Done.
-
Lars Rasmussen: Putting in six of them.
-
Now I'll hit the button here that says "distribute poll."
-
Now, what happens is that Polly sees
-
that I hit that button.
-
She fills in a results section
-
in that same wave here.
-
And then she sends out fresh waves
-
with the questions we specified
-
to all the recipients we specified.
-
And Stephanie's one of them.
-
Hannon: So I'm going to answer the poll
-
that Star Trek's my favorite.
-
Lars Rasmussen: And you'll see that Polly updates the results
-
live in the admin wave.
-
With a bit of luck-- thank you.
-
[applause]
-
Okay. So that's the-- an example of an extension
-
built exclusively inside of Wave.
-
The next type of extension we want to demonstrate for you
-
are extensions that integrate Wave
-
with existent communication systems.
-
In this case, we'll show you with everyone's favorite
-
microblogging service, Twitter.
-
Hannon: So at this point, you're probably wondering
-
how to install these extensions.
-
So let me open a wave.
-
And you probably won't be surprised to hear
-
that extensions can live inside a wave.
-
Here's their--a bunch of puzzle pieces
-
showing some of the things we're using today.
-
All I have to do if I want to use one of these inst--
-
extensious--is--
-
Sorry. Click the "install" button.
-
And you can see over here, there's a new drop-down menu.
-
And I have the option to create a new twave.
-
Lars Rasmussen: A wave, of course--twave, of course,
-
is a wave of tweets.
-
Hannon: You can describe as a developer
-
how your extensions hook into Wave.
-
It could be a keyboard shortcut,
-
a button on the tool bar.
-
It could be something like a new twave button.
-
There'll be a confirmation page
-
that tells the users how you're going to interact.
-
We haven't quite implemented that yet.
-
So let me log in here.
-
I have to tell you that Lars created my Twitter account.
-
Lars Rasmussen: I made her Twiffanie.
-
She hates that.
-
Hannon: [laughs]
-
Lars Rasmussen: She's Twiffanie at Twitter.
-
Hannon: I think that tab button should be implemented, you guys.
-
[laughs]
-
I feel like all sorts of bad stuff is about to happen.
-
[laughs]
-
All right, so I'll sign in to Twitter.
-
And you can see tweets
-
from all the famous people I follow.
-
And down here at the bottom, Lars.
-
Lars Rasmussen: No.
-
Hannon: I'm just going to close it.
-
We still haven't, uh, uh...
-
I wanted to get the contacts out.
-
Um, it's important you can see that each of these avatars,
-
they're not necessarily Wave users.
-
Through our APIs, you can be a proxy
-
for contacts on a different system.
-
So I have Lance Armstrong, Ryan Seacrest,
-
lots of different people.
-
If I go down here and I look for Lars' tweet,
-
I can respond to it.
-
He says, "The demo's going pretty well."
-
And I'll say, "It ain't over yet."
-
[laughs]
-
Lars Rasmussen: And now I've logged in
-
to Twiffanie at Twitter over here.
-
And if I refresh the page,
-
you'll see that the extension took Stephanie's wave reply
-
and tweeted it.
-
Thank you.
-
[applause]
-
Hannon: Now Tweety also lets you search
-
over the public timeline of Twitter.
-
For example, for a phrase like "Google Wave."
-
So I'm going to start a new twave.
-
Lars Rasmussen: You're going to search for Google Wave now?
-
Hannon: Gonna do it.
-
Lars Rasmussen: How brave it that?
-
Hannon: [laughs] I'm not afraid.
-
So try again.
-
I'm going to log in.
-
And then I'm going to type Google Wave.
-
So we did this yesterday and there are only two tweets.
-
One of them was a woman interviewing at a company
-
called Wave so she said, "I should google Wave
-
before my interview."
-
So now let's sign in. See what happens.
-
Lars Rasmussen: * Doo doo * Hannon: A lot more than two.
-
Lars Rasmussen: Oh! [laughs]
-
Hannon: And we can go down to the bottom
-
and see tweets still coming in.
-
Lars Rasmussen: Oh, my God, you guys, thank you.
-
[laughs] Wow. Thank you.
-
[applause]
-
Hannon: So that was a example of an integration
-
between Wave and another communication system.
-
Lars Rasmussen: I'll just add to the search functionality
-
here, actually, that you can-- you can have Tweety
-
continuously search over in Twitter
-
and update the wave as they come.
-
So you can use them like "twit alerts"
-
for whatever you're interested in.
-
It'll just pop into your inbox.
-
Buggy. Hannon: Buggy.
-
We were reading the tweets.
-
Lars Rasmussen: We were reading the tw--
-
Hannon: Totally threw us off.
-
[laughs]
-
Lars Rasmussen: Okay, the last example
-
of a robot extension we want to show
-
is an example of how you can use Wave extension APIs
-
to integrate Wave within existent workflows.
-
You guys are programmers like us.
-
You probably deal with filing bugs.
-
I want to show you an integration
-
between Wave and the issue tracker--
-
the bugs database over on code.google.com.
-
But this could be any issue tracker Bugzilla could host,
-
whichever is your favorite.
-
So I'll just conjure up a canned message here.
-
And I'll tell you a little bit
-
about how we do bugs on my team.
-
So a programmer has built some code.
-
They send it for code review.
-
They also send a demo to the PMs and the UI people
-
and Jens and I.
-
And then we sit in the room and we test it.
-
And you can't read the text here.
-
But there's a bunch of bullet points
-
with observations we made.
-
We, of course, edited this collaboratively.
-
Some of them are bugs.
-
Some of them are observations for discussion later.
-
Some of them are notes for the UI designers.
-
And, of course, we should now go and file bugs.
-
Um, but instead of doing that manually,
-
we run an extension that lets me just select a bullet point,
-
click this button here,
-
and now a robot enters the fray called Buggy,
-
takes that text, and files it as a bug for me.
-
[applause] Thank you.
-
Hannon: Hey, Lars, why don't you add me?
-
Lars Rasmussen: Yes. Excellent.
-
And I'll add Steph to the wave.
-
The bug--the, uh--the--the-- sorry, the robot
-
also grabs a little summary from issue tracker
-
and puts it right inside the wave.
-
There's a link there to the bug
-
will Stephani--which Stephanie will now click
-
so that you can see the bug sitting over on issue tracker.
-
Hannon: All right, so I'm going to open this bug,
-
number 11.
-
Lars Rasmussen: And while she does that,
-
I'll file a bunch more.
-
You can see how easy it is.
-
And I just triple click here. There's another one.
-
And I'll file that bug too.
-
Okay. And so now, we might send this wave--
-
we might share this wave with our bug triage team.
-
I'll just do that myself.
-
All I have to do is change the assignee here.
-
I'll give this to Stephanie. I'll take this myself.
-
And then this one goes to Lars.
-
Ooh, I'm sorry. Was that Greg?
-
Like this.
-
And now you'll see-- Stephanie will refresh the bug
-
and you'll see the robot change the assignee over
-
in the issue tracker.
-
Hannon: On the left-hand panel where it says "owner."
-
Lars Rasmussen: And also, most issue trackers
-
or bug databases lets you debate bugs--
-
endlessly if I recall-- inside the database.
-
Which is normally not the strength
-
of the database.
-
But it is the strength of Wave.
-
And so instead of debating them over on issue tracker,
-
you can debate the bug from inside Wave.
-
I'll just use the inline reply tool here.
-
And I'll say,
-
"That is so not my fault!"
-
Hannon: And I'll refresh. You can see the update there.
-
[applause]
-
Lars Rasmussen: And so now we can continue
-
the endless debate inside of Wave,
-
which would be much more efficient.
-
We could also build--
-
We haven't done this in the sample here--
-
that if someone wanted to go make a comment
-
over on issue tracker,
-
the robot would see that and update the wave as well.
-
And just like we did a search through Twitter
-
into a-a wave,
-
we could also have the robot start a new wave of bugs
-
and just pull in all of the bugs assigned to you
-
so that you could track them from within a wave.
-
It's remarkable--thank you-- how much more effective
-
this sort of thing makes you.
-
Okay. That's extensions for you.
-
You guys feeling--
-
Hannon: And I think that's two of our Ps.
-
Lars Rasmussen: Those are two Ps.
-
Are you guys feeling inspired yet?
-
Good. Yeah. Thank you. [applause]
-
Thank you.
-
Okay, let's talk a little bit about the protocols
-
and algorithms, um, underlying Wave.
-
So we want Wave, as Stephanie said in the beginning,
-
to be an open system.
-
Obviously, it's an enormous reason
-
behind the success of email that it's an open protocol.
-
Anyone can build an email system.
-
Anyone can email with each other
-
regardless of where they got their accounts from.
-
We want Wave to work the same way.
-
And so we've designed the algorithms--
-
we've designed the protocol to, um, uh, to support
-
what we call "federation."
-
Which means that any organization
-
could build their own Wave system,
-
give accounts to their users even in competition with Google,
-
and then the system will still ensure
-
that we can share waves with each other
-
across these boundaries.
-
And we want to-- we want to first show you
-
how that's going to look.
-
And then we'll talk a little bit
-
about how far along we are with that.
-
So let me--so this is very much work in progress.
-
Everything we've shown you is work in progress.
-
I'm going to sign in to, um, a different version
-
of the system that sits inside our corporate network
-
that has an open port on it for this sort of federation.
-
And we're going to imagine two separate wave systems.
-
One is the one Google has built
-
that you've been looking at all morning.
-
The other one is from Acme Wave,
-
which you'll see over on Stephanie's screen.
-
They have built a separate system.
-
They're actually giving out accounts
-
in competition with Google.
-
You'll realize that their client looks very similar to ours.
-
That's because we're intending to open source
-
the lion's share of the code that we used to build our system
-
so that organizations can get started quickly.
-
And that's how Acme Wave built their system.
-
So I'll start a wave over on my account here.
-
And I will say "Project.
-
You want to work with me on that thing?"
-
And then I will add-- what's your account
-
over on Acme Wave?
-
Hannon: It's Stephanie. Lars Rasmussen: Stephanie.
-
Stephanie on Acme Wave.
-
So Stephanie momentarily has her account--
-
Hannon: Actually, it's Steph. Lars Rasmussen: There we go.
-
Hannon: Sorry.
-
Lars Rasmussen: Stephanie is now a user
-
over on Acme Wave.
-
And I'm going to add her to the wave.
-
Hannon: So I'm going to open up the wave.
-
And he says, "You want to work with me on that thing?"
-
And I said, "I think the guys over at Initech can help too."
-
Lars Rasmussen: [laughs] And so...
-
And so even though Steph and I have accounts
-
on different wave systems,
-
you still get that live
-
character by character interaction.
-
The way it works is that from our two clients,
-
these fine-grained operations
-
travel to our respective servers,
-
then it crosses over and goes back up to our client.
-
And all of the liveness and concurrency control
-
and live--um, sorry, and real-time resolution
-
of conflicts happen in an algorithm
-
that supports this sort of federation.
-
Let's bring a third wave system into the system.
-
So we have a couple of friends, Peter and Milton,
-
that work for a company called Initech.
-
They have chosen to run their own wave server
-
in their server closet.
-
These guys didn't take our code.
-
Milton is the kind of engineer who prefers building stuff
-
from scratch.
-
Hannon: I'm not sure I want to show this, Lars.
-
Lars Rasmussen: Oh, come on. You show it.
-
I'm going to add Peter and I'm going to add Milton.
-
Why don't you want me to show it?
-
Hannon: I'm afraid this crowd might like their UI
-
better than ours and it would break my heart.
-
Lars Rasmussen: Don't break her heart.
-
[cheers and applause]
-
Do you have the wave? Do you have the wave?
-
Hannon: No, 'cause-- Lars Rasmussen: Hmm?
-
Hannon: Just make another edit.
-
So now I have the wave.
-
Lars Rasmussen: So she opens-- Hannon: And if I go into it...
-
[cheers and applause]
-
Lars Rasmussen: Thank you.
-
Hannon: Now I want to show you an important principle
-
of--an important feature of the protocol.
-
So I go back to Acme Wave
-
and I'm going to make a private reply
-
just like you saw earlier in the demo.
-
But I'm going to add everyone except Lars.
-
So I'll say, "What do you think of that Google guy?"
-
So I'll add all of my friends Peter and Milton.
-
Even though this wave is owned at Google
-
and there's copies on Acme Wave and Initech servers,
-
this private reply is never seen by Google
-
and cannot be discovered by Lars in any way.
-
In fact, if Peter and Milton made a private reply
-
between themselves,
-
that wave would never leave their server closet.
-
[applause]
-
Lars Rasmussen: Thank you.
-
Hannon: And I just want to go back over to Milton
-
for a second.
-
You can see the private reply came in there as well.
-
Lars Rasmussen: Okay, so let me just say this,
-
um, federation...
-
that was hard.
-
So we're building this thing
-
with live concurrent editing, and chatting,
-
and instant messaging, and email, and pictures,
-
and all that stuff.
-
And then we throw federation into the mix,
-
which vastly complicates things.
-
It would be so much easier, frankly,
-
from an engineering point of view.
-
If we could just keep this proprietary,
-
then we'd control all the servers,
-
we'd control all the update schedules,
-
and so on.
-
But we think it's worth the effort--
-
and we hope you guys will help us with this.
-
We think the world will be a much better place
-
if this is an open system that everyone can build
-
wave services with it.
-
And so--thank you.
-
[applause]
-
Thank you.
-
[applause]
-
And so let me tell you, um, where we're at with it.
-
So later today, there's a web site--
-
I'll show you the URL later-- that's going to launch,
-
which will have-- it's a very early draft
-
of this protocol.
-
It'll have, I think, four whitepapers
-
describing how the system works.
-
It's going to have, of course,
-
a public discussion forum
-
so that we can start debating how this hopefully bright future
-
of Wave will look.
-
And then like I said, later,
-
we're going to open source the lion's share of our code,
-
which will serve both as a reference implementation
-
of the protocol,
-
but also essentially a production ready system
-
like you saw Acme Wave do.
-
I'm obviously vastly simplifying it here.
-
But essentially, you could take that code,
-
you could put it on top of your own database,
-
and you would have a simple wave server
-
and you would be up and running.
-
Okay. So that's federation.
-
[laughs]
-
Hannon: I'm excited about our next demo.
-
Lars Rasmussen: The next demo is very, very nice.
-
This is something, um, to end off our demo with.
-
It's something, uh, a friend of ours
-
on the Google research team has been building
-
over the past month.
-
I saw it myself the first time just a few days ago.
-
Um, and it blew me away.
-
So, um, let's see.
-
I'm going to make sure I'm on the right system here.
-
I'm back on the sandbox.
-
So again, we've been doing this demo
-
on a system where we'll get you guys accounts.
-
Now, Stephanie is going to log into, um, an account
-
of one of our colleagues, Alexi.
-
And then I'm going to start a new wave.
-
I want to make sure you guys can see
-
what we're typing.
-
I'm making this a little bigger like this.
-
Do you make your font bigger there, Steph?
-
Hannon: Yeah, I was going to wait
-
till you started the wave.
-
Lars Rasmussen: And then I'll start a new wave here.
-
And I'll add Alexi, one of our colleagues.
-
And then I'll add my all-time favorite robot
-
called Rosy.
-
Yes.
-
So, um, Alexi is from France.
-
His English is not terribly good.
-
Hannon: Aww!
-
Lars Rasmussen: For the purposes of this demo.
-
[laughter]
-
And Rosy is a robot that very kindly translates
-
what I'm typing.
-
"Hello, world!"
-
[applause]
-
"What do you think
-
"of this demo--
-
of this demo?"
-
And now Alexi's typing in France.
-
And I get to see him saying, "Ah, yes...
-
since new--we are in can--use--used--"
-
Translates word by word, character by character
-
as he's typing.
-
Rosy speaks, I believe, 40 languages.
-
She can translate between any pair of them.
-
Um, she's quite the thing.
-
Okay. That finishes our demo.
-
Oh, thank you.
-
[cheers and applause] Thank you. Thank you.
-
Thank you. Thank you. Thank you.
-
Thank you.
-
Thank you. Thank you. Thank you. Thank you.
-
[cheers and applause] Thank you. Thank you.
-
Hannon: I think they like it. Lars Rasmussen: They like it.
-
You guys like it? Okay. Thank you.
-
Hannon: Thank you. Wow. Thank you. [laughs]
-
[cheers and applause] Lars Rasmussen: Thank you.
-
Thank you. [whistling and cheers]
-
Hannon: They have a lot of skills.
-
[applause]
-
I think... Lars Rasmussen: Thank you.
-
Hannon: If they really liked it...
-
[man shouting indistinctly]
-
If you guys--you guys really liked it,
-
you could do a wave.
-
Lars Rasmussen: So, so, so-- Hannon: Anyone?
-
It's time to do the wave. Lars Rasmussen: So--
-
So, um, what do you guys think?
-
Okay. [laughs]
-
So just-- Hannon: Thank you for filming.
-
Lars Rasmussen: Just to summarize,
-
um, what we like to think we've built here
-
is really quite a simple communication object
-
called a wave.
-
And we've showed how you can use it
-
for quite a lot of different types
-
of communication and collaboration.
-
We showed you how plain vanilla email-type conversations
-
could be done.
-
We showed you how instant messaging conversations
-
could be done.
-
We showed you how easy it is to share photos
-
and other rich media types with it.
-
We introduced a platform that we're hoping you guys
-
will pick up
-
that will let you build things like blogging sites,
-
discussion groups, uh, letting your users
-
discuss images on your web site.
-
With the editing functionality,
-
you can see you can build Wiki-like sites
-
with that as well.
-
We showed you how you can use waves
-
to collaboratively edit documents.
-
We showed you a rich set of extension APIs
-
that could let you build everything from games,
-
through collaborative applications inside a wave,
-
through integrations with other communication systems.
-
We showed you Twitter.
-
We're hoping you guys will build gateways
-
from Wave to email, to Facebook,
-
to instant messaging, and so on.
-
We showed you how you can use these extension APIs
-
to also integrate waves into work flows.
-
Whew. Okay.
-
And now...
-
Hannon: Just going to bring up...
-
Lars Rasmussen: For the administrativia
-
at the end,
-
I want to-- I want to just point out--
-
I forgot that earlier
-
that we have three breakout sessions
-
that I don't believe has been in the program so far.
-
Um, the first one at noon is about, um, the API.
-
If you can only come to one of our breakout sessions,
-
please make it that one.
-
The next one is a little run-through
-
of some of the more exciting pieces of technology
-
under the hood.
-
We're going to show you from the top of the--
-
top of the stack how our amazing spell-checker works,
-
how the rich text editor in the browser works,
-
and the algorithms that we used underneath
-
to do all the concurrency, control,
-
and conflict resolution and so on.
-
And then at 2:30,
-
one of our client team tech leads
-
are going to explain how we build
-
the web application with the Google Web Toolkit,
-
why we love it so much,
-
and what some other future plans are.
-
We also have in Room B4
-
from noon till 4:30 office hours
-
where you guys can come talk to the team in blue here.
-
They love talking.
-
And then I wanted to show you,
-
um, three important URLs here.
-
So for starters, wave.google.com
-
is going to be the home of Google Wave
-
when we launch it later in the year.
-
If you go there now or when the site goes live
-
in a little bit,
-
um, there is a sign-up form there
-
where you can sign up for notifications
-
when we launch it.
-
There's also going to be a beautifully edited video
-
of today's keynote.
-
Um, the API site is going to go live...
-
man: Already live.
-
Lars Rasmussen: The API site is already live.
-
No wonder I couldn't-- couldn't get a connection
-
to my mobile phone before.
-
It's at code.google.com/apis/wave.
-
It's got the API. It's got the documentation.
-
It's got the code samples we showed before.
-
Actually, I should just mention really quickly
-
the bug--the--the issue tracker integration
-
we showed at the end,
-
we have to cheat ever slow slightly
-
by using, uh, using an internal API
-
to the issue tracker.
-
I think they're working really hard
-
making APIs available.
-
So that particular sample is not going to be there
-
for--for a wee while.
-
Lastly, at waveprotocol.org,
-
you'll find the protocol draft,
-
the whitepapers, the discussion forum,
-
and so on if you guys are interested
-
in helping us, um, build that wave
-
to be an open system.
-
Hannon: You should tell them about the email.
-
Lars Rasmussen: Yes.
-
And the way you're going to get an account
-
is you'll receive an email later today
-
that explains where you can go and sign up
-
for an account,
-
which you will get shortly.
-
Okay. So, look, the last thing I want to say,
-
um, you can probably imagine it felt kind of nice
-
that you guys seemed to like what we built.
-
Um, one of the-- one of the best times
-
in my professional life
-
was after we launched Google Maps back in 2005
-
and developers started doing all kinds of crazy things
-
with Google Maps.
-
I hope some of you are here.
-
This was even before we had an API on Maps.
-
We scrambled to put an API on Maps.
-
And it's, uh, it's-- it's become very popular
-
and it's a huge driving force of success.
-
We learned a very important lesson
-
that--that you guys, developers,
-
are incredibly important to the success
-
of the kind of products that we build.
-
And so I can't wait to see what you guys
-
are gonna come up with.
-
Um, please, please, please, check it out.
-
Build cool stuff. Surprise us.
-
I just can't wait to see what you come up with.
-
Thank you very much.
-
[cheers and applause]
