Google Unveils Wave to Replace Email With Open Real-Time Protocol
Google
Email's forty-year-old model of transmitting discrete message copies is obsolete, requiring a transition to open, federated conversation objects that synchronize multi-user edits and keystrokes in real time.
Google introduced Google Wave at Google I/O 2009, combining email, instant messaging, wiki collaboration, and media sharing into a unified, hosted communication object. (0:01)
The entire web client was built with Google Web Toolkit (GWT), allowing a single Java codebase to target modern desktop browsers, Android, and iPhone with only a 5% marginal engineering effort for mobile adaptation. (37:48)
Wave fundamentally alters traditional messaging latency by streaming keystrokes live character-by-character across concurrent users and federated server domains. (10:42)
Google released early federation specifications and four whitepapers, committing to an open federation protocol and open-sourcing the majority of the production codebase. (70:13)
Detailed notes
## Background
Published by Google on YouTube on May 29, 2009, this video captures the Google Wave Developer Preview presentation during the Day 2 Keynote of Google I/O 2009. According to the page description, the keynote serves as an introductory presentation of Google Wave, directing viewers to wave.google.com to learn more.
## TL;DR
Engineering leads Lars Rasmussen, Jens Rasmussen, and product manager Stephanie Hannon introduce Google Wave, an ambitious open-source communication and collaboration platform designed to replace legacy email and instant messaging. Built entirely in the browser using HTML5 and Google Web Toolkit (GWT), Wave unifies real-time character-by-character typing, collaborative document editing, rich media, and chronological playback tracking into a single hosted conversation object. The team demonstrates extensive platform capabilities, including embedded web widgets, collaborative OpenSocial gadgets, server-side automated robots for spell-checking and language translation, and live cross-domain federation across independent server instances. Concluding with developer resources and protocol whitepapers, Google frames Wave as an open, federated ecosystem intended to evolve collaboratively with third-party developers.
## Atmosphere & style
The presentation carries the electric, forward-looking optimism characteristic of late-2000s tech keynotes, filled with ambitious declarations about fundamentally rewriting how people communicate on the internet. The rapport between Lars Rasmussen, Jens Rasmussen, and Stephanie Hannon is collegial and unrehearsed, balancing polished live demonstrations with spontaneous, charming tech-demo moments—including brief venue Wi-Fi hiccups and enthusiastic live audience applause. Watching the demonstration feels like stepping into a pivotal historical snapshot of the early HTML5 era, underscored by genuine developer excitement for open web standards, real-time interactivity, and collaborative software engineering.
## Bulletin
- [00:01](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1s) Google introduced Google Wave at Google I/O 2009, combining email, instant messaging, wiki collaboration, and media sharing into a unified, hosted communication object.
- [37:48](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=2268s) The entire web client was built with Google Web Toolkit (GWT), allowing a single Java codebase to target modern desktop browsers, Android, and iPhone with only a 5% marginal engineering effort for mobile adaptation.
- [10:42](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=642s) Wave fundamentally alters traditional messaging latency by streaming keystrokes live character-by-character across concurrent users and federated server domains.
- [01:10:13](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=4213s) Google released early federation specifications and four whitepapers, committing to an open federation protocol and open-sourcing the majority of the production codebase.
## Key takeaways
- [05:04](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=304s) Google Wave rethinks 40-year-old email architecture by replacing discrete message passing with a centralized, hosted tree of message content.
- [10:42](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=642s) Wave enables true real-time multi-user typing, transmitting characters as they are pressed rather than waiting for discrete submissions.
- [12:07](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=727s) The Playback feature provides complete historical accountability, allowing users to replay every keystroke, edit, and branching branch in a wave's history.
- [27:47](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1667s) Universal editing permissions allow any participant to edit another's message by default, with visual diffs highlighting modifications for returning readers.
- [32:05](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1925s) Work waves and product waves allow users to branch conversational drafts and merge clean states back into primary documents, similar to source control.
- [37:48](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=2268s) Google Web Toolkit (GWT) compiled a 1.4-megabyte Java codebase down to 200 kilobytes of optimized HTML, JavaScript, and CSS across desktop and mobile browsers.
- [18:16](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1096s) Waves can be embedded directly into external websites and blogs via the Embed API, maintaining bidirectional real-time synchronization with personal inboxes.
- [43:17](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=2597s) Third-party extensions operate as first-class citizens, implemented as either server-side robots or client-side OpenSocial gadgets.
- [43:17](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=2597s) The Spelly robot provides context-aware statistical spell checking by evaluating typing against a web-scale statistical language model.
- [59:59](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=3599s) Robots such as Buggy and Tweety bridge Wave to external systems like Google Code and Twitter, updating databases and public feeds directly from wave messages.
- [01:04:16](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=3856s) Google Wave is architected as an open federated protocol (similar to email), enabling independent, competing servers to interoperate seamlessly.
- [01:06:10](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=3970s) Private inline replies remain cryptographically scoped across server boundaries, ensuring uninvited domains never receive unauthorized sub-thread data.
- [01:11:53](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=4313s) Automated robots like Rosy provide instantaneous inline translation across approximately 40 languages as users type.
- [01:19:12](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=4752s) Drawing from the grass-roots developer adoption of Google Maps, Wave was designed developer-first with open APIs and federation whitepapers at preview launch.
## Detailed walkthrough
### [00:01](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1s) Vic Gundotra Introduces the Day Two Surprise
Vic Gundotra, Vice President of Engineering, opens the second day of Google I/O 2009 by welcoming the crowd and checking in on how much they enjoyed the first day’s sessions—and the Android phones handed out the day before, which elicits energetic cheers from the audience. Delivering on a promise made on day one, Gundotra announces that Google is about to unveil a brand-new personal communication and collaboration tool in a very early form. He explains that Google chose this specific developer gathering for two primary reasons. First, the product will be completely open-sourced because Google not only wants to give back to the internet ecosystem, but genuinely needs developers to build upon and complete it. Second, it serves as a tour de force for modern web technologies. Gundotra insists that over the upcoming ninety-minute demonstration, attendees will repeatedly lose track of the fact that the entire application is executing strictly inside a web browser, urging the audience to remind themselves: “I am looking at an HTML 5 app. I am looking at what's possible in the browser.”
He builds anticipation by connecting the project to proven engineering pedigree, noting that its magical nature should come as no surprise given its leadership. The product is the brainchild of brothers Lars and Jens Rasmussen—the creators behind Google Maps—alongside their dedicated engineering team. Gundotra emphasizes that the audience is receiving an exclusive first look and that every attendee in the room will receive sandbox accounts and credentials via email, likely by tomorrow, so they can test the software and offer feedback. With that setup, Gundotra welcomes Lars Rasmussen and Product Manager Stephanie Hannon to the stage.
- The product being debuted is an open-source personal communication and collaboration platform.
- Engineering leadership is headed by Lars and Jens Rasmussen, the team behind Google Maps.
- Every Google I/O attendee in the room is promised sandbox account credentials via email within roughly twenty-four hours.
---
[02:47](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=167s) The Three Ps: Product, Platform, and Protocol
Lars Rasmussen takes the stage, waking up his laptop and joking about the audience making it to an early morning keynote after partying late the night before. He reveals the name of the project: Google Wave, developed over the past several years by their team in Sydney, Australia. Acknowledging that it is unusual for Google to unveil a product so long before its public launch later in the year, Lars explains that launching an early developer preview sandbox is intentional. Google wants developers working with the new APIs immediately so that when Google Wave officially launches to the public, an ecosystem of third-party extensions and integrated web experiences will already be live. He then introduces Stephanie Hannon, praising her as “quite possibly the best PM in the world.”
Hannon outlines the structure of the presentation around what the team affectionately nicknames "the three Ps": Product, Platform, and Protocol. The keynote will first demonstrate the core user product, then dive into the developer platform APIs used to embed waves into websites or build custom extensions, and finally explain the underlying open federation protocol. Stressing the philosophy driving the project, Stephanie Hannon declares: “We are very passionate about this being an open system of communication.” The overarching ambition is for independent organizations to stand up their own Wave servers that interoperate seamlessly, giving users genuine choice among providers in the exact same manner email does.
- Project development was based out of Google's engineering office in Sydney, Australia, spanning over two years of work.
- The project architecture is structured around the "Three Ps": Product (the end-user collaboration app), Platform (APIs and extensions), and Protocol (an open, federated standard).
- Google plans to release the developer sandbox first, targeting a wider consumer launch later in 2009.
---
[05:04](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=304s) Rethinking Email: Hosted Shared Objects vs. Snail Mail Metaphors
Lars Rasmussen contextualizes the origins of Google Wave by dissecting the dominant mode of online communication: email. Despite being the most ubiquitous communication channel on the internet, email was designed more than forty years ago—well before the web, SMS, instant messaging, blogs, wikis, message boards, social media feeds, and concurrent collaborative text editors existed. Because hardware, bandwidth, and user paradigms have shifted so radically since the late 1960s, the Sydney team began with a fundamental design thought experiment: “what might email look like if it was invented today?”
Lars contrasts the core architectural metaphors of email and Wave. Traditional email mimics postal snail mail: a user authors a standalone message and transmits discrete copies over the wire to recipients, leaving the client software (such as Gmail) to stitch together related replies into threads after the fact. Wave discards the concept of sending discrete messages back and forth entirely. Instead, a wave is defined as a shared, hosted conversation object—a lightweight tree structure of messages and participants hosted on a central server. When participants want to interact, they do not dispatch an electronic envelope; they simply open the hosted object, make their edits or contributions, and leave. Subsequent users open the exact same live object, view the latest state, and append their thoughts. Lars notes that while this concept shares roots with bulletin boards, an ultra-responsive, real-time client-server implementation transforms it into a flexible medium capable of subsuming email, chat, and collaborative document editing in one cohesive space.
```mermaid
flowchart TD
accTitle: Comparison of Email and Wave Architecture Models
accDescr: Diagram contrasting traditional email message-copying with Google Wave's centralized hosted conversation model.
subgraph EmailModel["Traditional Email Model (Snail Mail Metaphor)"]
A["Sender writes message"] --> B["Client transmits discrete copies"]
B --> C["Recipient 1 Mailbox"]
B --> D["Recipient 2 Mailbox"]
C --> E["Local client collates threads"]
D --> E
end
subgraph WaveModel["Google Wave Model (Hosted Object Metaphor)"]
W["Hosted Conversation Object\n(Central Server Tree Structure)"]
U1["User A (Browser Client)"] <-->|"Reads / Appends In-Place"| W
U2["User B (Browser Client)"] <-->|"Reads / Appends In-Place"| W
U3["User C (Browser Client)"] <-->|"Reads / Appends In-Place"| W
end
```
- Email was created over forty years ago, mimicking physical envelopes sent between distinct inboxes.
- A wave conversation is architected as a lightweight message tree living on a server as a single shared object rather than replicated messages.
- The hosted model eliminates fragmented threads by allowing all participants to read from and modify the same centralized conversation record.
---
[07:35](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=455s) Live Demo: Asynchronous Threading and Real-Time Instant Messaging
Stephanie Hannon introduces the live demo environment, pointing out that the client is an HTML5 web app written using the Google Web Toolkit (GWT). To demonstrate real-time cross-browser interoperability, Lars operates on the left screen using Google Chrome, while Stephanie operates on the right screen using Apple Safari, with Mozilla Firefox slated to appear later in the presentation. Lars initiates a wave to plan a boat trip, typing the subject into the top line. When he types his opening text, a contextual spell-checker instantly corrects his words on the fly, triggering applause from the crowd. Lars jokes that because nobody wants to watch him type slowly for an hour, he is utilizing pre-baked canned text macros that the team will try hard to remove before the public launch. Lars finalizes his message, adds Stephanie to the wave, and steps away while she is shown as offline.
Stephanie opens Wave, where Lars's unread message appears bold in her search inbox panel. Simulating an asynchronous, email-like workflow, she opens the wave and hits "Reply" to agree to go shopping for fins. She then demonstrates how a hosted object handles inline replies without the quoting mess typical of email. Rather than hitting reply, copying the preceding text block, and manually inserting text among nested angle brackets, she clicks directly beneath the middle of Lars’s message where he asked about bus schedules. The server instantly splits Lars’s message block apart, creating an inline response container where she writes that Lars never wakes up early so they should take the late bus.
When Lars logs back in, the wave appears bolded with unread highlights on Stephanie's new contributions. Lars navigates down through the tree using keyboard shortcuts and adds an inline acknowledgement. He then shows what occurs when both users have the wave open simultaneously: the asynchronous document immediately functions as a synchronous instant messaging channel. Because keystrokes and updates reflect off the server in real time into the active browser session, typing within the shared object updates character-by-character on Stephanie’s screen, prompting enthusiastic cheering and applause from the audience.
- Client framework: pure HTML5 application compiled via Google Web Toolkit (GWT), tested live across Google Chrome and Apple Safari.
- Inline threading: users can split any specific paragraph of a message to nest sub-threads directly in context rather than quoting entire emails.
- Blended communication modes: the same conversation object transitions seamlessly between asynchronous store-and-forward messaging and live, low-latency character streaming depending on whether participants are online concurrently.
[10:42](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=642s) Real-Time Character Transmission and Conversation Speed
Lars Rasmussen and Stephanie Hannon resume their live chat session, discussing meeting up at a new venue on George Street at 7:00 and planning to invite Jens Rasmussen. Lars points out that the Google Wave client does not wait for a user to click "Done" before displaying text to the other party; instead, it transmits the message live, character by character.
Lars explains that traditional instant messaging tools cause users to waste half their time watching typing indicators: “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.” Because Wave transmits keystrokes continuously, participants can read and begin drafting their answers while the other person is still writing, allowing users to spend 100% of their time actively communicating. Acknowledging that people might not always want every typo exposed, Lars jokes about his own spelling and gestures to a checkbox meant to buffer text until clicking "Done," admitting with a laugh, “This is one of the features we haven't implemented quite yet.”
[12:07](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=727s) Adding Participants, Playback Mode, and Private Replies
Lars introduces his brother Jens Rasmussen to the stage to demonstrate how new participants join an active discussion. In standard email threads, branching conversations make catching up painful because adding someone to the latest message leaves out prior branches, and subsequent replies to earlier emails leave the newcomer behind in a game of "cat and mouse." In Wave, Jens is added directly to the wave itself. Jens opens the thread in Firefox, where all unread content is highlighted. Because late arrivals miss the temporal flow of an evolving document, Jens triggers the "Playback" feature, which steps chronologically through each edit, inline reply, and branching message.
```mermaid
flowchart TD
accTitle: Wave Participant and Thread Access Model
accDescr: Diagram showing how a public wave branches into a restricted private sub-tree.
subgraph WaveRoot["Shared Wave"]
M1["Original Message: Dinner on George St"]
M2["Branch Reply: Invite Jens"]
M3["Inline Additions & Discussion"]
end
subgraph PrivateBranch["Restricted Sub-Tree"]
PR["Private Reply: Buy Steph a nice present"]
end
While typing a response ("Me too."), Jens's browser crashes, prompting Lars to joke, “Did I mention that it's a developer preview? So we made sure to inject a few bugs so that you wouldn't have too high expecta--I'm just kidding.” Jens quickly reloads, teasing the audience about the speed of Google Web Toolkit (GWT), and finishes his note: "Don't forget your keys."
Lars then demonstrates a "Private Reply" by drafting a note at the bottom: "Let's buy Steph a reeeally nice present" (which Stephanie quips she authored). By scoping that message sub-tree to only Jens, Lars shows that the private reply appears instantly on Jens's screen while remaining completely invisible on Stephanie's interface. Lars explains: “Essentially you can take any sub-tree of the wave and restrict access to a subset of the participants.”
[15:20](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=920s) Media Attachments and Desktop Drag-and-Drop
Lars demonstrates how Wave handles attachments using six photos from a recent boat trip by dragging them straight from his desktop into the active wave window. Thumbnail previews render immediately on Stephanie's display before the full-resolution source files finish uploading from Lars's machine. Stephanie repeats the process by dragging images directly from Apple iPhoto into her browser, drawing sustained applause from the crowd. Lars playfully encourages the audience, noting, “Don't be shy letting us know. We can--we can handle pretty much any amount of applause.”
Stephanie explains that direct desktop-to-browser drag-and-drop was not yet supported by standard HTML5, requiring the Google Gears plugin as a temporary bridge while Google worked to submit the capability to the web standards body:
- Google Gears is required only for this specific desktop drag-and-drop operation in Wave.
- An "Image" menu at the base of the Wave panel lets users execute bulk actions across all photos in the wave (such as batch uploads or downloads).
- Shared waves serve as collaborative group albums without requiring external photo-sharing platforms.
Lars reviews the newly populated album—featuring "Captain Athena" and humorous photos of their team's "hard life down under" in Sydney. Because they also did some shopping that they do not want to broadcast to their whole office, Lars uses a built-in feature to extract just the boating photos into an independent wave titled "Boating in January. Enjoy all, here and yonder." He stresses the philosophy behind this capability: “Namely that we care just as much about the product of the wave as we do the wave itself.”
[18:16](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1096s) Embedding Wave and the "Bloggy" Bot Demo
Stephanie suggests introducing developer extension capabilities, prompting Lars to unveil the embedding APIs. Lars compares the initiative to the original Google Maps API, thanking the developer community for their past contributions and hoping for similar adoption. To demonstrate embedding, the team presents a lightweight blog application hosted on Google App Engine.
To bridge the private wave workspace and the public blog, Lars invites an automated robot participant named "Bloggy" into the wave. When Bloggy joins, a yellow warning banner alerts participants that the wave is being published externally to an App Engine-hosted page. Lars invites product manager Gregory Delasander to demonstrate the live blog front end.
The demo hits an immediate snag when Greg's screen loses connectivity. While Greg checks his network and Stephanie asks if the VPN dropped, Lars improvises: “Everyone look at me. Don't look at his screen... The Wave dance.” Lars jokes about maintaining composure: “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,” deadpanning, “We wish we were one of them.”
Once Greg sorts out the proxy and re-establishes connectivity, he shows that the blog does not simply present static text or isolated photos—it embeds the entire interactive Wave client and user interface. Greg posts a live comment directly from the embedded blog page: "Hey, that looks fun. Why wasn't I invited?" The comment renders instantaneously inside Lars's primary desktop Wave client, demonstrating that external readers can engage in the full conversation without ever leaving the host blog, and internal participants can reply without visiting the external website.
[21:19](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1279s) Two-Way Blog Embedding and Unified Conversations
Greg D’Alesandro continues replying to Lars Rasmussen’s embedded blog wave directly from the webpage. Because Greg is typing at the same time Lars is viewing the post, the updates stream in character by character in real time. Greg explains that even if a participant leaves the original blog, responding to an embedded wave automatically pulls that entire wave into their personal Google Wave client. After refreshing his client inbox, Greg sees the conversation appear immediately and resumes chatting from within Wave itself, typing, “But, Lars, I live next door.” The response surfaces instantly back on the public blog, allowing anyone visiting the page or following along inside Wave to participate seamlessly in the same thread.
Lars highlights how the embedding APIs allow developers to drop dynamic waves into standard web pages, whether for personal blogs, discussion groups, community forums, or rich-media sites. Developers gain a live, highly responsive interaction layer with minimal engineering effort, while end users get a familiar interface and avoid losing track of distributed comment sections. Lars argues that Wave centralizes fragmented web discussions: “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.” He jokes that having all these threads in one place “will make flame wars so much more effective,” drawing laughter from the crowd while Stephanie Hannon jokingly groans in protest.
[23:13](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1393s) The Embed API inside Social Networks: The Orkut Integration
Stephanie Hannon takes the stage to showcase how the Embed API goes far beyond simple blog commenting by presenting a prototype built inside Google’s social networking platform, Orkut. Developed during a Sydney visit with engineering colleagues from Brazil and India—specifically Sid, Torsten, and Rodrigo—the Orkut integration illustrates how deeply Wave can be woven into existing social platforms to manage community interactions.
Stephanie demonstrates three core architectural capabilities of the Embed API within the Orkut interface:
- **Creating waves in-place:** Users can initiate brand-new waves directly inside an Orkut panel (demonstrated with her post: “Brazil trip? Wonder when Lars will let me go.”).
- **Custom contact providers:** Sites are not locked into Google Wave contacts; Orkut developers hooked the widget directly into Orkut’s native friends list, allowing users to add site-specific contacts directly to the wave.
- **Embedded search and custom clients:** Stephanie pulls up an embedded Wave search panel directly inside Orkut, retrieving and browsing all relevant waves without leaving the social network.
Because the wave is an independent shared object, opening the full Wave client immediately reflects the exact wave created inside Orkut. Stephanie points out the broader architectural implication: “What's important is that our embed API is powerful enough for you to build your own Wave client.” Lars confirms that all attendees will receive developer sandbox accounts running the exact build used on stage, urging the audience to use these sample integrations as inspiration to build richer applications.
```mermaid
flowchart LR
accTitle: Wave Embed API Architecture
accDescr: Diagram illustrating how waves synchronize across embedded pages, social networks, and full Wave clients.
subgraph S1["Embedded Endpoints"]
B["Blog Comment Wave"]
O["Orkut Wave Panel & Custom Contacts"]
end
subgraph S2["Wave Data Layer"]
W["Single Shared Wave"]
end
subgraph S3["Standalone Clients"]
C["Google Wave Web Client"]
M["Mobile Client"]
end
B <-->|"Embed API"| W
O <-->|"Embed API"| W
W <-->|"Live Sync"| C
W <-->|"Sync"| M
```
[25:25](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1525s) Mobile Devices and Network Realities
Lars shifts the demo toward mobile productivity, pulling out an Android device and an iPhone to show how Google Wave keeps handheld devices in live communication with desktop workstations. He opens the vacation photo wave on Android, displaying the inbox view and thumbnail images. However, when attempting to submit a live reply from the phone stating “I am on the boat,” the message fails to transmit due to an unresponsive venue Wi-Fi network.
Lars quips that the 4,000 conference attendees are hogging the bandwidth: “Because I can't get on the wireless. So if it doesn't work, it's your fault.” Rather than masking the issue, the team leans into the humor of live stage demos, with Lars remarking that “nothing is going to show up over there because we haven't yet figured out squeezing this through without a connection.” Stephanie jokingly reminds him that as long as the technical hiccup is attributed to his phone’s connectivity rather than the underlying software, she is satisfied, prompting Lars to pivot cleanly to Wave’s collaborative editing tools.
[26:44](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1604s) Concurrent Document Editing and Universal Message Mutation
Returning to his desktop, Lars reminds the audience that every view—whether on a personal blog, a phone, or in a client inbox—is anchored to a single underlying data model. Noticing that some of the photo captions on his blog post are awkward, Lars clicks “Edit” directly within the wave and fixes them to read “Kayaks” and “Beer Man.” Stephanie confirms to the audience that the moment Lars makes the adjustment on his desktop, the captions update live on the embedded blog without requiring a page reload.
Crucially, Wave does not limit editing rights to the original author. Lars announces that Google Wave allows any participant on a wave to edit any other participant’s messages by default, transforming ordinary conversation threads into fully collaborative document-authoring workspaces.
[27:47](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1667s) Bridging Conversation and Documents: Accountability, Diffs, and Playback
Stephanie frames collaborative editing around a persistent dilemma in product management: choosing between sending meeting notes over email to foster discussion or publishing them in a wiki or document where colleagues can edit content. She argues that Wave eliminates this friction: “With Wave you don't have to make that choice. You can do both discussion and content collaboration in one tool.” To prove this, she drafts a set of meeting notes and adds Lars, Jens Rasmussen, and Greg D’Alesandro to the wave.
Lars opens Stephanie’s note, clicks “Edit,” alters her text to describe an outcome as “glorious,” and appends an action item: “AI. Make more better AIs, already.” When the screen switches back to Stephanie, the wave has surfaced back to the top of her inbox with visual markup (diffs) clearly highlighting Lars’s changes. Stephanie explains that these diff markups appear for anyone who had previously seen the original version of the message.
Jens demonstrates the experience for someone who arrived late:
- Because Jens had never viewed Stephanie’s original text, he opens the wave and sees only the current, consolidated document state.
- The interface explicitly indicates that both Stephanie and Lars contributed to the message.
- If Jens wants to trace how the document reached its present state, he activates the Playback slider, stepping through Stephanie’s initial draft, the addition of collaborators, and Lars’s subsequent edits.
Jens underscores the philosophy behind this permissive model: “So now that we have accountability in place, we're going to allow everybody on a wave to edit everything by default.” Accountability ensures that if unauthorized changes occur, the original author is notified immediately and can trace the edit history. Jens then drops an inline reply directly underneath Lars’s newly added action item, typing, “No, enough AIs already.”
Lars closes the walkthrough by emphasizing that Wave does not distinguish between a structured document and an informal chat: “Notice that we never said, 'Let's start a document, here.' These are all just waves.” Whether an entry is treated as a long-form design specification featuring rich text, bold headlines, bullet points, and illustrations, or as short, inline conversational comments nested throughout the text, the underlying engine handles all contributions as a unified, iteratively editable tree.
[32:05](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1925s) Wave Playback and Document Production
Lars Rasmussen demonstrates that the best way to understand how a complex document evolved is to use the Playback feature. Scrubbing through the history reveals the team’s iterative back-and-forth: Steven, the server engineer, began with a terse initial draft; Lars stepped in as manager asking for more work; Steven grudgingly added another paragraph saying “Yeah, whatever”; and product manager Stephanie Hannon followed with inline edits and threaded comments. Rasmussen uses the timeline slider to drag the document to any point in its recorded history. He outlines a suite of upcoming power tools planned for Playback, including filtering the playback to display only a specific person's contributions, isolating the evolution of a single message or paragraph, naming specific versions for easy retrieval, and selecting any historical change to revert it at the tip of the history. Rasmussen emphasizes the vision for this capability: “Playback is going to be a really powerful tool for investigating and manipulating the entire history of the wave.”
```mermaid
flowchart LR
accTitle: Wave Branching and Merging Workflow
accDescr: Diagram showing work waves branching off and merging changes back into a shared pristine product wave.
subgraph CoreDocument ["Published Artifact"]
P["Product Wave<br>(Pristine Document)"]
end
W1 -->|"Extract pristine message"| P
W1 -->|"Merge incremental changes"| P
W2 -->|"Pull updates & merge local edits"| P
```
To solve the readability problem when an active design document becomes cluttered with inline discussions, the interface provides a widget to toggle discussions on and off. Furthermore, just as images were earlier extracted from waves, users can extract the current clean version of any message in a tree into an entirely fresh wave. This creates an unencumbered product wave containing only the pristine output, ready to be submitted to a server, shared with broader teams, posted to a mailing list or internal blog, or revised further. Drawing a direct parallel to source control systems, Rasmussen explains that teams will be able to maintain multiple working waves that link back to the single product wave:
> “We’ll let you have a whole string of work waves, all pointing to the same product wave. You can have different teams working on different parts of a wave, and then when one team merges that changes into the product wave, the other teams can pull that down, merge it with the local changes, and so on.”
While demonstrated with rich text, Rasmussen notes that the underlying Wave content model is built to be extensible—both internally by Google and externally by developers—paving the way for future spreadsheet calculations and presentation-building tools within the same framework.
Before opening the next demonstration, Stephanie asks Lars to stall for thirty seconds to give the engineering team a moment to set up. Lars jokes with the audience, offering to do an interpretive dance and checking in on the crowd: “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? Are you having a good time? I know it’s a long demo.” He gestures to the colleagues in blue shirts working feverishly offstage before diving into what he describes as both the most difficult and the most rewarding engineering feat in Wave: allowing multiple people to edit the exact same message simultaneously while transmitting keystrokes live across the wire.
Opening a wave filled with photographs, Stephanie begins editing captions from the top-left while Lars types from the lower-right. Colored cursor labels display each user's exact position on screen in real time as they trade rapid caption updates:
- Stephanie: "Thumbs up."
- Lars: "Spelling Google."
- Stephanie: "Lars in the lead."
- Lars: "Smiley David."
- Stephanie: "Wave crew hiking."
- Lars: "Kapow."
Additional team members—Casey, Ophir, and Dan—jump into the document simultaneously, bringing four people into the exact same paragraph adding italic formatting and font colors right alongside each other. Lars reflects on the experience, joking about “hours and hours of fun just chasing each other’s carets around on the screen.” Beyond amusement, live concurrent editing fundamentally alters collaboration patterns. During internal meetings, team members often skip attending in person altogether, choosing instead to open the active wave, monitor the live note-taking, and inject their questions directly into the text. Lars highlights international text rendering, displaying Ophir typing live right-to-left in Hebrew, as well as complex international input method editors (IME) handling Chinese characters in the upper-left of the document.
[37:48](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=2268s) Under the Hood: Building Wave on Google Web Toolkit (GWT)
Pausing the live feature walk-through to give the audience a brief physical stretch break, Rasmussen takes a moment to acknowledge the Google Web Toolkit (GWT) team. Google Wave was built 100% on GWT from the very first lines of prototype code written in early 2007. GWT enables developers to write client-side applications in Java, which the toolchain then compiles into optimized HTML, JavaScript, and CSS that execute across all modern desktop and mobile web browsers.
Rasmussen admits that without GWT, the Wave team would not have attempted—or even conceived—a browser application of this sophistication. Reflecting on his past work, he contrasts the experience with his earlier career: “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.”
This cross-compilation pipeline pays major dividends across devices:
- The exact same codebase powers both the desktop browser experience and the mobile browser interfaces demonstrated earlier on Android and iPhone, requiring only layout adjustments.
- Rasmussen estimates that supporting both desktop and mobile web environments requires merely 5% additional engineering effort.
- Stephanie and Lars reference a compiler optimization graph shown during the conference the prior day, where GWT compressed an initial 1.4 megabyte codebase down to just 200 kilobytes.
[40:13](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=2413s) Wave Organization, Drag-and-Drop Wave Links, and Live Search
Transitioning back to everyday use cases, Stephanie Hannon discusses managing high volumes of waves. The application provides standard organizational utilities such as folders and saved searches, alongside shared tags that are visible to every participant on a wave—giving participants as much incentive to assign meaningful tags as clear subject lines. Stephanie jokes that because Lars is far too lazy to organize his own waves, the team has to step in to organize them for him.
The most potent organizational construct, however, is using waves themselves to index other waves. Stephanie brings up the wave the team created to plan the Google I/O keynote demo, which functions like a structured wiki containing formatted sections, discussions, and embedded wave links. Clicking an embedded wave link opens that wave directly while preserving standard browser back-button navigation. Adding links is entirely fluid: Stephanie grabs a wave directly from the search results panel and drops it straight into the body of the planning document, repeating the action to the audience's applause.
Stephanie then initiates a test of real-time search updating by querying for the phrase "Google Wave" in her client panel. As Lars prepares a new wave in parallel containing the text "Wow. I am finally demo-ing Google Wave", he intentionally stops short of typing the final letter "e" to demonstrate how live index matching triggers across the network the exact moment the search criteria are met.
[42:22](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=2542s) Real-Time Latency and the "Wave Dance"
To prove the speed of the underlying architecture, Lars Rasmussen sets up a real-time latency test for the audience. He types an "E" into his client and asks the crowd to count how many seconds it takes to appear across the network inside Stephanie Hannon's browser. The character renders almost instantaneously to enthusiastic applause. To demonstrate that this was not a fluke, Lars asks Stephanie to open the wave on her screen and begins hitting backspace and the letter E in rapid succession—a rapid sequence of edits he jokingly dubs "the Wave dance."
While the team takes pride in the engineering achievement, Lars candidly notes an unexpected usability trade-off that emerged once they began living in the tool daily. “I should just say after we started using it, we found this is almost too fast,” he explains, observing that extreme immediacy can pull a user's attention prematurely toward incomplete thoughts. The team is actively calibrating the balance between instant synchronization and minimizing intrusive interruptions during active drafting.
[43:17](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=2597s) Extending Wave: The First-Class Citizen Philosophy and "Spelly"
The presentation pivots to the core reason many developers attended: extension APIs. Lars outlines the design principle guiding the platform's architecture: the Google Wave engineering team deliberately dogfoods its own public extension hooks to construct core platform features. Rather than reserving privileged internal hooks for native capabilities, they treat third-party extensions as first-class citizens living inside Wave, directly analogous to how Firefox allows developers to extend the browser itself—except here, developers extend an interactive web application.
```mermaid
flowchart LR
accTitle: Wave Robot Architecture Diagram
accDescr: Shows how a server-side robot monitors live wave text and applies collaborative edits back to the session.
subgraph WaveSession["Wave Client Session"]
UserTyping["User Input / Text"]
LiveView["Collaborative View"]
end
subgraph ServerBackend["Robot Backend Infrastructure"]
RobotAPI["Robot API Listener"]
Model["Language Model / Web Corpus"]
CollabEdit["Collaborative Engine"]
end
UserTyping -->|"streams keystrokes"| RobotAPI
RobotAPI -->|"evaluates n-grams"| Model
Model -->|"identifies correction"| CollabEdit
CollabEdit -->|"applies real-time edits"| LiveView
```
To demonstrate the power of this philosophy, Lars unveils the context-aware spell-checker nicknamed "Spelly." Traditional spell-checkers merely validate tokens against isolated word lists, failing whenever a typo accidentally spells an existing dictionary entry. Wave's engine instead evaluates the broader context of a sentence against an enormous statistical language model derived from the entire indexed web:
- **The "Bean Soup" Test:** Lars inputs *"Can I have some been soup?"* The engine flags "been" with a red underline and recognizes the intended word is "bean."
- **Automatic High-Confidence Correction:** Typing *"It has bean so long."* causes the engine to instantly rewrite "bean" to "been" without manual user intervention because its statistical confidence threshold is met.
- **Homophone and Typo Resolution:** Lars demonstrates sentences like *"Icland is an icland."* (auto-correcting capitalization and spelling) and *"You are to kind."* (correcting "to" to "too").
[45:37](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=2737s) Server-Side Robots: Linky and Searchy
Lars connects these smart editing behaviors back to the platform's extension primitives by introducing server-side robots. Robots act as fully fledged programmatic participants inside a wave, possessing the exact same privileges as human collaborators: they can inspect live state mutations, add or delete replies, collaboratively edit inline text, manage the participant list, and spawn brand new waves. Spelly operates simply as a server-side robot listening to keystrokes, periodically querying the language model, and submitting collaborative edits directly into the shared document. If confidence is low, it inserts a red underline annotation visible simultaneously to all active editors, allowing any collaborator to review and accept the fix.
A companion robot named "Linky" provides live URL detection, instantly styling text into clickable anchors as the user types domain names like `google.com` (dynamically parsing valid top-level domains like `.com` or `.au` while dropping formatting on invalid strings like `.a`). To streamline gathering web materials without manual text copying, a teammate from the Google Search team built an extension called "Searchy." Lars queries "Australia" to seamlessly insert search links directly into the conversation, and then queries "Bora Bora" to embed high-resolution web imagery into the thread. A subsequent attempt to demonstrate automatic video embed conversion via Linky encounters a momentary software glitch, prompting Lars to joke that he will "dance a little bit while the system spectacularly fails" before moving forward.
[48:10](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=2890s) Collaborative OpenSocial Gadgets: The Yes-No-Maybe RSVP
Stephanie Hannon announces that the developer preview exposes external versions of these APIs on code.google.com, mirroring almost all internal capabilities with only minor exceptions still undergoing security hardening. Turning to client-side UI extensions, Stephanie explains that any OpenSocial gadget can embed directly inside a wave, augmented by an additional Wave API that renders standard gadgets live, multi-user, and collaborative.
Reflecting on the team's early days dogfooding the product, Stephanie shares how ingrained communication habits initially carried over:
> “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.”
She illustrates this learning curve by replaying an old wave where an engineer organized a team movie trip to see *Transformers*. Initially, colleagues replied with conversational email-like fragments ("I'm interested," "What place are you going to?"), while Stephanie unsuccessfully campaigned for *Confessions of a Shopaholic* ("She's still trying," Lars quips). The resulting thread became unreadable until the team cleaned up the wave by collaboratively editing the top message into an RSVP list. To streamline this workflow further, an engineer turned the roster into a live "yes-no-maybe" gadget:
- A gadget developer manages just two operations: capturing a user event (e.g., clicking a button) to mutate state within the wave's underlying XML, and reacting when the server broadcasts that state update to update the UI on peer clients.
- Stephanie toggles her status from "No" to "Maybe," immediately shifting her avatar on Lars's monitor.
- Lars clicks "Yes," and his entry instantly shifts across both displays simultaneously.
[51:23](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=3083s) Collaborative Gaming and Interactive Maps
Stephanie jokes that while business productivity is valuable, the secret real motivation behind building collaborative gadgets was to make addictive multiplayer games. She and Lars demonstrate a real-time Sudoku gadget, conceived originally as a cooperative puzzle-solving app that quickly degenerated into a cutthroat competition where correct placements award points and errors penalize players (causing Lars's score to drop into negative territory while trying to play under the pressure of 4,000 onlookers). Stephanie then opens an archived gadget containing an 1851 23-move chess match to demonstrate how Wave's Playback engine steps backward and forward through arbitrary gadget state transitions just as cleanly as textual messages.
Returning to their roots as alumni of the Google Maps team, the presenters showcase a collaborative Google Maps gadget. Planning an imaginary holiday, Stephanie sends a Bora Bora vacation wave. Lars highlights the text "Bora Bora," clicks an extension button to insert a dynamic map gadget, and toggles into satellite photography. As Lars rapidly zooms into the island view, Stephanie lifts both hands off her keyboard to demonstrate that Lars's viewport shifts and zoom actions synchronize instantly to her side. Lars drops a shark marker pinpointing where lemon sharks congregate, leaving the map marked for Stephanie to take over and draw boundaries with the polygon tool.
[53:36](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=3216s) Client-Side Gadget State Sync and Linky's Video Embedding
Reviewing how gadget state updates synchronize across instances, Lars Rasmussen explains the underlying mechanism for client-side extensions: developers simply store updates to state in local XML, which the platform transmits over the wire so other gadget instances update automatically upon receiving change notifications. Turning back to an earlier demo hiccup, Lars points out that the team in blue scrambled and restored Linky.
Re-examining the YouTube URL previously dropped into the extension wave, Linky does far more than just spot a plain hyperlink—it identifies the URL as a video and renders a friendly light bulb icon on screen. Clicking this icon reveals a pop-up menu of contextual suggestions, including embedding the YouTube video directly into the wave. Lars clicks embed, initiates playback right inside the wave canvas with a playful sound effect, and draws applause from the audience.
[54:48](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=3288s) Server-Side Extensions: Polly the Pollster and Collaborative Native Forms
Transitioning from client-side gadgets to server-side extensions, Lars introduces robots. To showcase their potential, the team presents three distinct architectural examples, starting with a native collaborative application built entirely inside Google Wave using the extension API. Opening his inbox drop-down, Lars bypasses the standard "new wave" action to select "new poll," which provisions a wave pre-populated with an automated robot named Polly the Pollster. Lars adds Stephanie Hannon to the wave, and Polly injects a native form layout directly into the canvas.
Lars emphasizes that this form is not a gadget, but rather a first-class native Wave capability that supports real-time concurrent editing. As Lars begins typing the poll title, Polly inspects the keystrokes character-by-character on the server side and dynamically syncs the wave's title. The true power lies in collaborative form completion: while Lars drafts the central question (“Which movie is the best ever?”), Stephanie types candidate options in the input box below. After playfully entering "Star Wave" instead of *Star Wars* alongside *Confessions of a Shopaholic* and *Star Trek*, Stephanie populates a recipient list with six participants. Lars clicks "distribute poll," triggering Polly to append a live results panel into the administrative wave while spinning off child waves with the question to every recipient. When Stephanie votes for *Star Trek* in her instance, Polly tallies the vote and updates the admin wave's results section in real time.
- Client-side gadgets sync by saving state into local XML, which Wave handles over the wire.
- Native forms run directly within Wave documents rather than inside iframe/gadget containers.
- Server-side robots like Polly can observe real-time keystroke edits and dispatch child waves autonomously.
[57:21](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=3441s) Integrating Communication Systems: Twave and Twitter Integration
The second class of extensions bridges Google Wave with external communication networks, demonstrated here through Twitter. Stephanie shows how users install extensions directly from waves containing modular "puzzle pieces," clicking an install button to add a dedicated "new twave" action into the application menu. Lars quips, “A wave, of course--twave, of course, is a wave of tweets.” Developers can configure extensions to hook into Wave through custom keyboard shortcuts, toolbar buttons, or tailored menu items, paired with confirmation dialogs outlining permission boundaries.
```mermaid
flowchart TD
accTitle: Wave to Twitter Architecture
accDescr: Diagram showing how the Twave robot bridges between Google Wave and the external Twitter API.
subgraph WaveClient["Google Wave Client"]
U1["User writes inline reply in Twave"]
U2["Live stream of tweets / Search results"]
end
subgraph ExternalTwitter["Twitter Platform"]
TAPI["Twitter API / Public Timeline"]
TwUsers["External Accounts (Lance Armstrong, Seacrest)"]
end
U1 -->|"Sends reply message"| TRobot
TRobot -->|"Publishes tweet via OAuth/Credentials"| TAPI
TAPI -->|"Pulls tweets & avatar proxies"| TRobot
TRobot -->|"Streams updates to inbox"| U2
TwUsers -.->|"Interacts on Twitter"| TAPI
```
Stephanie logs into an account Lars set up for her under the handle "Twiffanie at Twitter"—a username she jokingly protests. Once authenticated, the wave populates with tweets and external avatars representing non-Wave accounts, including Lance Armstrong and Ryan Seacrest, demonstrating how Wave APIs can proxy identity models from legacy protocols. Locating a tweet from Lars stating the demo is going well, Stephanie submits an inline reply: "It ain't over yet." Switching over to a web browser showing Twitter, Lars refreshes the profile to reveal that the extension successfully picked up Stephanie's wave reply and published it to Twitter's public timeline.
- Wave extension triggers can bind to toolbar buttons, keyboard shortcuts, or drop-down action menus.
- External participants without Wave accounts can appear via avatar/contact proxying.
- Twave bridges Wave's concurrent discussion fabric directly into Twitter's timeline.
[59:59](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=3599s) Real-Time Twitter Search and Workflow Automation with Buggy
Demonstrating the search capabilities of the Tweety robot, Stephanie runs a live query across Twitter's public timeline for "Google Wave." Lars jokes about the bravery required to run an unfiltered public search during a live keynote. Stephanie recalls that testing the query the previous day returned only two matches—one being an applicant noting, “I should google Wave before my interview.” When the query executes live, a massive flood of keynote-related audience tweets instantly streams into the wave, drawing cheers and astonishment from the presenters. Lars explains that these robot queries can run continuously in the background, serving as live inbox alert feeds.
Moving to the third category of extensions—integrating Wave into enterprise developer workflows—Lars showcases Buggy, a robot interfacing directly with Google Code's issue tracker (adaptable to Bugzilla or any alternative bug database). Lars describes how the Wave engineering team handles internal software development:
> “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.”
During testing sessions, the team compiles collaborative notes containing bugs, UI critiques, and discussion items. Instead of filing tickets by hand, Lars simply highlights a bullet point and clicks a toolbar button to summon Buggy. The robot parses the highlighted text, opens an official issue in Google Code, and injects the issue metadata and ticket link directly back into the wave. When Stephanie opens issue #11 on the issue tracker site, Lars highlights additional items to spawn further tickets effortlessly. Lars then assigns owners directly inside the wave UI, reassigning tickets among Stephanie, himself, and team members; refreshing the issue tracker confirms that Buggy updated the assigned owners in the external database instantly. Lars observes that while issue trackers permit discussion, they do not excel at fluid conversation, making Wave's inline reply threads an ideal collaborative replacement for external bug tracker comment sections.
[01:04:16](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=3856s) Issue Tracker Robots and the Vision for Open Federation
Wrapping up the discussion on extensions, Stephanie Hannon demonstrates an external issue tracker update reflecting directly inside Google Wave. Lars Rasmussen highlights that while their current sample demonstrates pushing updates inward, developers could just as easily build bidirectional synchronization: if an engineer posts a comment on an external bug tracker, an issue tracker robot could detect it and update the corresponding wave in real time. Similarly, just as they earlier demonstrated Twitter searches pulled directly into a wave, an automated robot could initiate a dedicated wave for bug tracking, aggregating all tickets assigned to a specific developer. Reflecting on the impact of automated workflows, Lars remarks:
> “It's remarkable—thank you—how much more effective this sort of thing makes you.”
Transitioning to the underlying architecture, Lars turns to the core protocols and algorithms of Google Wave. Emphasizing that open standards were the primary reason behind the historical success of email, he explains that Google intentionally designed Wave as an open system rather than a walled garden. Anyone can set up an email server and exchange messages with anyone else across arbitrary domain boundaries, and Google Wave is built around the exact same philosophy through a model called federation. Under this architecture, independent organizations can deploy competing Wave systems and register their own users, while the underlying protocols guarantee seamless, real-time collaboration across network and organizational boundaries.
```mermaid
flowchart TD
accTitle: Google Wave Federation Architecture
accDescr: Diagram showing real-time operational federation between Google, Acme Wave, and Initech Wave servers.
subgraph GoogleDomain["Google Domain"]
ClientA["Lars' Client"] <--> ServerA["Google Wave Server"]
end
[01:06:10](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=3970s) Multi-Server Federation and Privacy Scopes Across Domains
To prove that federation is fully operational, Lars logs into a test instance inside Google’s corporate network configured with an open federation port, while Stephanie connects using an account on an entirely independent, competing service dubbed "Acme Wave." Stephanie’s client interface mirrors Google’s web UI because Google plans to open source the bulk of their codebase, allowing third parties to bootstrap functional wave services with minimal effort. Lars initiates a new wave asking, "Project. You want to work with me on that thing?" and adds Stephanie using her external handle (`steph@acmewave`). As she types her response—suggesting they bring in colleagues Peter and Milton from a company called Initech—her keystrokes stream character-by-character directly into Lars' client despite residing on disparate servers.
The demo expands further by federating with Initech, where fictional engineers Peter and Milton maintain their own custom Wave server hosted locally in an office server closet. Milton, being the type of developer who insists on writing everything from scratch, didn't use Google's client codebase. When Lars asks to add Peter and Milton, Stephanie jokes:
> “I'm afraid this crowd might like their UI better than ours and it would break my heart.”
Stephanie reveals Initech's minimalist client interface, drawing immediate cheers from the audience. She then demonstrates Wave's federated permission model by initiating an inline private reply inside the wave, addressing Peter and Milton with the message: "What do you think of that Google guy?" Because the reply scope explicitly excludes Lars, the operational data is synchronized exclusively between the Acme Wave server and Initech’s local server closet. Even though the overall parent wave was originally created and hosted on Google’s infrastructure, the private sub-conversation is cryptographically withheld from Google and completely undiscoverable by Lars.
- Fine-grained editing operations flow from the client to the local server, cross over the network to the peer federated server, and render on the remote client with full operational concurrency and conflict resolution.
- Private sub-threads exist only on the servers hosting the included participants; if Peter and Milton message privately between themselves, that wave data never leaves their local closet server.
[01:10:13](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=4213s) The Engineering Challenge of Federated Concurrency and Open-Source Plans
Lars addresses the engineering hurdles required to build a federated, concurrent editing architecture, contrasting it with proprietary alternatives. Combining real-time character-by-character collaboration, instant messaging, email workflows, and media sharing was already difficult, but implementing real-time operational transformation across disparate, untrusted server clusters dramatically elevated the complexity. He acknowledges that keeping the platform proprietary would have simplified release schedules, software updates, and central operations, but maintains that open federation is non-negotiable:
> “We think the world will be a much better place if this is an open system that everyone can build wave services with it.”
To jumpstart community adoption, Google announces that a public developer site will go live later that day featuring an early draft of the federation protocol along with four comprehensive whitepapers detailing the system architecture and operational transformation algorithms. In addition to community discussion forums, Google commits to open-sourcing the majority of their production codebase. This release will serve both as the formal reference implementation for the protocol and as a turnkey backend that organizations can connect to their own database systems to deploy custom Wave servers immediately.
[01:11:53](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=4313s) Real-Time Translation with Rosy the Robot
For the final live demonstration of the keynote, Lars introduces a research project developed over the preceding month by a colleague on Google’s research team. Switching back to the developer sandbox instance, Lars starts a clean wave, adds his French colleague Alexi (logged in via Stephanie's terminal), and invites an automated translation robot named "Rosy." Joking that Alexi’s English is subpar "for the purposes of this demo," Lars types in English: "Hello, world! What do you think of this demo?"
Across the network, as Stephanie types back in French on Alexi's client, Rosy instantly performs live inline machine translation character-by-character directly within the wave document. Lars reads along in real time as Alexi’s thoughts emerge translated into coherent English as the keys are depressed. Lars notes that Rosy supports around 40 distinct languages and can execute bidirectional real-time translations between any supported pair. The simultaneous translation display brings the keynote demonstration to a close, sparking massive sustained applause, cheering, and standing ovations from the developer audience.
[01:14:52](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=4492s) Recap: The Versatile Nature of a "Wave"
Following the live demonstrations, the room breaks out into banter as the presenters suggest that if attendees enjoyed the presentation, they could literally "do a wave." Taking the podium once more, Lars Rasmussen pauses to ask the audience what they thought, drawing warm laughter and applause before moving into a high-level summary of what the team has created. At its foundation, Lars emphasizes that Google Wave is intended to be a simple, elegant communication object that unifies formats that were previously isolated from one another.
```mermaid
flowchart TD
accTitle: Google Wave Capabilities and Extension Ecosystem
accDescr: Diagram categorizing Google Wave's built-in communication modes and external developer integration points.
subgraph Core["Core Communication & Editing"]
A["Wave Communication Object"] --> B["Email & Instant Messaging"]
A --> C["Photo & Rich Media Sharing"]
A --> D["Collaborative Document Editing & Wikis"]
end
subgraph Ext["Extension APIs & Integrations"]
A --> E["Embedded Web Widgets (Blogs & Discussion)"]
A --> F["Interactive Games & Apps"]
A --> G["External Gateways (Twitter, Facebook, IM, Email)"]
A --> H["Enterprise Workflows & Issue Tracking"]
end
```
He recaps the wide variety of use cases demonstrated across the keynote:
- Handling plain-vanilla email-style correspondence and threaded discussions.
- Conducting real-time instant messaging conversations without leaving the workspace.
- Seamlessly sharing photos and rich multimedia inline.
- Powering external web experiences such as blogs, forum discussion groups, and image-commenting widgets embedded directly into third-party websites.
- Building collaborative wiki spaces and multi-user live document editing environments.
- Leveraging rich extension APIs to build interactive games, native collaborative applications, and workflow automations.
- Constructing bidirectional gateways connecting Wave to external communication platforms like Twitter, traditional email, Facebook, and legacy instant messaging networks.
Reflecting on the scope of the project, Lars Rasmussen captures the team's underlying vision: “Just to summarize, um, what we like to think we've built here is really quite a simple communication object called a wave.”
---
[01:16:25](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=4585s) Breakout Sessions, Developer Office Hours, and Key URLs
Transitioning into event logistics, Lars highlights several unlisted breakout sessions scheduled for the afternoon, urging attendees to explore the technical underpinnings of the platform:
- **12:00 PM (Noon) — Wave APIs:** Lars underlines this as the most crucial session for developers, urging: “If you can only come to one of our breakout sessions, please make it that one.”
- **Technical Deep-Dive / Under the Hood:** A look into the core engineering stack, covering the server-side architecture of the contextual spell checker, the in-browser rich text editor, and the underlying operational transformation algorithms used for concurrency control and conflict resolution.
- **2:30 PM — Google Web Toolkit (GWT) Architecture:** Led by one of the client team tech leads, explaining how the entire web client was constructed with GWT, why the engineering team chose and loves the toolkit, and their future development plans.
- **12:00 PM – 4:30 PM (Room B4) — Developer Office Hours:** Open Q&A where attendees can meet face-to-face with the engineering team wearing blue shirts, of whom Lars jokes, "They love talking."
Lars then presents three essential URLs for developers and early adopters:
- **wave.google.com:** The future home of Google Wave when it launches later in the year. The site hosts an email notification sign-up form and will soon feature an edited video of the day’s keynote.
- **code.google.com/apis/wave:** The developer portal hosting the extension API, technical documentation, and code samples shown during the presentation. Lars is informed by an offstage colleague that the site has already gone live—prompting Lars to joke that this explains why he struggled with his mobile connection earlier. He notes one caveat: the issue-tracker integration demo utilized an internal Google API that is not yet public, so that particular sample code will not be immediately available.
- **waveprotocol.org:** The home for the open architecture, including the draft protocol specification, technical whitepapers, and developer discussion forums for those interested in federating and building an open communication system.
Prompted by Stephanie Hannon to clarify account access, Lars announces that attendees will receive an email later that day detailing how to sign up for developer preview accounts.
---
[01:19:12](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=4752s) Lessons from Google Maps and a Call to Developers
In his closing thoughts, Lars expresses deep personal gratitude for the audience's enthusiastic reception. He draws a direct parallel to the launch of Google Maps in 2005, describing that period as one of the highlights of his career because developers immediately reverse-engineered and remixed the product to build unexpected mashups before an official API even existed. That organic developer passion forced Google to scramble and release an official Maps API, which ultimately turned into the primary engine of the platform's worldwide success.
Lars emphasizes that Google Wave was deliberately architected with this same developer-first philosophy in mind: “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.”
Closing out the keynote to a standing ovation and enthusiastic cheers, he leaves the audience with a direct challenge: “Please, please, please, check it out. Build cool stuff. Surprise us. I just can't wait to see what you come up with.”
## Notable quotes
> [27:47](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1667s) With Wave you don't have to make that choice. You can do both discussion and content collaboration in one tool. — Stephanie Hannon
> [27:47](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1667s) So now that we have accountability in place, we're going to allow everybody on a wave to edit everything by default. — Jens Rasmussen
> [23:13](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1393s) What's important is that our embed API is powerful enough for you to build your own Wave client. — Stephanie Hannon
> [32:05](https://www.youtube.com/watch?v=v_UyVmITiYQ&t=1925s) Playback is going to be a really powerful tool for investigating and manipulating the entire history of the wave. — Lars Rasmussen
## Mentioned
Google, Google Wave, Vic Gundotra, Lars Rasmussen, Jens Rasmussen, Stephanie Hannon, Gregory Delasander, Greg D’Alesandro, Google Maps, Google I/O 2009, Google Web Toolkit (GWT), Google Chrome, Apple Safari, Mozilla Firefox, Apple iPhoto, Google Gears, Google App Engine, Orkut, Android, iPhone, HTML5, Java, JavaScript, CSS, OpenSocial, YouTube, Twitter, Bugzilla, Google Code, Facebook, Acme Wave, Initech, Spelly, Linky, Searchy, Polly the Pollster, Tweety, Twave, Buggy, Rosy, Lance Armstrong, Ryan Seacrest
## Video description
Google Wave Developer Preview presentation at the Day 2 Keynote of Google I/O. To learn more visit http://wave.google.com
[27:47] Stephanie Hannon: With Wave you don't have to make that choice. You can do both discussion and content collaboration in one tool.
[27:47] Jens Rasmussen: So now that we have accountability in place, we're going to allow everybody on a wave to edit everything by default.
[23:13] Stephanie Hannon: What's important is that our embed API is powerful enough for you to build your own Wave client.
[32:05] Lars Rasmussen: Playback is going to be a really powerful tool for investigating and manipulating the entire history of the wave.
Original transcript
[0:01] man:
Ladies and gentlemen,
[0:02] please welcome Vice President,
Engineering, Vic Gundotra.
[0:07] [cheers and applause]
[0:11] Gundotra:
Well, good morning, everyone.
[0:13] Welcome to day two
of Google I/O.
[0:16] I hope you all had
a great time yesterday.
[0:18] I hope you enjoyed
your sessions,
[0:20] and I hope you enjoyed
those Android phones.
[0:23] [audience whoos]
[0:24] [cheers and applause]
[0:29] Yesterday, we promised you
a surprise for this morning.
[0:33] And this morning,
Google will surprise you.
[0:37] We are about to unveil
[0:39] a personal communication
and collaboration tool
[0:43] in a very early form.
[0:45] We decided to do this
at this forum
[0:48] for a couple of reasons.
[0:49] This unbelievable product,
[0:51] one that I'm very,
very excited about,
[0:54] will be open-sourced.
[0:57] It's open-sourced
for many reasons.
[0:59] Not only do we want to
contribute to the Internet,
[1:01] but frankly,
we need developers
[1:03] to help us
complete this product,
[1:05] and we need your support.
[1:06] So we hope after
you see this
[1:08] you're as excited
about it as we are.
[1:11] And number two,
[1:13] we decided to unveil
this product
[1:15] in its early form
at this conference
[1:17] because it is an unbelievable,
powerful demonstration
[1:20] of what is possible
in the browser.
[1:23] I guarantee you that over
the next hour and a half,
[1:26] as you see this product,
you will forget
[1:29] that you are looking
at the browser.
[1:31] And I want you
to repeat after me.
[1:33] "I am looking
at an HTML 5 app.
[1:36] I am looking at what's
possible in the browser."
[1:39] And I hope you are as excited
and delighted as I was
[1:43] when I first saw the thinking
behind this product.
[1:46] Now, it shouldn't
have surprised me
[1:48] that this product
would be magical.
[1:50] After all,
the engineering leadership
[1:53] had already produced
a magical product.
[1:55] The engineering leadership
behind what you're about to see
[1:59] is the work
of two brothers,
[2:01] and an amazing
engineering team with them.
[2:03] Those two brothers
are Lars and Jens Rasmussen.
[2:07] You might remember
those names,
[2:09] because those were
the same amazing people
[2:12] that did another magical app
called Maps--Google Maps.
[2:16] And so you'll see what
they've been working on
[2:18] unveiled for
the first time today.
[2:20] So why don't we go ahead
and get started?
[2:21] Remember, this is
an early developer preview
[2:24] for this audience.
[2:26] Everyone in this room will get
accounts to give us feedback,
[2:30] and we'll talk about that
a little bit later.
[2:32] We have your email addresses,
so you will get those passwords
[2:35] a little bit later on,
likely tomorrow.
[2:37] With that, let me just
go ahead and get started.
[2:39] Let me introduce Lars Rasmussen
and Stephanie Hannon.
[2:43] Thank you.
[2:45] [cheers and applause]
[2:47] Lars Rasmussen:
Thank you.
[2:48] Thank you.
Thank you.
[2:54] Thank you very much.
[2:56] I shall wake up
my laptop.
[3:00] Good morning, everyone.
[3:02] Thank you very much
for coming early.
[3:03] I know you've been here
partying all night.
[3:06] Uh, we're going
to show a demo today
[3:07] of a product that
we've been working on
[3:09] for a couple of years
down in Sydney, Australia.
[3:12] It's called Google Wave,
[3:15] and it's a communication
and collaborations tool
[3:18] that we're launching
later in the year.
[3:20] Uh, like Vic said,
it's a little unusual for us
[3:22] to be showing it
to the world this early.
[3:25] The reason we're doing it
is very simple.
[3:27] We're starting
a developer preview today.
[3:30] You guys will all
get accounts
[3:31] on a sandbox build
of the system.
[3:33] You are the first outside
of Google to see this,
[3:36] and you'll be the first
to get accounts on the system.
[3:39] And we're doing that because
as you will see from the demo,
[3:43] Google Wave comes with a set
of really nice APIs,
[3:45] and we're hoping we can
persuade you guys
[3:47] to start building cool things
with those APIs
[3:51] while we're getting
the product ready for launch,
[3:54] which is going to happen
later this year.
[3:56] Because that way,
when we do launch,
[3:58] our users and your users
can enjoy both Google Waves
[4:01] and all the cool things
that we hope you'll build
[4:04] at the same time.
[4:05] Let me introduce
Stephanie Hannon.
[4:07] She's quite possibly
the best PM in the world.
[4:10] [cheers and applause]
[4:12] Hannon: [laughs]
[4:16] Good morning, I/O.
[4:18] Thank you, Vic,
for the invitation to be here.
[4:20] We couldn't imagine
a better audience
[4:22] to show our
product to first.
[4:24] Lars Rasmussen:
I second that.
[4:26] Hannon: Our presentation
today is in three parts.
[4:29] First, we're going to show you
a demo of the product.
[4:31] Second, we'll show you the APIs
that Lars talked about.
[4:35] You can use Waves
to enhance your Web site
[4:38] and you can build
extensions to Wave itself.
[4:41] Third, we'll show you
that Wave is also a protocol.
[4:44] We are very passionate
about this being
[4:46] an open system
of communication.
[4:49] We hope other people
build Wave services
[4:51] that interoperate
with ours
[4:53] so users have choice
in their provider.
[4:55] We affectionately
call this the three Ps.
[4:59] Product, platform, protocol.
[5:01] And we'll talk
about them all today.
[5:04] Lars Rasmussen:
Okay, so communication.
[5:07] Um, email today is by far
the most popular way
[5:10] for us to communicate
on the Internet,
[5:11] which is remarkable,
[5:13] because email was invented
more than 40 years ago.
[5:16] before the Internet,
before the Web,
[5:19] and it was done
without the experience
[5:21] of things like SMS,
and instant messenging,
[5:24] and blogs, and Wikis,
and bulletin boards,
[5:26] and discussion groups,
and social networks, and Wikis,
[5:29] and media sharing sites,
and collaborative editors--
[5:33] All of these different
kinds of communication
[5:35] that we take
for granted today.
[5:37] Also, of course,
computers and networks
[5:40] have dramatically improved
in those four decades,
[5:43] and so when we started
this project--
[5:45] and it's been
more than two years--
[5:47] we asked ourselves
the question,
[5:49] "what might email look like
if it was invented today?"
[5:53] And needless to say,
there is about a million
[5:54] different ways you can
answer that question.
[5:57] What you're going to see today,
Google Wave, is our attempt.
[6:01] And so let me start
by briefly contrasting
[6:04] email from Wave.
[6:06] Email essentially
mimics snail mail.
[6:09] The basic metaphor
is you write a message
[6:11] and you send it
to one or more recipients,
[6:14] and then email systems--
[6:15] and we like to think Gmail
does this particularly well--
[6:18] can collate related messages
into conversations or threads.
[6:24] Wave, by contrast,
starts out
[6:28] with the definition
of a conversation,
[6:29] which is simply a lightweight
tree structure of messages
[6:32] and a set of users participating
in that conversation.
[6:35] And then instead of thinking
of individual messages
[6:38] as being sent
back and forth,
[6:40] we think of the entire
conversation object
[6:42] as being a shared object
hosted on a server somewhere.
[6:46] And users that participate
can open up that wave,
[6:50] leave their replies,
go away,
[6:52] and then when
the next user comes,
[6:54] she can open up
that same shared object,
[6:57] see those replies,
and add her own.
[6:59] That's how the wave grows.
[7:00] That's how the conversation
builds up.
[7:02] And you'll recognize
that this is a model
[7:05] that came to how
bulletin boards work.
[7:07] We found that with a tight
enough implementation,
[7:09] you can use that to build
a single communication tool
[7:12] that has functionality
spanning quite a lot further
[7:15] than what you can do
with email today.
[7:18] And so we'll show you a demo.
[7:20] It'll take you through
a series of usage scenarios
[7:24] that you'll be
familiar with,
[7:25] but where today we would use
different tools for each one,
[7:29] and we'll show you
how it all fits neatly
[7:31] in this one metaphor
of hosted conversations.
[7:33] Stephanie.
[7:35] Hannon: So what you are
looking at is an HTML 5 app
[7:38] that we built with
the Google Web Toolkit.
[7:40] On the left side
is Lars running Chrome.
[7:43] On the right side,
I'm running Safari.
[7:46] And a little bit later
we're going to throw in Firefox.
[7:48] So the same thing is being shown
on each pair of screens,
[7:51] you can just
choose one to look at.
[7:54] Lars Rasmussen:
Okay, so we'll start
[7:56] with plain vanilla-type
email conversations,
[7:59] and we'll show you
how it looks in Wave.
[8:02] We're planning
a boat trip.
[8:04] And I'm going to start
by clicking "New Wave" here,
[8:06] and then I'll type my title
in the first line.
[8:08] Hannon: Watch your
spelling, Lars.
[8:09] There's a lot of people.
[8:11] Lars Rasmussen: [laughs]
There is a lot of people.
[8:12] They can't see
what I'm typing anyway.
[8:14] "Are you ready
for the boat trip?
[8:18] Hey, Steph."
[8:20] Did you guys like
the spell-checker?
[8:22] [applause]
[8:23] You do.
[8:26] We'll talk more
about that later.
[8:27] Since you don't want
to watch me type for an hour,
[8:30] we put canned messages
in there.
[8:31] We'll try hard to pull them out
before we launch.
[8:35] I click "Done,"
it asks me for more users.
[8:38] I'll add Stephanie.
[8:40] And since she is offline,
[8:42] I'm going to go stare
at a blank page.
[8:45] Hannon: So I will
open Wave.
[8:48] And you'll see in my
Search panel, the middle panel,
[8:50] will be an unread
message from Lars.
[8:53] He's asking me
if I want to go shopping,
[8:55] uh, before this
boat trip,
[8:56] so I'll do something
very email like,
[8:58] which is hit "Reply,"
[8:59] and say,
"I looove shopping."
[9:03] Lars Rasmussen:
I wrote the script.
[9:05] Hannon: "I need new fins.
Let's go."
[9:11] The first benefit
I want to show you
[9:13] of this being
a hosted conversation
[9:15] is it's easier
to keep track of structure.
[9:18] If this was email
and I wanted to reply
[9:20] to the middle part
of Lars's message
[9:21] where he asked
which bus to take,
[9:24] I would hit "Reply," the email
client would copy the message,
[9:27] and I'd hand-edit
in the response.
[9:29] Because this is
a hosted conversation
[9:31] that lives in one place,
[9:33] I can just instruct the server
to split the message apart
[9:37] and say,
"You never wake up early,"
[9:40] which is true.
[9:42] "Let's take the late bus."
[9:45] Okay, Lars isn't online;
I'm going to close this wave.
[9:49] Lars Rasmussen: So a little bit
later I come back online,
[9:51] and you'll see, for starters,
that that wave is now bold
[9:54] to show me there is
new material in it.
[9:56] When I open it up, Stephanie's
first message gets the highlight
[9:59] and I can navigate the
conversation with my keyboard,
[10:02] and of course,
continue her thread here.
[10:04] "You know me too well."
[10:06] Like that.
[10:08] And that's how plain vanilla
email-type conversations
[10:11] work in Wave.
[10:13] So you've noticed that
we have carefully avoided
[10:15] having the wave open
on both screens.
[10:17] When we do have the wave
open at the same time,
[10:20] my message bounces
right off the server
[10:23] into Stephanie's browser.
[10:24] The effect is
that you can also
[10:26] do Instant Messaging-type
conversations in Wave.
[10:29] In fact in the same wave
you can switch back and forth
[10:32] between these different
ways of communicating.
[10:34] I'll show you that now.
[10:36] Shiny.
You must know a good store.
[10:41] [cheers and applause]
[10:42] Hannon: There is a new one
over on George Street.
[10:48] Lars Rasmussen: Cool.
Let's go at 7:00.
[10:52] Hannon: "Sounds good.
Let's invite Jens too."
[10:56] Lars Rasmussen: "Okay."
[10:57] So you noticed that it didn't
wait for me to hit "Done"
[11:00] before showing
Stephanie the message,
[11:02] but rather--and this was
difficult to do--
[11:04] we transmit live almost
character by character
[11:07] what I'm typing.
[11:08] Why did we do that?
[11:09] It's because with today
instant messaging tools
[11:11] you spend half of your time
looking at it saying,
[11:14] "Stephanie is typing,
she's typing, she's typing,
[11:16] she's typing,"
and then you see what she said.
[11:21] Thank you.
[laughs]
[11:23] But because in general you can
start formulating your own reply
[11:27] before Stephanie
is done typing hers,
[11:30] by doing this
live transmission,
[11:31] you end up spending 100% of your
time either reading or writing,
[11:34] which dramatically
speeds up the conversation.
[11:37] Now needless to say,
there are times
[11:38] you don't want everyone
to see every keystroke,
[11:41] in particular
if you spell like I do.
[11:43] Um, and so we have
this checkbox here.
[11:46] All you have to do
is check it
[11:47] and now no one can
see what you're typing
[11:49] until you hit
that "Done" button.
[11:50] This is one of the features we
haven't implemented quite yet.
[11:53] [laughter]
[11:58] Okay, so that's how
email conversations,
[12:00] or rather email-type
conversations
[12:02] and instant messaging-type
conversations
[12:04] no longer require
two separate tools.
[12:07] Next thing we want
to show you is how easy it is
[12:09] to add a new person
to an ongoing conversation.
[12:12] Can I just introduce
my brother Jens, by the way?
[12:15] Give him a hand, please.
[12:16] [cheers and applause]
[12:22] So we want to--
[12:23] We want to add Jens
to the conversation.
[12:25] If this was email, I would
take the last message here,
[12:28] reply to it and add Jens
to the recipient list.
[12:31] There's two problems
with that.
[12:32] For starters,
[12:33] because we branched
the conversation up here,
[12:36] that last email message
[12:37] would not contain
the entire conversation.
[12:39] But also,
if Stephanie then later
[12:42] went and replied to
an earlier message of mine,
[12:44] Jens wouldn't
get that anyway.
[12:46] You end up with these
cat and mouse games.
[12:48] In the Wave model,
all you have to do
[12:51] is make Jens a participant
in the wave like that.
[12:55] And now I'll switch
over to Firefox here
[12:58] where Jens is
already signed in.
[13:01] Jens Rasmussen:
So now that I'm on the wave,
[13:03] um, I'm going to open it,
[13:05] and, of course, everything
is going to be marked
[13:08] as unread for me.
[13:10] But because
I was added late,
[13:11] I didn't get to see
Lars's message in one piece,
[13:14] and by the time I'm added they
could be arbitrarily far apart.
[13:17] So we added a feature
called Playback.
[13:20] So I get to see
Lars's original message,
[13:23] Lars asks Stephanie,
Stephanie replies,
[13:26] Steph does in-line reply,
and so on, and so on.
[13:29] [applause]
[13:32] Thank you.
[13:34] So Playback turns out to be
a really useful feature,
[13:37] particularly when the wave
[13:38] starts picking up
more structure,
[13:39] and we'll show you
more of that later.
[13:41] But now that I've
caught up on this wave,
[13:43] I'm going to just
add my reply.
[13:48] "Me too."
[13:50] Oh, I think I crashed.
[13:51] Lars Rasmussen: Did I mention
that it's a developer preview?
[13:54] [laughter]
[13:55] So we made sure
to inject a few bugs
[13:57] so that you wouldn't have
too high expecta--
[13:59] I'm just kidding.
[14:05] Jens Rasmussen: Did you notice
how quickly it reloads?
[14:07] [laughter]
[14:09] Did we mention
we used GWT?
[14:13] All right, so I'm
going to add my reply.
[14:16] "Me too.
[14:17] Don't forget your keys."
[14:22] And then I'll hand it back
to Lars.
[14:24] Lars Rasmussen: Thank you.
[14:25] So that's how easy it is
to add a new person
[14:28] to an ongoing
conversation.
[14:30] And so often
we end up having
[14:31] very nice
group conversations in Wave.
[14:33] And then occasionally
you want to say something
[14:35] in a wave that's not visible
to all the participants.
[14:38] We call that
a "Private Reply,"
[14:40] and I'll add one
down here at the bottom,
[14:42] and I'll say,
[14:43] "Let's buy Steph
a reeeally nice present."
[14:49] Hannon: I wrote this part.
[14:51] Lars Rasmussen: And then
I will add just Jens,
[14:53] and you will see,
[14:55] if I just quickly
flip over to Jens's browser,
[14:58] and scroll down,
[14:59] he sees that
private reply,
[15:01] but if you look
at Stephanie's screen,
[15:04] she doesn't see it.
[15:06] If you remember,
I've explained
[15:07] that a wave is
a tree structure of messages.
[15:09] Essentially you can take
any sub-tree of the wave
[15:13] and restrict access
to a subset of the participants.
[15:17] Okay, I switch back
to my own account, here.
[15:20] The next thing
we want to show you
[15:22] is how attachments
work in Wave.
[15:23] So we've been
on a boat trip--
[15:25] It was very nice,
thank you--
[15:26] And we all
got pictures.
[15:28] I have six of them
sitting here on my desktop,
[15:30] and I'm going to drag them
onto the wave like this.
[15:35] [applause]
[15:42] Hannon: You might not
have noticed,
[15:44] but the thumbnails
appeared on my screen
[15:47] long before the full images were
uploaded from Lars's computer.
[15:50] I'll show you
that again
[15:52] by dragging in
my own photos from iPhoto.
[15:57] Ready?
Here we go.
[15:59] Lars Rasmussen: And you can see
them show up over on my screen.
[16:02] audience member: Yeah.
[16:03] [applause]
[16:04] Lars Rasmussen:
Don't be shy, you guys.
[16:06] If you like what you see,
don't be shy letting us know.
[16:09] [cheers and applause]
[16:11] We can--we can handle pretty
much any amount of applause.
[16:15] [laughter]
[16:17] Hannon: This feature--
[16:18] drag and drop from the desktop
to the browser--
[16:20] is the one part of Wave
that HTML 5 can't support yet.
[16:25] We're working on a proposal
to add it to the standard.
[16:28] In the meantime,
you need to download Gears
[16:30] for this specific
feature to work.
[16:32] It's the only part of Wave
that you need Gears for.
[16:36] When Lars
dropped in his images,
[16:38] you might've noticed
at the bottom of the Wave panel
[16:40] there's an Image menu
[16:41] with actions you'd
probably do on images,
[16:43] like upload or download.
[16:46] What's important
is these actions
[16:47] apply to all
the images in the wave,
[16:50] not just the ones
I dropped in,
[16:52] which makes Wave really
an easy, lightweight way
[16:54] to create a group
photo album together,
[16:57] which is surprisingly
hard to do with today's tools.
[17:00] Lars Rasmussen: And so here's
the photo album.
[17:02] This is Captain Athena.
[17:04] Here's the hard life
down under.
[17:06] And as advertised,
you'll see over here
[17:08] Stephanie's images
show up in my slideshow
[17:10] so that I can show you
[17:11] just how much fun
life down under is.
[17:17] And that's images.
[17:19] So that's how easy it is
to share photos in Wave.
[17:21] This was a group trip.
[17:23] We'll all throw
our photos in here.
[17:24] We'd probably share it
with the rest of the office
[17:26] to make them envious.
[17:27] In this particular case,
it's not clear
[17:30] that we want everyone to know
that we went shopping together.
[17:33] And so one of the features
down here
[17:35] lets me copy
just the images
[17:37] from this wave
into a fresh wave.
[17:39] "Boating in January.
[17:42] Enjoy all,
here and yonder."
[17:47] And then I'll add
Stephanie to this.
[17:49] I could now share that
with the rest of the office.
[17:52] Now, this feature here
of extracting images
[17:55] from a wave and putting them
in a new one
[17:57] is actually part
of a very important
[17:59] design principle for us.
[18:00] Namely that we care
just as much
[18:02] about the product of the wave
as we do the wave itself.
[18:06] And we'll show you
more examples of that later.
[18:11] Yes, we will.
[18:13] Um, I forgot what's next.
[18:16] Hannon: How 'bout we show them
the embedding APIs?
[18:19] Lars Rasmussen:
Excellent idea.
[18:20] Okay, thank you. So...
[18:21] [laughter]
[18:22] She's right.
[18:24] We should've rehearsed this
before coming this morning.
[18:26] Just kidding.
[18:27] So the first--
[18:29] The first category of, um,
APIs that we want to show you
[18:32] are APIs that let you
embed waves onto your webpage.
[18:37] It is very similar
to the Maps API,
[18:40] which, by the way, um,
thank you, everyone who used it.
[18:43] We consider your enthusiasm
for that API
[18:46] an enormous factor
in that product's success,
[18:49] and we're hoping, obviously,
to repeat that with Wave.
[18:52] Hannon: Give a round
of applause to themselves.
[18:54] Lars Rasmussen: Oh, yeah,
a round of applause to yourself.
[18:56] Well done.
[applause]
[18:58] Lars Rasmussen: Okay, so...
Hannon: Yay, developers!
[19:01] Lars Rasmussen: Here's
an example application.
[19:02] It's a little blogging site
we've built.
[19:04] It's over
on Google App Engine,
[19:06] but you could build it
anywhere you host your website.
[19:09] And this blogging site--
[19:10] In addition to embedding
waves on its pages,
[19:13] it provides me
with this robotic participant
[19:16] that we affectionately
call Bloggy.
[19:18] All I have to do
is add Bloggy to the wave,
[19:22] and now you'll see--
[19:24] You can probably
not read that,
[19:25] but on that yellow banner,
[19:27] all users on the wave
is now warned that Bloggy,
[19:30] this new participant,
has published the blog
[19:33] on a page which we built
over an app engine.
[19:36] Can I just introduce
Gregory Delasander?
[19:39] He's another PM
on the team.
[19:40] [cheers and applause]
[19:42] And he's going to show you
the blog site now.
[19:45] Delasander: Hi, I'm Greg,
[19:46] and I'm a huge fan
of Lars's blog,
[19:47] just like everybody on the team
is told they should be.
[19:50] I'm going to show you...
Hannon: He makes us read it.
[19:53] Lars Rasmussen:
It's a good blog. Come on.
[19:54] Delasander: Oh, hold on
just a second.
[19:59] Did we lose...
[20:02] Hannon: Did we lose VPN?
[20:03] Delasander:
Yes, I think we might have.
[20:05] Hannon: Lars, this is
where you do the dance.
[20:06] Delasander:
Lars, dance a little bit.
[20:07] Lars Rasmussen:
Everyone look at me.
[20:08] Don't look at his screen.
[20:09] [humming]
[20:11] The Wave dance.
[20:12] Delasander: I think
we lost all connectivity.
[20:14] Lars Rasmussen: Neener, neener.
Neener, neener.
[20:19] There's not a--
Delasander: And then...
[20:22] Lars Rasmussen: There's not
a lot of people in the world
[20:23] that can have their demos
as spectacularly fail
[20:25] in front of 4,000 people
and not break a sweat.
[20:29] Hannon: It wasn't the demo,
it was the network.
[20:31] Lars Rasmussen: We wish
we were one of them.
[20:33] Delasander: Excellent.
[20:34] Lars Rasmussen: I think your
proxy server might be missing.
[20:36] Oh, there we go.
Hannon: All right, we're back.
[20:38] Delasander:
So as I was saying...
[20:42] The blog.
[20:44] So in the blog, one of
the cool things you'll s--
[20:46] you can see is that we're
not just embedding the images,
[20:49] we're actually embedding
the whole wave
[20:50] with all of its UI.
[20:52] This means
that I can respond.
[20:54] "Hey, that looks fun.
Why wasn't I invited?"
[20:57] [cheers and applause]
[21:03] The same way we embed--
[21:06] And we--we do--
[21:07] You can respond in the same way
you do in the Wave client.
[21:10] Lars Rasmussen: Exactly.
[21:11] And so now,
I can see, obviously, uh,
[21:13] Greg's question
from inside my Wave client.
[21:15] I can answer from in here.
[21:17] I don't have to go
to the blog site to do that.
[21:19] I could if I wanted to,
but I can stay here.
[21:22] "Um, I lost the phone
with your number."
[21:28] I really,
truly can't spell.
[21:30] Here we go.
[21:32] Delasander: So one of
the things you just saw
[21:34] is that I happened to be online
when Lars was online,
[21:36] and I saw his response
coming in live on his blog.
[21:39] That's not always
going to be the case.
[21:40] Since I responded
to this blog,
[21:42] it'll show up
in my Wave client.
[21:45] Right after I refresh
my Wave client.
[21:49] Um, it will show up
in my Wave client
[21:51] and I can continue
the conversation in there.
[21:54] "But, Lars,
I live next door."
[21:57] [laughter]
[22:00] And, um--
And then we can--
[22:01] That response shows up
on the blog,
[22:04] we can continue
the conversation from there,
[22:06] and anyone else can
join in that conversation.
[22:09] Lars Rasmussen: Thank you, Greg.
Delasander: No problem.
[22:11] [applause]
[22:14] Lars Rasmussen:
Thank you.
[22:17] And so this, again,
is an example
[22:19] of how to use our embedding APIs
to put blogs on your web pages,
[22:23] and here we showed you
with a blogging site,
[22:25] but you could imagine
discussion group sites,
[22:27] community forums--
[22:28] if you have
a rich-media site
[22:29] you can let your users
discuss that using waves.
[22:33] The benefit
for developers, of course,
[22:34] is you get to provide
this very live, rich experience
[22:38] with very little code.
[22:39] For your users, for starters,
they get to use a familiar UI,
[22:43] but for those of your users
that have Wave accounts,
[22:46] they get to walk
around the Web
[22:48] and aggregate the conversations
they're interested in
[22:50] into the Wave client
so that they don't
[22:52] have to go check back
on 10,000 different pages
[22:55] whether someone
responded to them.
[22:57] Which will make flame wars
so much more effective.
[23:00] [laughter]
[23:01] She hates that joke.
[23:03] Hannon: I hate it.
[laughs]
[23:05] Lars Rasmussen: Okay.
[23:06] So that was an example
of how to embed waves.
[23:09] The embedding APIs
can do other things,
[23:11] and Stephanie
will show you that now.
[23:13] Hannon: So we invited
some of our colleagues
[23:15] from Brazil and India
to Sydney
[23:17] who work on one of our
social networks called Orkut.
[23:20] We wanted to build a demo
of what it could look like
[23:23] to put waves
inside of Orkut.
[23:25] Obviously, it's a place where
lots of discussions happen.
[23:28] It demonstrates
three important principles,
[23:31] or features,
of our embed API.
[23:34] Let me load up the demo.
[23:42] So here's my Orkut account.
[23:44] And you can see there's
a Wave panel in the middle.
[23:47] And the first thing is
I can create a wave on Orkut.
[23:51] So I'm starting a new wave,
and I'll say, "Brazil trip?
[23:54] Wonder when Lars
will let me go."
[24:01] The second important feature
is that you can
[24:03] use contacts
other than your Wave contacts.
[24:06] In this case,
the authors of the site
[24:08] chose to use
the Orkut contacts,
[24:10] so I can add
some of my Orkut friends
[24:12] like Sid, Torston,
and Rodrigo,
[24:16] who all helped
build this demo.
[24:18] The third principle is that
I can embed a "Search" panel
[24:21] inside of Orkut
using the embed API.
[24:25] I'll show you that now.
[24:27] I can search for all my waves
from here.
[24:32] And so on.
And look at them.
[24:35] So that's waves
embedded in Orkut.
[24:38] What's important
is that our embed API
[24:41] is powerful enough for you
to build your own Wave client.
[24:45] In this case, the Orkut team
[24:46] chose to focus on waves
created inside of Orkut.
[24:49] But just like
in the blog example,
[24:52] I can go back to my Wave client,
[24:54] and I can see the wave
I started there.
[24:57] "Wonder when Lars
will let me go to Brazil."
[24:59] So that's the embed API.
[25:02] Lars Rasmussen: You guys--
[applause]
[25:04] Thank you.
[25:09] Are you guys
feeling inspired yet?
[25:11] So remember that we're all
going to give you accounts
[25:13] on a sandbox build,
[25:15] which is in fact the build that
we're demo-ing from later today,
[25:18] and this is all
sample applications
[25:21] that we're hoping
you'll pick up
[25:22] and build much,
much cooler things with.
[25:25] Okay, so the next thing
I want to show is
[25:27] of course you're going to want
Wave on your mobile devices,
[25:31] and I have an Android
and an iPhone here,
[25:34] and I was going to show you
how well it works communicating
[25:38] from mobile devices
to the desktop,
[25:41] but you guys are all
on Facebook, aren't you?
[25:43] Because I can't
get on the wireless.
[25:46] [laughter]
[25:47] So if it doesn't work,
it's your fault.
[25:51] Okay, so you can see
my inbox over here.
[25:53] This is on
the Android device.
[25:54] Here's an open--
[25:56] uh, the same open wave
we saw before.
[25:58] You see the pretty
pictures here.
[26:00] And then I can click
the "Reply" button like this,
[26:05] and you'll see
over on Stephanie's screen,
[26:08] which I can't see.
[26:11] You will see a reply.
[26:13] Imagine I was actually
on a network,
[26:15] and then I could type in,
"I am on the boat."
[26:21] Done.
[26:23] Notice again my spelling.
[26:25] And nothing is going
to show up over there
[26:27] because we haven't
yet figured out
[26:28] squeezing this through
without a connection.
[26:32] Maybe we'll show you that.
[26:33] [laughter]
[26:35] Hannon: As long as it's your
fault that it's not working.
[26:37] Lars Rasmussen: We are--
[26:38] Hannon: I just don't
want to screw up the--
[26:39] Lars Rasmussen:
We are working on it.
[26:40] Okay, so that's mobile.
[26:44] Hannon: How 'bout
we talk about editing?
[26:46] Lars Rasmussen:
Oh, that's a brilliant idea.
[26:47] Thank you.
[26:49] Okay, so the next thing
we're going to show.
[26:51] Again because, um,
there's only--
[26:53] Back to my desktop.
Thank you.
[26:54] There is only one copy
of the wave out there.
[26:57] Even though we put
these pictures on my blog,
[26:59] I discussed them
with Greg,
[27:01] uh, we had them
on my mobile device.
[27:03] Now I notice
that some of the captions
[27:05] are kind of wonky.
[27:06] And all I have to do is click
this "Edit" button here,
[27:09] and then I can
fix that.
[27:11] Kayaks. Beer Man.
[27:14] Thank you.
[applause]
[27:18] Hannon: And as you notice,
[27:19] the captions
are updating on the blog.
[27:22] Lars Rasmussen: Yes, hopefully
you saw that the captions
[27:24] were actually updating live
on the blog as I was typing.
[27:28] So, here I edited
my own message,
[27:30] but we actually let users edit
each other's messages as well,
[27:34] which is a very nice effect
that in addition
[27:36] to everything
we showed you already,
[27:38] you can use waves
[27:39] to collaboratively
author documents,
[27:41] which we'll show you now.
[27:42] So let's leave the boat behind,
and let's go to work.
[27:45] Stephanie.
[27:47] Hannon: As Lars mentioned,
I'm a product manager,
[27:49] and I often have to
take notes in a meeting.
[27:51] Today I have to decide
if I want to send those notes
[27:54] out on email because
I want people to discuss them,
[27:57] or if I'm going to put them
in a dock or a Wiki,
[27:59] 'cause I want other people
to help me edit them.
[28:01] With Wave you don't
have to make that choice.
[28:03] You can do both discussion
and content collaboration
[28:07] in one tool.
[28:09] So these are
our meeting notes.
[28:11] I'm going to add Lars,
[28:13] Jens, Greg, and ACD.
[28:17] [Lars Rasmussen and Hannon
speak over each other]
[28:18] Lars Rasmussen:
Pardon me.
[28:20] Hannon: Then you open it.
[28:21] Lars Rasmussen:
Then I open it.
[28:22] And even though
this is Stephanie's message,
[28:24] I can click
that same "Edit" button
[28:26] and change this
to "glorious."
[28:31] And then I can
add an action item.
[28:33] "AI. Make more better
AIs, already."
[28:38] Whoo, like that.
[28:39] Thank you.
[28:40] [applause]
[28:43] Thank you.
[28:44] And so that's
how easy it is
[28:46] for me to edit
Stephanie's message.
[28:48] We want to show you now
how it looks
[28:49] to the other participants
on the wave--
[28:51] the fact that
I edited her message.
[28:52] We'll start
with Stephanie.
[28:54] Hannon: So you can see
the wave pop back into my inbox
[28:56] because there's
new material.
[28:58] If I open it,
I see the markups.
[29:01] So I see the changes
that Lars made.
[29:03] Lars Rasmussen:
Thank you.
[29:05] [applause]
[29:09] Hannon: We haven't
implemented it yet,
[29:11] but we'll also have
a little description at the top
[29:12] that says
Lars edited this message.
[29:15] What's important
is I see these markups
[29:17] not because I wrote
the original message,
[29:20] but because I saw
the original message.
[29:23] Anyone who saw
my original message
[29:25] would see
these same markups
[29:27] the next time
they visited the wave
[29:29] after Lars
made his edits.
[29:31] Jens Rasmussen:
All right, now,
[29:32] I didn't get to see
the original message,
[29:33] so when I open up
this wave,
[29:35] I just see
the current version of it.
[29:37] But I do get to see
[29:38] that both Stephanie and Lars
wrote this message.
[29:41] Most of the time
I'm not going to care,
[29:44] but if I do care, then Playback
is my friend again.
[29:47] So I see Stephanie's
original message,
[29:49] she adds Lars,
[29:51] and then I get to see
Lars's edits.
[29:55] [applause]
[29:58] Thank you.
[30:00] So now that we have
accountability--
[30:01] accountability in place,
[30:03] we're going to allow
everybody on a wave
[30:05] to edit everything
by default.
[30:08] When something
is changed,
[30:09] the author
is notified immediately,
[30:10] and, if needed,
can take action.
[30:12] and everybody who's on the wave
can find out who did what.
[30:17] So Stephanie promised
that we were going to do
[30:20] collaboration and communication
using the same tool.
[30:22] Hannon: I did.
Jens Rasmussen: So I'm going--
[30:24] Now that I know that Lars made
this--the request for more AIs,
[30:27] I'm going to use the in-line
reply tool we showed earlier,
[30:30] um, to add my reply here.
[30:34] "No, enough AIs already."
[30:40] My spelling is not
doing well either.
[30:44] Lars Rasmussen: It's hard
when 4,000 people are watching.
[30:46] Jens Rasmussen:
Typing and talking?
[30:47] It's a little bit
too much.
[30:48] There we go.
So I'll hand it back to Lars.
[30:50] Lars Rasmussen:
Okay, thank you.
[30:51] So notice--
[30:53] Notice that we never said,
"Let's start a document, here."
[30:56] These are all
just waves.
[30:57] The only thing
different here
[30:58] is that we chose to think
of that opening message
[31:01] more like a document
we're collaborating about
[31:03] than a message
that starts a conversation.
[31:06] And then we're choosing to think
about that in-line reply
[31:09] more like the beginning
of a conversation
[31:11] about the point
in that document.
[31:13] But to the system,
they're all just waves,
[31:15] and in fact,
you can collaboratively edit
[31:17] any message
in the tree.
[31:19] Doesn't have to be, uh,
document-like at all.
[31:22] Stephanie often comes
and very friendly fixes
[31:24] all of my spelling errors.
[31:27] And so we think this combination
of collaborative editing
[31:31] and in-line discussion
[31:33] makes for a very powerful
collaboration tool.
[31:35] And I want to show you that
with a design document
[31:38] that the team wrote
a while back.
[31:41] Let me just reconfigure
my client, here.
[31:43] I'm going to go do a safe
search, find the document here,
[31:49] Let me make some more
space for it.
[31:51] And you'll see here
that it's a RISTEX document.
[31:54] It's got headlines,
it's got bullet points.
[31:55] It's got illustrations,
different types of fonts.
[31:58] And then it's interrupted
[31:59] by these little snippets
of conversation
[32:02] that help facilitate
the collaboration.
[32:05] And as always, the best way
to see how this happened
[32:07] is to play back the wave.
[32:09] And you'll see Steven,
our trusted server guy,
[32:11] started out
with a terse draft.
[32:13] He added the rest of the team
[32:15] Lars the manager
says, "Please do more work."
[32:18] Steven grudgingly
adds another paragraph.
[32:20] He says, "Yeah, whatever."
[32:22] Then Stephanie the PM
makes an edit here.
[32:24] She adds a comment there,
[32:26] starts a discussion there,
and so on.
[32:29] I can use the slider
here to drag it
[32:31] to anywhere in the history
of the wave.
[32:34] And we're planning
a bunch of power tools
[32:36] that come with Playback.
[32:38] For example,
I might ask it
[32:39] only to play back
Stephanie's contribution.
[32:41] So I might ask it to only
play back a single message
[32:44] or even a single paragraph
inside a message.
[32:47] we're definitely going to
let you take
[32:48] one change in the history
[32:50] and revert it at the end
of the history.
[32:52] Maybe name aversion so that you
can find it again and so on.
[32:55] Playback is going to be
a really powerful tool
[32:57] for investigating
and manipulating
[33:00] the entire history
of the wave.
[33:04] Thank you.
[33:05] [applause]
[33:10] And so now imagine we're done
with the design document.
[33:13] Or we find we're
in a good state;
[33:15] we want to share it
with a wider audience.
[33:17] You'll notice it's not super
comfortable reading a document
[33:19] interrupted by all
this discussion,
[33:21] so we added
this widget here
[33:23] that lets you hide
and show some discussions,
[33:27] but also, just like we extracted
images from a wave earlier,
[33:31] we let you extract
the current version
[33:33] of any message in a tree
into a fresh wave.
[33:36] Like this.
[33:37] And now I have a fresh wave
[33:39] with the pristine
product of our work,
[33:42] which I can now submit
to the server
[33:44] and share with
whomever I like,
[33:45] put on a mailing list internal
blog or even keep working on.
[33:49] And in fact, we're planning
more features here
[33:52] for document production.
[33:53] Imagine you go back
and do more work
[33:55] in the original wave.
[33:57] Then you'll be able
to merge just those changes
[33:59] into that same
product wave.
[34:01] The product wave will just
have a two-step history now,
[34:04] where each step is attributed
to whoever did the copy.
[34:07] In fact, and you guys will
recognize this as, um,
[34:10] inspired by
source-controlled systems.
[34:12] We'll have you--
[34:13] We'll let you have
a whole string of work waves,
[34:15] all pointing
to the same product wave.
[34:17] You can have
different themes
[34:18] working on different
parts of a wave,
[34:20] and then when
one team merges
[34:22] and that changes
into the product wave,
[34:24] the other teams
can pull that down,
[34:25] merge it with
the local changes, and so on.
[34:28] So this is
going to become
[34:29] a very powerful
document production tool.
[34:33] Thank you.
[34:34] [applause]
[34:39] We showed you this,
of course, with, um,
[34:42] with, uh,
rich text documents.
[34:44] There's no reason
we shouldn't
[34:46] later add spreadsheet-type
functionality in there,
[34:48] or presentation building-type
functionality in there.
[34:50] In fact as we'll show you later,
we've taken great care
[34:53] to make the content model
inside Wave extendable,
[34:56] both by us and by you.
[34:59] Okay, the next thing I want--
[35:00] Hannon: Why don't you
just talk for a minute
[35:02] before you open it?
[35:03] Lars Rasmussen:
Talk for a minute...
[35:05] Hannon: You know.
[35:06] Lars Rasmussen:
Before I open it.
[35:07] Hannon: 30 seconds.
[35:08] Lars Rasmussen: We could do
a little interpretive dance
[35:10] while we open it.
[35:11] It's not that there's
anything wrong
[35:12] with the thing
I was about to open,
[35:13] it's just that--
[35:14] How're you guys doing?
[35:15] [laughter]
[35:17] Are you having
a good time?
[35:18] I know it's a long demo.
Thank you.
[35:20] Don't be shy
if you like it.
[35:23] Hannon:
All right, we're ready.
[35:24] Lars Rasmussen:
There's a whole bunch of people
[35:25] in blue shirts working
feverishly over there.
[35:28] [chuckles]
And we're ready.
[35:30] Okay, so here is
a wave, um...
[35:33] Here is a wave.
That's right.
[35:34] So my little introduction
here is the following:
[35:37] We're going
to show you now
[35:38] the thing we had
the most fun working on.
[35:40] As in this was
the hardest thing we did.
[35:43] Um, which is to let
more than one person
[35:46] edit the same message
at the same time
[35:48] and still transmitting
the characters live on the wire.
[35:51] So we have
a set of pictures here,
[35:52] and Stephanie
is going to start
[35:54] at the top-left
editing the captions.
[35:56] You can see on my screen
[35:57] I can see exactly where
that orange label--where she is,
[36:00] and I'm going to start
from the lower-right.
[36:02] Hannon: "Thumbs up."
[36:04] Lars Rasmussen: "Spelling
Google."
[36:06] Hannon: "Lars in the lead."
[36:07] Lars Rasmussen: "Smiley David."
[36:09] Hannon: "Wave crew hiking."
Lars Rasmussen: "Kapow."
[36:11] [applause]
[36:12] Thank you.
[36:14] Now we're very close
to each other.
[36:15] I'll add some
styling here.
[36:17] I'll make this italic.
[36:19] Oh, boy, if someone
can add some color.
[36:22] We can do this.
[36:23] Notice how close
we can edit to each other.
[36:25] You can see we've got
a couple of--
[36:26] of our team
has joined us.
[36:28] We've got three people here.
[36:29] Casey, Steph, Ophir and Dan.
[36:32] We have four people now,
[36:34] editing the same document
right next to each other.
[36:37] [applause]
[36:41] Thank you.
[36:43] Thank you.
[36:45] And so apart
from hours and hours of fun
[36:47] just chasing each other's
carrots around on the screen...
[36:50] [laughter]
[36:51] Hannon: It's a lot of fun.
Lars Rasmussen: A lot of fun.
[36:54] Um, the--the--this sort
of live, concurrent editing
[36:57] opens up a whole set
of new ways of using the tool.
[37:00] We're actually
still discovering some.
[37:02] Imagine you're
in the same room,
[37:03] you're taking notes
from a meeting.
[37:05] Oftentimes people don't even
come to the meeting,
[37:07] they just open up the wave,
see the notes being taken,
[37:10] they just pop their questions
in the wave, and so on.
[37:14] I want to--
while I'm showing off our edit,
[37:16] I want to
make sure you see
[37:18] that it supports
right-to-left languages.
[37:20] This is Ophir
speaking in Hebrew.
[37:23] Thank you.
[37:24] [applause]
[37:28] You see up at the top-left that
the editor supports languages
[37:31] that require international
input method editors as well.
[37:35] I'm pretty sure
that's Chinese.
[37:40] Okay.
That's collaborative editing.
[37:46] And now...
[37:48] Man, this is a long demo.
[37:50] You guys want
to stand up a little?
[37:51] Stretch.
Hannon: Any stretching?
[37:52] Lars Rasmussen:
Stretch a little.
[37:53] Hug the person
next to you.
[37:55] [laughter]
[37:56] You don't
have to do that.
[37:57] Hannon: A hug break.
Make some friends.
[38:00] Lars Rasmussen: Um, I want
to take a little break.
[38:02] We have lots more
to show you,
[38:04] but I want to take
a little break,
[38:05] and I want to, um, call out
to our friends and colleagues
[38:09] on the Google Web Toolkit team.
[38:11] So--Thank you.
[38:12] [applause]
[38:14] Thank you.
[38:18] So Google Wave is 100% built
with the Google Web Toolkit
[38:22] from the first line of code
we wrote in a prototype
[38:25] back in early 2007.
[38:27] And as I'm sure you know,
the Google Web Toolkit
[38:30] lets you write HTML 5
applications in Java.
[38:34] And then GWT,
as we call it,
[38:36] automatically translates that
into HTML, JavaScript, CSS,
[38:40] all of those things
that then run
[38:41] in all
of the modern browsers.
[38:43] And I think that we couldn't
possibly have built
[38:47] something this rich
without the Google Web Toolkit.
[38:50] In fact, I don't think we would
even have thought to do that.
[38:54] I think using
modern tools like this
[38:56] changes your way
of thinking.
[38:58] When I was still hand rolling
JavaScript for Google Maps,
[39:01] I found too much
of my brain cycles
[39:05] were used worrying about
the constraints of programming
[39:07] in a scripting language
in a browser.
[39:09] But by using GWT,
I get to write in Java
[39:12] and have this
amazing set of tools
[39:13] that come with
writing in Java,
[39:15] and we found
that our programmers
[39:17] can now spend
most of their time
[39:18] thinking about the amazing
potential of the Web.
[39:23] And by the way, this is
both if you're on a desktop
[39:26] or if you're
on a mobile device,
[39:28] when I showed you
on the Android and iPhone here,
[39:31] Wave was running in the browser
in both of those phones.
[39:35] GWT makes that
fairly easy to do.
[39:37] It's actually
the same code
[39:39] that runs
in those mobile devices,
[39:41] it's just a different layout.
[39:43] We estimate that the extra
requirement of serving this
[39:46] both into desktop browsers
and mobile browsers
[39:49] only adds about 5% extra
engineering effort,
[39:52] which I find remarkable.
[39:56] Okay.
[39:57] Hannon: And that graph
from yesterday.
[39:58] Lars Rasmussen: Pardon me.
[40:00] Oh, the graph from yesterday.
Did you see that?
[40:01] How we built 1.4 megs of code
and then all of a sudden
[40:04] it went down to 200k?
[40:06] We like GWT for that.
[40:09] [applause]
[40:13] Hannon: All right.
So back to the demo.
[40:15] Let's talk
about organization.
[40:17] We learned from our own use
of Wave
[40:20] that you get a lot of waves,
which is great,
[40:23] but you need tools
to organize them.
[40:25] We have things
you're familiar with
[40:26] like folders
and saved searches.
[40:29] We also have tags
and they're shared
[40:31] by all the participants
on the wave.
[40:34] So you have
just as much incentive
[40:35] to put a great tag on a wave
as a great subject.
[40:39] For example,
Lars is way too lazy
[40:41] to organize his own stuff.
[40:42] Lars Rasmussen: Oh, yeah.
[40:43] Hannon: So we have a team
help him do it.
[40:46] Lars Rasmussen: Thank you.
Hannon: [laughs]
[40:48] But the most powerful way
to organize waves
[40:50] is with waves themselves.
[40:52] Let me open a wave we used
to organize this demo.
[40:55] You can see it has links
to other waves in it
[40:57] and you can combine, uh, them
in sections, formatting.
[41:01] You can discuss them.
[41:03] And if I click
on one of these links,
[41:05] it'll take me to that wave
[41:07] and I can use the back button
to go back.
[41:10] So let me show you
how easy it is
[41:12] to create one
of these wave links.
[41:14] If I missed one,
I can just pick it up
[41:17] from the search panel
and drop it in.
[41:20] [applause]
[41:25] I'll do that one more time
'cause I think it's cool.
[41:28] Drop it in.
[41:30] So we found
on our own team
[41:32] links--wave links are good
for more than just lists.
[41:34] We're actually interlinking
a lot of waves on our site
[41:37] almost like a Wiki,
uh, on our team.
[41:40] Before we get
to Wave extensions,
[41:42] which I know this audience
is really excited about,
[41:44] I want to show you
one more thing
[41:46] that we worked
really hard on.
[41:48] I'm going to go up here
and search for Google Wave.
[41:51] Lars Rasmussen: I have
a feeling, uh, you're going
[41:52] to want to refresh your browser
before we do this.
[41:55] Hannon: Just like my inbox,
when a wave matches this search,
[41:59] it will pop into the panel.
[42:03] Lars Rasmussen: And so Stephanie
has a search
[42:04] for Google Wave over there.
[42:06] I'm teeing up
a new wave here.
[42:08] Said, "Wow.
[42:09] I am finally demo-ing
Google Wave."
[42:15] Now the reason this hasn't
showed up
[42:17] in Stephanie's search yet
is I didn't type the E.
[42:20] So what I'm going to do,
I'm going to count to three,
[42:22] then I'm going to hit the E,
[42:24] and you guys can count
how many seconds it takes
[42:26] before it shows up
in Stephanie's browser.
[42:28] One, two, three.
[42:32] [applause]
[42:37] You guys want to--
you guys want to see that again?
[42:40] [laughter]
[42:41] Hey, Stephanie, can you open up
that wave for me?
[42:44] Hannon: All right,
let me go over there.
[42:45] Lars Rasmussen:
Backspace.
[42:46] Hannon: [laughs]
[42:48] [laughter and applause]
[42:51] Lars Rasmussen:
E, backspace, E,
[42:53] backspace, E, backspace, E,
backspace.
[42:57] We call that the Wave dance.
[43:00] So we've worked really hard
on this.
[43:02] We're pretty proud
of the result.
[43:03] I should just say
after we started using it,
[43:06] we found
this is almost too fast.
[43:07] Sometimes, uh, it draws
your attention
[43:09] to unfinished work.
[43:10] And we're actually looking
for the right balance
[43:12] between speed and not being
interrupted too often.
[43:17] Okay, what's next?
[43:19] Hannon: Extensions.
Lars Rasmussen: Extensions.
[43:22] The reasons
you guys came here.
[43:24] Okay. So the next thing
we want to show
[43:27] is the other category
of APIs
[43:30] that we're
making available today,
[43:31] which is about extending
the functionality of Wave.
[43:35] So we have tried hard
to maintain a discipline
[43:37] on the team
that even significant offerings
[43:40] of our own should be built
with our own extension APIs
[43:43] so that your extensions
will live
[43:45] as first-class citizens
inside Wave.
[43:47] It's similar, actually,
to how browsers like Firefox
[43:51] let you extend them.
[43:52] This is just the web site
you're extending
[43:54] instead of the browser.
[43:55] So let me show you
some examples.
[43:58] You've undoubtedly noticed
how all morning,
[44:00] I've been pretending
my spelling is bad
[44:03] just so that we could show off
our spell-checker.
[44:06] So normally
spell-checkers work
[44:07] by matching words up
against a dictionary.
[44:09] If they find there's--
if they don't find a word
[44:11] that is in error,
[44:12] the problem is
that oftentimes
[44:14] spelling mistakes
hits other dictionary words.
[44:16] And so our spell-checker
actually takes the context
[44:19] of the word into account
[44:21] and then it matches it up
[44:22] against an enormous
language model
[44:24] that we've built
from the entire web.
[44:26] Let me show you
how powerful that is.
[44:29] We call this
the "Bean Soup Demo."
[44:32] "Can I have some been soup?"
[44:38] It puts a red on the line
[44:39] and it knows that I meant
"bean soup."
[44:42] Thank you.
[44:43] [applause]
[44:47] Okay, now watch carefully.
[44:49] "It has bean so long."
[44:54] Did you see that?
[44:59] So it is--it has become
so good at spell-checking
[45:02] that often,
it has enough confidence
[45:04] that we let it automatically
correct my errors.
[45:07] Let me show you that again.
[45:10] "Icland is an icland."
[45:15] [applause]
[45:22] "You are to kind."
[45:29] Pretty cool, huh?
[laughs]
[45:31] You didn't see
that last one.
[45:33] Okay, so that's
our spell-checker,
[45:35] or Spelly as we
affectionately call it.
[45:37] Let me show you another
simpler one
[45:38] that detects links
in what you're typing.
[45:41] And we call it Linky.
[45:42] "I love google.com."
[45:47] It immediately puts
an underline--.a--
[45:50] ooh, that's not a link--
.u--now it's a link again.
[45:54] [applause]
[45:58] You're wondering
what's this all got to do
[45:59] with extensions
and let me explain that.
[46:02] So you remember
we showed you a robot earlier
[46:04] called "Bloggy."
[46:05] All that one did
was publish a blog
[46:08] that let you use
the embedding API.
[46:10] But robots
are really powerful ways
[46:11] of extending Wave's
functionality.
[46:13] They're server-side programs
that participate in Wave
[46:17] with all the power
of the human participants.
[46:19] You can see from your robot
the live changes in the wave.
[46:22] You can make live changes
to the wave
[46:24] including adding
and removing messages,
[46:26] collaboratively edited
messaging,
[46:28] adding and removing
participants.
[46:30] You can even start new waves
from robots.
[46:33] And the way Spelly works
[46:34] is that it uses our robot APIs
to watch what I'm typing.
[46:38] It sits on the server.
It watches what I'm typing.
[46:40] It takes every so many words
and matches it up
[46:43] against a language model.
[46:45] And then when it finds
an error,
[46:46] it uses collaborative editing
to edit the content.
[46:50] And in fact, when it doesn't
have enough confidence
[46:52] and it put
that red underline,
[46:54] if Steph and I were editing
the message at the same time,
[46:56] she would also see
the red underline
[46:58] and she could be the one
taking the suggestion.
[47:01] Linky works
in the same way.
[47:05] But who wants
to be typing in links all day?
[47:08] We had a very good friend
of ours
[47:10] from the Google Search Team
build this extension for us here
[47:13] called Searchy.
[47:15] Let's search for Australia.
[47:16] Hannon: We have a really clever
naming convention.
[47:19] Lars Rasmussen: And here
you can do a Google search
[47:20] from right inside Wave
and add the link like that.
[47:24] [applause]
[47:28] You guys want
to see that again?
[47:30] I search for Bora Bora.
It's so pretty there.
[47:33] I add an image to the wave
just like that.
[47:36] Thank you.
[47:38] [applause]
[47:41] Let me just quickly return
to our friend Linky.
[47:44] I've got a video
sitting here.
[47:46] Let me copy the URL.
[47:49] And inside my wave,
[47:51] I'm going to type
"Check this out."
[47:55] And then I'm going to copy
the link in there.
[47:58] And then I'm going to dance
a little bit
[48:01] while the system
spectacularly fails.
[48:04] [laughter]
[48:07] Maybe we'll return
to that later.
[48:10] Okay, so that's extensions
that we built
[48:13] with internal APIs.
[48:15] And what we're doing today
as part of the developer preview
[48:17] is--is make external versions
of these APIs
[48:21] available to you guys.
[48:23] The external APIs
have almost all the power
[48:25] of the internal APIs.
[48:27] There is a few things
we haven't quite figured out
[48:29] how to secure the export.
[48:31] We're working very hard
to close the gap.
[48:33] We're going to show you now
a series of examples
[48:37] of things that are built
with the external APIs.
[48:39] These are all sample codes
[48:41] that are going
to be on code.google.com
[48:43] where we'll host the API.
[48:45] Stephanie.
[48:48] Hannon: Any open social gadget
can sit inside a wave.
[48:51] In fact, we were about
to show you one
[48:52] which might come
a little bit later.
[48:55] But we also make
an additional API available
[48:58] that lets you the developer
make your gadget
[49:00] live and collaborative.
[49:02] I want to show you that.
[49:04] But before I do, I'll digress
and tell you a little story.
[49:07] Even though we on this team
have been building Wave
[49:10] and thinking about Wave
for a year and a half,
[49:12] when we first started
using it ourselves,
[49:14] it took awhile for us
to discover all the ways
[49:17] Wave can make you
more productive
[49:19] because we were so used
to older tools.
[49:21] In fact, we're still discovering
new ways all the time.
[49:25] I'll show you that
by opening a wave
[49:27] and using Playback
to tell you what happened.
[49:31] Uh, someone on our team
wanted to create a movie outing
[49:33] and we should all go see
the Transformers.
[49:35] So he sent a wave out
and people did something
[49:37] very email-like
and responded.
[49:40] "I'm interested."
"What place are you going to?"
[49:43] "Is that really a good movie?"
And so on.
[49:45] I tried to get them to see
Confessions of a Shopaholic.
[49:49] Nobody went for that.
[49:50] Lars Rasmussen:
She's still trying.
[49:52] Hannon: Still trying.
[49:53] So when you look
at this wave,
[49:55] it's sort of hard to parse out
the important information
[49:57] of who wants to go.
[49:58] So somebody suggested
we should all edit
[50:00] the opening message
instead of putting it
[50:02] in individual messages.
[50:05] And we cleaned up the wave.
[50:06] Everyone started editing
the opening message and so on.
[50:12] This was a much better way
to construct this RSVP list.
[50:16] And we could still have
discussions
[50:17] about which car to take
and so on.
[50:20] Now, we're all engineers,
[50:22] and you can look
at this workflow
[50:23] and think
there are better ways
[50:25] or there are ways
to make this even better
[50:27] using our extensions.
[50:29] So another engineer
on our team wrote a gadget.
[50:35] We call this
the "yes-no-maybe gadget."
[50:39] Hey. [laughs]
[50:41] [applause]
[50:44] So if you--it's hard to see
for you guys, I know.
[50:46] But I'm currently in "No"
in the middle column
[50:48] and I'm to change it
to "Maybe."
[50:51] And you see it update
on Lars' screen.
[50:54] [applause]
[50:56] Lars Rasmussen:
And I'm currently
[50:57] in the "Maybe" column.
[50:58] And I click
the "Yes" over here.
[50:59] And you'll see
it quickly updates
[51:01] on both our screens.
[51:03] Hannon: So you
the gadget developer
[51:04] only have to worry
about two things.
[51:07] When I click the button,
[51:08] update the state of the gadget
in XML and the wave,
[51:12] then we automatically transmit
through the server
[51:15] to Lars' client
where your gadget
[51:18] has to update the UI
to reflect the new state.
[51:23] Now, of course we did
all this--
[51:25] ooh, it's a secret though--
[51:27] I, um, uh, don't tell anyone,
[51:29] but we did all this
so we could build
[51:30] impossibly fun,
addictive games.
[51:32] And we'll show you
a few of those now.
[51:34] Lars and I are going
to open Sudoku.
[51:37] Lars Rasmussen: Hmm. Hmm.
[51:40] Hannon: And we intended for this
to be a collaborative game
[51:42] so we could solve
the puzzle together,
[51:44] but somehow it turned
competitive.
[51:46] [laughter]
[51:47] And, uh, you get a point
for making a good move
[51:51] and a negative point
for doing something wrong.
[51:53] You can see Lars' score
is going negative.
[51:56] Lars Rasmussen:
How can you play Sudoku
[51:58] in front of 4,000 people?
[51:59] Come on.
[52:00] Hannon:
Then, uh, back in 1851,
[52:02] Lars and I
played this chess game
[52:04] that became very famous.
[52:05] It ended in 23 moves.
[52:07] And it illustrates how well
Playback works with gadgets.
[52:11] So if I go into playback
and I click forward,
[52:15] you can actually step through
the whole game.
[52:18] [applause]
[52:27] So as we mentioned
in the beginning,
[52:28] we come from the Maps team.
[52:30] So probably wouldn't be
a good demo
[52:32] if we didn't do
a Maps gadget as well.
[52:34] It's been a lot of work
to prepare for this demo.
[52:36] So I'm going to send Lars a wave
about taking a vacation.
[52:40] Lars Rasmussen:
Stephanie's favorite topic.
[52:41] She wants to go on vacation
in Bora Bora.
[52:43] She's asking me
for recommendations.
[52:46] I highlight the term
Bora Bora here.
[52:48] And then I click this button
that's provided
[52:50] by an extension
that you guys could've written
[52:52] that inserts a map
to Bora Bora.
[52:56] Thank you.
[applause]
[52:58] Hannon: Now,
the important thing
[52:59] is my hands are off
of my computer,
[53:01] but my screen is still
on the right.
[53:03] Lars Rasmussen: And now I click
the satellite button
[53:05] and it changes
on both screens.
[53:06] And I go zoom, zoom,
zoom, zoom, zoom, zoom.
[53:12] [applause]
[53:14] [laughs]
Thank you.
[53:17] [applause]
[53:20] And now, Stephanie loves
swimming with sharks.
[53:24] And I happen to know
that the lemon sharks hang
[53:26] over here.
[53:28] And you can see
that I put that marker on.
[53:31] Shows up live
over on Stephanie's screen.
[53:33] Now my hands are off.
[53:34] Hannon: And I'll pick up
the polygon tool
[53:36] and I'll tell Lars, actually,
I want to stay in this area.
[53:39] Lars Rasmussen: And you see that
showing up on my screen too.
[53:41] And so again, all you guys
have to do with your gadgets
[53:44] is to store updates
to the state
[53:46] in the local XML.
[53:48] And then we transmit
on the wire
[53:49] and then the other instance
of your gadget
[53:51] just updates its state
when it gets notified
[53:54] of that change.
[53:57] And so those are client-side,
um, extensions.
[54:01] I want to just show you,
actually,
[54:02] the team in blue over here
is scrambled.
[54:05] And they brought back up
Linky.
[54:07] And I wanted to show you
what happened
[54:08] when I dropped that YouTube URL
into the old extension wave.
[54:13] So you'll see that Linky
didn't just recognize
[54:15] it was a link,
[54:17] but it recognized
it was a link to a video.
[54:19] It puts this
little friendly light bulb
[54:21] on my screen
where I can open up
[54:23] a set of suggestions
for what I might want to do.
[54:26] Like, for example,
I might want to embed the video
[54:29] right inside my wave
[54:32] and play it for you guys.
[54:35] [wobbling noise]
[54:38] Dah nah.
Pretty cool, huh?
[54:40] [applause]
[54:46] Thank you.
[54:48] Okay. What's next?
[54:50] So Stephanie showed you
a bunch of gadgets.
[54:52] They're all client-side
extensions.
[54:55] We want to show you next
what you can do
[54:57] on a server side
with robots.
[54:59] And we're going to show you
three examples.
[55:01] The first one
is an application--
[55:03] a collaborative application
built entirely within Wave
[55:06] with our extension API.
[55:09] So let me just open up
my inbox again.
[55:11] And instead of clicking
"new wave,"
[55:13] I'm going to hit
this drop-down button here.
[55:15] And I'm going
to hit this item
[55:16] called a "new poll."
[55:18] New poll
is just a new wave,
[55:21] but with a special robot
that comes from an extension
[55:24] that you guys could build
called Polly the Pollster.
[55:28] I'll add Steph
to the wave as well.
[55:31] Polly added a form
to the wave.
[55:35] Yes. And so this is not
a gadget.
[55:37] Forms are native to wave.
[55:39] You can put them in there.
[55:40] And now
I can fill out the form
[55:42] starting with the title
of the poll
[55:44] that I want to conduct.
[55:46] And you'll see
as I'm typing in the form,
[55:49] Polly sits
on the server side.
[55:51] She saw that
letter by letter,
[55:52] and she updated
the title of the wave.
[55:56] Now the really cool thing
about having forms in waves
[55:58] is that you can fill them out
collaboratively.
[56:01] So Stephanie's going
to fill in the choices
[56:03] while I add
the question here.
[56:05] "Which movie
is the best ever?"
[56:10] And you see that Stephanie's
filling in the options
[56:13] in the field below.
[56:15] Hannon: Star Wars.
[56:17] Lars Rasmussen: Star Wave.
[laughs]
[56:21] Hannon: Not on purpose.
[laughs]
[56:24] Lars Rasmussen: Confessions
of a Shopaholic.
[56:25] So now Stephanie's going
to fill out a number of people
[56:28] that we're going
to send the poll to
[56:30] in the recipient list there.
[56:36] She's putting in--
[56:37] Hannon: Done.
[56:38] Lars Rasmussen: Putting in
six of them.
[56:39] Now I'll hit the button here
that says "distribute poll."
[56:42] Now, what happens is
that Polly sees
[56:43] that I hit that button.
[56:45] She fills in
a results section
[56:48] in that same wave here.
[56:50] And then she sends out
fresh waves
[56:52] with the questions
we specified
[56:54] to all the recipients
we specified.
[56:56] And Stephanie's
one of them.
[56:58] Hannon: So I'm going
to answer the poll
[56:59] that Star Trek's my favorite.
[57:01] Lars Rasmussen: And you'll see
that Polly updates the results
[57:03] live in the admin wave.
[57:07] With a bit of luck--
thank you.
[57:09] [applause]
[57:15] Okay. So that's the--
an example of an extension
[57:17] built exclusively inside
of Wave.
[57:21] The next type of extension
we want to demonstrate for you
[57:24] are extensions
that integrate Wave
[57:27] with existent
communication systems.
[57:29] In this case, we'll show you
with everyone's favorite
[57:31] microblogging service,
Twitter.
[57:35] Hannon: So at this point,
you're probably wondering
[57:37] how to install
these extensions.
[57:39] So let me open a wave.
[57:41] And you probably
won't be surprised to hear
[57:42] that extensions can live
inside a wave.
[57:45] Here's their--a bunch
of puzzle pieces
[57:47] showing some of the things
we're using today.
[57:51] All I have to do if I want
to use one of these inst--
[57:53] extensious--is--
[57:55] Sorry.
Click the "install" button.
[57:59] And you can see over here,
there's a new drop-down menu.
[58:02] And I have the option
to create a new twave.
[58:05] Lars Rasmussen: A wave,
of course--twave, of course,
[58:07] is a wave of tweets.
[58:10] Hannon: You can describe
as a developer
[58:11] how your extensions
hook into Wave.
[58:14] It could be
a keyboard shortcut,
[58:15] a button on the tool bar.
[58:17] It could be something
like a new twave button.
[58:19] There'll be
a confirmation page
[58:20] that tells the users
how you're going to interact.
[58:23] We haven't quite implemented
that yet.
[58:26] So let me log in here.
[58:28] I have to tell you that Lars
created my Twitter account.
[58:30] Lars Rasmussen:
I made her Twiffanie.
[58:32] She hates that.
[58:35] Hannon: [laughs]
[58:36] Lars Rasmussen: She's Twiffanie
at Twitter.
[58:40] Hannon: I think that tab button
should be implemented, you guys.
[58:42] [laughs]
[58:44] I feel like all sorts
of bad stuff is about to happen.
[58:48] [laughs]
[58:50] All right, so I'll sign in
to Twitter.
[58:57] And you can see tweets
[58:58] from all the famous people
I follow.
[59:01] And down here at the bottom,
Lars.
[59:03] Lars Rasmussen: No.
[59:05] Hannon: I'm just going
to close it.
[59:06] We still haven't,
uh, uh...
[59:10] I wanted
to get the contacts out.
[59:13] Um, it's important you can see
that each of these avatars,
[59:17] they're not necessarily
Wave users.
[59:19] Through our APIs,
you can be a proxy
[59:22] for contacts
on a different system.
[59:24] So I have Lance Armstrong,
Ryan Seacrest,
[59:27] lots of different people.
[59:28] If I go down here
and I look for Lars' tweet,
[59:32] I can respond to it.
[59:34] He says, "The demo's going
pretty well."
[59:37] And I'll say,
"It ain't over yet."
[59:41] [laughs]
[59:42] Lars Rasmussen: And now
I've logged in
[59:44] to Twiffanie at Twitter
over here.
[59:46] And if I refresh the page,
[59:48] you'll see that the extension
took Stephanie's wave reply
[59:52] and tweeted it.
[59:55] Thank you.
[59:56] [applause]
[59:59] Hannon: Now Tweety
also lets you search
[60:01] over the public timeline
of Twitter.
[60:03] For example,
for a phrase like "Google Wave."
[60:06] So I'm going to start
a new twave.
[60:09] Lars Rasmussen: You're going
to search for Google Wave now?
[60:11] Hannon: Gonna do it.
[60:12] Lars Rasmussen:
How brave it that?
[60:14] Hannon: [laughs]
I'm not afraid.
[60:17] So try again.
[60:21] I'm going to log in.
[60:24] And then I'm going to type
Google Wave.
[60:28] So we did this yesterday
and there are only two tweets.
[60:31] One of them was a woman
interviewing at a company
[60:33] called Wave so she said,
"I should google Wave
[60:36] before my interview."
[60:39] So now let's sign in.
See what happens.
[60:46] Lars Rasmussen: * Doo doo *
Hannon: A lot more than two.
[60:49] Lars Rasmussen:
Oh! [laughs]
[60:51] Hannon: And we can go down
to the bottom
[60:53] and see tweets
still coming in.
[60:54] Lars Rasmussen: Oh, my God,
you guys, thank you.
[60:57] [laughs]
Wow. Thank you.
[60:59] [applause]
[61:07] Hannon: So that was a example
of an integration
[61:09] between Wave and another
communication system.
[61:12] Lars Rasmussen: I'll just add
to the search functionality
[61:15] here, actually, that you can--
you can have Tweety
[61:17] continuously search
over in Twitter
[61:19] and update the wave
as they come.
[61:21] So you can use them
like "twit alerts"
[61:23] for whatever
you're interested in.
[61:24] It'll just pop
into your inbox.
[61:31] Buggy.
Hannon: Buggy.
[61:33] We were reading the tweets.
[61:34] Lars Rasmussen: We were reading
the tw--
[61:35] Hannon:
Totally threw us off.
[61:36] [laughs]
[61:38] Lars Rasmussen:
Okay, the last example
[61:40] of a robot extension
we want to show
[61:42] is an example of how you can use
Wave extension APIs
[61:45] to integrate Wave
within existent workflows.
[61:49] You guys are programmers
like us.
[61:50] You probably deal
with filing bugs.
[61:53] I want to show you
an integration
[61:54] between Wave
and the issue tracker--
[61:57] the bugs database
over on code.google.com.
[62:00] But this could be any issue
tracker Bugzilla could host,
[62:03] whichever is your favorite.
[62:05] So I'll just conjure up
a canned message here.
[62:08] And I'll tell you
a little bit
[62:09] about how we do bugs
on my team.
[62:12] So a programmer
has built some code.
[62:13] They send it
for code review.
[62:14] They also send a demo
to the PMs and the UI people
[62:17] and Jens and I.
[62:19] And then we sit in the room
and we test it.
[62:20] And you can't read
the text here.
[62:22] But there's a bunch
of bullet points
[62:23] with observations we made.
[62:25] We, of course, edited this
collaboratively.
[62:27] Some of them are bugs.
[62:29] Some of them are observations
for discussion later.
[62:31] Some of them are notes
for the UI designers.
[62:33] And, of course, we should now go
and file bugs.
[62:36] Um, but instead of doing that
manually,
[62:38] we run an extension that lets me
just select a bullet point,
[62:42] click this button here,
[62:43] and now a robot enters the fray
called Buggy,
[62:47] takes that text,
and files it as a bug for me.
[62:50] [applause]
Thank you.
[62:52] Hannon: Hey, Lars,
why don't you add me?
[62:54] Lars Rasmussen:
Yes. Excellent.
[62:56] And I'll add Steph
to the wave.
[62:57] The bug--the, uh--the--the--
sorry, the robot
[63:00] also grabs a little summary
from issue tracker
[63:03] and puts it
right inside the wave.
[63:05] There's a link there
to the bug
[63:06] will Stephani--which Stephanie
will now click
[63:09] so that you can see the bug
sitting over on issue tracker.
[63:15] Hannon: All right,
so I'm going to open this bug,
[63:17] number 11.
[63:19] Lars Rasmussen:
And while she does that,
[63:20] I'll file a bunch more.
[63:21] You can see how easy
it is.
[63:23] And I just triple click here.
There's another one.
[63:26] And I'll file that bug too.
[63:28] Okay. And so now,
we might send this wave--
[63:30] we might share this wave
with our bug triage team.
[63:33] I'll just do that myself.
[63:35] All I have to do
is change the assignee here.
[63:38] I'll give this to Stephanie.
I'll take this myself.
[63:41] And then this one
goes to Lars.
[63:44] Ooh, I'm sorry.
Was that Greg?
[63:45] Like this.
[63:46] And now you'll see--
Stephanie will refresh the bug
[63:48] and you'll see the robot
change the assignee over
[63:52] in the issue tracker.
[63:53] Hannon: On the left-hand panel
where it says "owner."
[63:56] Lars Rasmussen: And also,
most issue trackers
[63:57] or bug databases
lets you debate bugs--
[64:00] endlessly if I recall--
inside the database.
[64:03] Which is normally
not the strength
[64:04] of the database.
[64:05] But it is the strength
of Wave.
[64:07] And so instead of debating them
over on issue tracker,
[64:10] you can debate the bug
from inside Wave.
[64:13] I'll just use the inline
reply tool here.
[64:15] And I'll say,
[64:16] "That is so not my fault!"
[64:21] Hannon: And I'll refresh.
You can see the update there.
[64:25] [applause]
[64:30] Lars Rasmussen: And so now
we can continue
[64:31] the endless debate
inside of Wave,
[64:33] which would be
much more efficient.
[64:35] We could also build--
[64:36] We haven't done this
in the sample here--
[64:38] that if someone wanted
to go make a comment
[64:40] over on issue tracker,
[64:41] the robot would see that
and update the wave as well.
[64:45] And just like we did a search
through Twitter
[64:47] into a-a wave,
[64:49] we could also have the robot
start a new wave of bugs
[64:51] and just pull in all of the bugs
assigned to you
[64:53] so that you could track them
from within a wave.
[64:56] It's remarkable--thank you--
how much more effective
[64:59] this sort of thing
makes you.
[65:02] Okay.
That's extensions for you.
[65:04] You guys feeling--
[65:06] Hannon: And I think that's
two of our Ps.
[65:07] Lars Rasmussen:
Those are two Ps.
[65:08] Are you guys
feeling inspired yet?
[65:10] Good. Yeah. Thank you.
[applause]
[65:13] Thank you.
[65:17] Okay, let's talk a little bit
about the protocols
[65:19] and algorithms,
um, underlying Wave.
[65:22] So we want Wave, as Stephanie
said in the beginning,
[65:24] to be an open system.
[65:26] Obviously,
it's an enormous reason
[65:28] behind the success of email
that it's an open protocol.
[65:31] Anyone can build
an email system.
[65:33] Anyone can email
with each other
[65:34] regardless of where they got
their accounts from.
[65:37] We want Wave
to work the same way.
[65:41] And so we've designed
the algorithms--
[65:44] we've designed the protocol
to, um, uh, to support
[65:47] what we call "federation."
[65:49] Which means
that any organization
[65:50] could build their own
Wave system,
[65:53] give accounts to their users
even in competition with Google,
[65:56] and then the system
will still ensure
[65:58] that we can share waves
with each other
[66:00] across these boundaries.
[66:02] And we want to--
we want to first show you
[66:05] how that's going to look.
[66:06] And then we'll talk
a little bit
[66:07] about how far along
we are with that.
[66:10] So let me--so this is very much
work in progress.
[66:13] Everything we've shown you
is work in progress.
[66:16] I'm going to sign in
to, um, a different version
[66:19] of the system that sits
inside our corporate network
[66:23] that has an open port on it
for this sort of federation.
[66:26] And we're going to imagine
two separate wave systems.
[66:30] One is the one
Google has built
[66:31] that you've been looking at
all morning.
[66:34] The other one
is from Acme Wave,
[66:37] which you'll see
over on Stephanie's screen.
[66:39] They have built
a separate system.
[66:40] They're actually
giving out accounts
[66:42] in competition with Google.
[66:43] You'll realize that their client
looks very similar to ours.
[66:47] That's because we're intending
to open source
[66:49] the lion's share of the code
that we used to build our system
[66:53] so that organizations
can get started quickly.
[66:56] And that's how Acme Wave
built their system.
[66:59] So I'll start a wave
over on my account here.
[67:03] And I will say "Project.
[67:05] You want to work with me
on that thing?"
[67:11] And then I will add--
what's your account
[67:13] over on Acme Wave?
[67:15] Hannon: It's Stephanie.
Lars Rasmussen: Stephanie.
[67:18] Stephanie on Acme Wave.
[67:19] So Stephanie momentarily
has her account--
[67:21] Hannon: Actually, it's Steph.
Lars Rasmussen: There we go.
[67:23] Hannon: Sorry.
[67:24] Lars Rasmussen:
Stephanie is now a user
[67:25] over on Acme Wave.
[67:26] And I'm going to add her
to the wave.
[67:30] Hannon: So I'm going
to open up the wave.
[67:32] And he says, "You want to work
with me on that thing?"
[67:34] And I said, "I think the guys
over at Initech can help too."
[67:40] Lars Rasmussen: [laughs]
And so...
[67:43] And so even though Steph and I
have accounts
[67:45] on different wave systems,
[67:46] you still get that live
[67:48] character by character
interaction.
[67:50] The way it works is that
from our two clients,
[67:52] these fine-grained
operations
[67:54] travel to our respective
servers,
[67:56] then it crosses over
and goes back up to our client.
[68:00] And all of the liveness
and concurrency control
[68:02] and live--um, sorry,
and real-time resolution
[68:05] of conflicts happen
in an algorithm
[68:07] that supports this sort
of federation.
[68:09] Let's bring a third wave system
into the system.
[68:12] So we have a couple of friends,
Peter and Milton,
[68:15] that work for a company
called Initech.
[68:17] They have chosen to run
their own wave server
[68:19] in their server closet.
[68:21] These guys didn't take
our code.
[68:23] Milton is the kind of engineer
who prefers building stuff
[68:26] from scratch.
[68:29] Hannon: I'm not sure
I want to show this, Lars.
[68:31] Lars Rasmussen: Oh, come on.
You show it.
[68:33] I'm going to add Peter
and I'm going to add Milton.
[68:35] Why don't you want me
to show it?
[68:37] Hannon: I'm afraid this crowd
might like their UI
[68:39] better than ours
and it would break my heart.
[68:41] Lars Rasmussen:
Don't break her heart.
[68:44] [cheers and applause]
[68:51] Do you have the wave?
Do you have the wave?
[68:56] Hannon: No, 'cause--
Lars Rasmussen: Hmm?
[68:58] Hannon: Just make
another edit.
[69:01] So now I have the wave.
[69:03] Lars Rasmussen: So she opens--
Hannon: And if I go into it...
[69:08] [cheers and applause]
[69:12] Lars Rasmussen: Thank you.
[69:15] Hannon: Now I want to show you
an important principle
[69:17] of--an important feature
of the protocol.
[69:21] So I go back to Acme Wave
[69:23] and I'm going to make
a private reply
[69:24] just like you saw earlier
in the demo.
[69:26] But I'm going to add everyone
except Lars.
[69:29] So I'll say, "What do you think
of that Google guy?"
[69:35] So I'll add all of my friends
Peter and Milton.
[69:40] Even though this wave
is owned at Google
[69:43] and there's copies on Acme Wave
and Initech servers,
[69:46] this private reply
is never seen by Google
[69:50] and cannot be discovered
by Lars in any way.
[69:53] In fact, if Peter and Milton
made a private reply
[69:56] between themselves,
[69:58] that wave would never leave
their server closet.
[70:01] [applause]
[70:06] Lars Rasmussen: Thank you.
[70:07] Hannon: And I just want
to go back over to Milton
[70:09] for a second.
[70:10] You can see the private reply
came in there as well.
[70:13] Lars Rasmussen: Okay,
so let me just say this,
[70:15] um, federation...
[70:17] that was hard.
[70:19] So we're building this thing
[70:20] with live concurrent editing,
and chatting,
[70:22] and instant messaging,
and email, and pictures,
[70:23] and all that stuff.
[70:25] And then we throw federation
into the mix,
[70:27] which vastly
complicates things.
[70:30] It would be so much easier,
frankly,
[70:31] from an engineering
point of view.
[70:33] If we could just keep this
proprietary,
[70:35] then we'd control
all the servers,
[70:36] we'd control
all the update schedules,
[70:38] and so on.
[70:39] But we think it's worth
the effort--
[70:42] and we hope you guys
will help us with this.
[70:44] We think the world
will be a much better place
[70:46] if this is an open system
that everyone can build
[70:48] wave services with it.
[70:50] And so--thank you.
[70:52] [applause]
[70:53] Thank you.
[70:55] [applause]
[70:59] And so let me tell you,
um, where we're at with it.
[71:01] So later today,
there's a web site--
[71:03] I'll show you the URL later--
that's going to launch,
[71:06] which will have--
it's a very early draft
[71:08] of this protocol.
[71:10] It'll have, I think,
four whitepapers
[71:12] describing
how the system works.
[71:15] It's going to have,
of course,
[71:16] a public discussion forum
[71:17] so that we can start debating
how this hopefully bright future
[71:21] of Wave will look.
[71:23] And then
like I said, later,
[71:25] we're going to open source
the lion's share of our code,
[71:28] which will serve both as
a reference implementation
[71:31] of the protocol,
[71:32] but also essentially
a production ready system
[71:34] like you saw Acme Wave do.
[71:36] I'm obviously vastly
simplifying it here.
[71:38] But essentially,
you could take that code,
[71:41] you could put it on top
of your own database,
[71:42] and you would have
a simple wave server
[71:44] and you would be up
and running.
[71:47] Okay.
So that's federation.
[71:53] [laughs]
[71:54] Hannon: I'm excited
about our next demo.
[71:55] Lars Rasmussen: The next demo
is very, very nice.
[71:58] This is something, um,
to end off our demo with.
[72:02] It's something,
uh, a friend of ours
[72:04] on the Google research team
has been building
[72:06] over the past month.
[72:08] I saw it myself the first time
just a few days ago.
[72:11] Um, and it blew me away.
[72:12] So, um, let's see.
[72:14] I'm going to make sure
I'm on the right system here.
[72:16] I'm back on the sandbox.
[72:18] So again, we've been doing
this demo
[72:19] on a system where we'll get
you guys accounts.
[72:22] Now, Stephanie is going
to log into, um, an account
[72:26] of one of our colleagues,
Alexi.
[72:28] And then I'm going to start
a new wave.
[72:30] I want to make sure
you guys can see
[72:31] what we're typing.
[72:33] I'm making this
a little bigger like this.
[72:36] Do you make your font
bigger there, Steph?
[72:38] Hannon: Yeah,
I was going to wait
[72:40] till you started
the wave.
[72:42] Lars Rasmussen: And then
I'll start a new wave here.
[72:44] And I'll add Alexi,
one of our colleagues.
[72:47] And then I'll add
my all-time favorite robot
[72:51] called Rosy.
[72:54] Yes.
[72:55] So, um,
Alexi is from France.
[72:58] His English
is not terribly good.
[73:01] Hannon: Aww!
[73:03] Lars Rasmussen: For the purposes
of this demo.
[73:05] [laughter]
[73:07] And Rosy is a robot
that very kindly translates
[73:11] what I'm typing.
[73:13] "Hello, world!"
[73:16] [applause]
[73:18] "What do you think
[73:20] "of this demo--
[73:24] of this demo?"
[73:32] And now Alexi's typing
in France.
[73:34] And I get to see him saying,
"Ah, yes...
[73:37] since new--we are in
can--use--used--"
[73:41] Translates word by word,
character by character
[73:43] as he's typing.
[73:45] Rosy speaks, I believe,
40 languages.
[73:47] She can translate
between any pair of them.
[73:50] Um, she's quite the thing.
[73:54] Okay.
That finishes our demo.
[73:57] Oh, thank you.
[73:58] [cheers and applause]
Thank you. Thank you.
[74:03] Thank you.
Thank you. Thank you.
[74:09] Thank you.
[74:13] Thank you.
Thank you. Thank you. Thank you.
[74:15] [cheers and applause]
Thank you. Thank you.
[74:18] Hannon: I think they like it.
Lars Rasmussen: They like it.
[74:22] You guys like it? Okay.
Thank you.
[74:27] Hannon: Thank you.
Wow. Thank you. [laughs]
[74:31] [cheers and applause]
Lars Rasmussen: Thank you.
[74:36] Thank you.
[whistling and cheers]
[74:39] Hannon: They have a lot
of skills.
[74:41] [applause]
[74:46] I think...
Lars Rasmussen: Thank you.
[74:47] Hannon: If they really
liked it...
[74:51] [man shouting indistinctly]
[74:52] If you guys--you guys
really liked it,
[74:54] you could do a wave.
[74:56] Lars Rasmussen: So, so, so--
Hannon: Anyone?
[74:58] It's time to do the wave.
Lars Rasmussen: So--
[75:00] So, um,
what do you guys think?
[75:03] Okay. [laughs]
[75:05] So just--
Hannon: Thank you for filming.
[75:07] Lars Rasmussen:
Just to summarize,
[75:08] um, what we like to think
we've built here
[75:11] is really quite a simple
communication object
[75:13] called a wave.
[75:15] And we've showed
how you can use it
[75:16] for quite a lot
of different types
[75:18] of communication
and collaboration.
[75:20] We showed you how plain vanilla
email-type conversations
[75:23] could be done.
[75:25] We showed you how instant
messaging conversations
[75:27] could be done.
[75:28] We showed you how easy it is
to share photos
[75:29] and other rich media types
with it.
[75:31] We introduced a platform
that we're hoping you guys
[75:34] will pick up
[75:35] that will let you build things
like blogging sites,
[75:37] discussion groups,
uh, letting your users
[75:40] discuss images
on your web site.
[75:42] With the editing
functionality,
[75:43] you can see you can build
Wiki-like sites
[75:45] with that as well.
[75:46] We showed you
how you can use waves
[75:48] to collaboratively
edit documents.
[75:50] We showed you a rich set
of extension APIs
[75:53] that could let you build
everything from games,
[75:56] through collaborative
applications inside a wave,
[75:59] through integrations with other
communication systems.
[76:02] We showed you Twitter.
[76:03] We're hoping you guys
will build gateways
[76:05] from Wave to email,
to Facebook,
[76:08] to instant messaging,
and so on.
[76:10] We showed you how you can use
these extension APIs
[76:14] to also integrate waves
into work flows.
[76:18] Whew. Okay.
[76:22] And now...
[76:24] Hannon:
Just going to bring up...
[76:25] Lars Rasmussen:
For the administrativia
[76:27] at the end,
[76:28] I want to--
I want to just point out--
[76:32] I forgot that earlier
[76:33] that we have three
breakout sessions
[76:35] that I don't believe has been
in the program so far.
[76:39] Um, the first one at noon
is about, um, the API.
[76:44] If you can only come to one
of our breakout sessions,
[76:46] please make it that one.
[76:49] The next one is a little
run-through
[76:50] of some of the more
exciting pieces of technology
[76:52] under the hood.
[76:54] We're going to show you
from the top of the--
[76:56] top of the stack how our amazing
spell-checker works,
[76:59] how the rich text editor
in the browser works,
[77:03] and the algorithms
that we used underneath
[77:04] to do all
the concurrency, control,
[77:06] and conflict resolution
and so on.
[77:09] And then at 2:30,
[77:10] one of our client team
tech leads
[77:13] are going to explain
how we build
[77:16] the web application
with the Google Web Toolkit,
[77:19] why we love it so much,
[77:21] and what some other
future plans are.
[77:24] We also have in Room B4
[77:26] from noon till 4:30
office hours
[77:28] where you guys can come talk
to the team in blue here.
[77:32] They love talking.
[77:36] And then I wanted
to show you,
[77:39] um, three important
URLs here.
[77:42] So for starters,
wave.google.com
[77:44] is going to be the home
of Google Wave
[77:47] when we launch it
later in the year.
[77:49] If you go there now
or when the site goes live
[77:52] in a little bit,
[77:53] um, there is
a sign-up form there
[77:55] where you can sign up
for notifications
[77:56] when we launch it.
[77:57] There's also going to be
a beautifully edited video
[78:01] of today's keynote.
[78:03] Um, the API site
is going to go live...
[78:06] man: Already live.
[78:07] Lars Rasmussen: The API site
is already live.
[78:09] No wonder I couldn't--
couldn't get a connection
[78:11] to my mobile phone before.
[78:13] It's at
code.google.com/apis/wave.
[78:18] It's got the API.
It's got the documentation.
[78:21] It's got the code samples
we showed before.
[78:23] Actually, I should just mention
really quickly
[78:25] the bug--the--the issue
tracker integration
[78:28] we showed at the end,
[78:30] we have to cheat
ever slow slightly
[78:31] by using, uh, using
an internal API
[78:35] to the issue tracker.
[78:36] I think they're working
really hard
[78:37] making APIs available.
[78:39] So that particular sample
is not going to be there
[78:41] for--for a wee while.
[78:43] Lastly,
at waveprotocol.org,
[78:46] you'll find
the protocol draft,
[78:48] the whitepapers,
the discussion forum,
[78:50] and so on if you guys
are interested
[78:52] in helping us,
um, build that wave
[78:55] to be an open system.
[78:57] Hannon: You should tell them
about the email.
[78:59] Lars Rasmussen: Yes.
[79:00] And the way you're going
to get an account
[79:02] is you'll receive an email
later today
[79:04] that explains where you can go
and sign up
[79:07] for an account,
[79:08] which you will get shortly.
[79:12] Okay. So, look, the last thing
I want to say,
[79:14] um, you can probably imagine
it felt kind of nice
[79:18] that you guys seemed to like
what we built.
[79:21] Um, one of the--
one of the best times
[79:23] in my professional life
[79:24] was after we launched
Google Maps back in 2005
[79:28] and developers started doing
all kinds of crazy things
[79:30] with Google Maps.
[79:32] I hope some of you
are here.
[79:33] This was even before
we had an API on Maps.
[79:36] We scrambled to put an API
on Maps.
[79:38] And it's, uh, it's--
it's become very popular
[79:41] and it's a huge driving force
of success.
[79:45] We learned
a very important lesson
[79:47] that--that you guys,
developers,
[79:48] are incredibly important
to the success
[79:51] of the kind of products
that we build.
[79:53] And so I can't wait
to see what you guys
[79:56] are gonna come up with.
[79:58] Um, please, please, please,
check it out.
[80:00] Build cool stuff.
Surprise us.
[80:02] I just can't wait to see
what you come up with.
[80:06] Thank you very much.
[80:07] [cheers and applause]