The (Google) Wave Is Here! (Full Review Inside, And It's LONG)

Discussion in 'BlackHat Lounge' started by RoadToMillions, Oct 2, 2009.

  1. RoadToMillions

    RoadToMillions BANNED BANNED

    Sep 27, 2009
    Likes Received:
    I warned you it was long.

    Many of the underlying standards that define modern e-mail technology were originally developed in the 1980s. Almost 30 years after the birth of SMTP, e-mail is still the dominant Internet communication medium despite its significant limitations and increasingly anachronistic design. Supplementary services like instant messaging and microblogging have emerged to fill in some of the gaps, but virtually no attempts have been made to build a holistic replacement for e-mail. Our most important day-to-day messaging infrastructure remains intractably mired in antiquity.
    To advance the current state of Internet communication to the next level, it will take a truly audacious vision and highly sophisticated technology. The engineers at Google seem to have both.

    At the Google I/O conference earlier this year, the search giant unveiled a new prototype service called Wave, which aims to deliver a unified platform for next-generation messaging. The prototype, which is currently accessible to a limited number of users and is scheduled to open up for broader testing soon, is an intriguing communication tool that also provides compelling insight into the future of the Web.

    What is Wave

    The scope of Google's Wave project is broad, which makes it difficult to define concisely. It brings together elements of instant messaging, e-mail, collaborative rich document editing, and generic support for third-party Web services in a single seamless communication medium that is more flexible than any of those things individually. On a technical level, it is a messaging platform that consists of a protocol, a Web service, a set of standard extension APIs, and an open-source concurrency framework.

    Communication within the Wave service is organized in a structure that is a bit like ad-hoc forum threads. Each top-level conversation contains groups of messages that are sort of like subthreads. The conversations are referred to as "waves" and the subthreads are called "wavelets". Individual messages, which are called "blips", are the smallest discrete conversational unit of a wave. The distinction between Wave—the service—and "wave"—the conversational unit—is significant, so keep an eye on the capitalization.

    In e-mail terms, a wave is like a group of messages tied to a specific subject line. A wavelet is like a single thread of messages that that are sent as replies to that subject, and a blip is like an individual e-mail. It's important to note that these concepts are not totally analogous, as Wave reflects a distinctly different messaging paradigm and doesn't totally conform with the e-mail model. We will explore some of the differences shortly.

    When a user starts a wave, they can invite any number of other users to join the discussion. Participants can post individual messages, edit shared content, and insert rich media such as images or Google Map widgets. Wave is designed to facilitate real-time concurrent messaging, meaning that content appears to all users immediately and multiple users can edit and submit content at the same time.

    When a user starts typing a message, the individual text characters of the message will appear to other participants as the user is typing. It will eventually be possible to selectively disable real-time transmission for individual blips by enabling a "draft" mode which is not yet available in Google's current prototype. Although messages are displayed immediately to participants who are actively viewing the wave, the messages will still be available later to non-active participants. This means that Wave can seamlessly be used for both real-time communication like instant messaging and for delayed communication like e-mail.

    Short blips look and feel a lot like instant messages. In Google's user interface, they are displayed as a short block of text alongside the name of the sender and their account profile icon. Users can reply to individual blips to start a wavelet thread. In Google's interface, the threads are displayed inline with nesting and indentation to indicate their hierarchical structure.

    The reason why I explicitly mention Google's interface is because the service will eventually support third-party client and server systems which could potentially present message content in radically different ways. Google's implementation will help define a lot of the baseline visual idioms for representing Wave concepts, but there are a lot of possible interpretations and there is still room for improving on Google's user interface even though it's already very good.

    In addition to being able to reply to blips, users can also edit blips, including ones posted by other participants. This level of mutability is one of the most profound advantages that Wave offers over conventional e-mail. On the basis of individual blips, it makes it easy to annotate, correct, or elaborate on messages posted by other users. More significant, however, is the ability to restructure the entire conversation. This brings some wiki-like characteristics to the Wave communication model.

    When consensus is reached on a topic that is under discussion, for example, you could just erase the related wavelets and replace them with a single block of text that describes the outcome of the discussion. This kind of refactoring makes it possible to streamline discussions and throw away noise that is no longer needed.

    But what if someone arrives late to the thread and wants to see how the decision was reached? Or what if you have a compelling reason to want to go back and look at the decision-making process? Fortunately, Wave has a built-in revision history mechanism that records individual messaging operations as they are being performed.

    This means that you can roll back the state of the Wave and view it as it was at any time during the discussion. Google provides a really convenient slider widget that you can drag to move forward or backward in the timeline. There is also a "Playback" button that will start at the beginning and show you each operation throughout the history of the wave as if you are watching it play out in real time. This revision history gives you the freedom to delete messages and move them around as needed without having to worry about losing important information.

    Wave Sandbox

    During the Google I/O event, the company launched the Wave Sandbox, which is a live demo version of the service. Attendees of Google I/O and a select assortment of other interested parties have been given access to the Sandbox so that they can help test the code and begin developing tools that integrate with the service.

    Users who are testing the Sandbox are automatically included in a special group list that is primarily intended to facilitate discussion and collaboration between testers. It is generating an enormous amount of message traffic, which has proved to be very valuable for testing purposes. This traffic has illuminated some performance challenges and usability strengths that become visible in heavy usage scenarios. While interacting with very large waves that have many participants and a lot of content, I experience sluggishness and notice high CPU consumption. Generally speaking, however, the service is quite responsive and functions well in most regular usage scenarios.

    Despite some of the occasional performance problems and the lack of robustness (the Wave client system in the browser can actually "crash" in some rare cases, necessitating a page reload), the Sandbox is already very impressive on several different levels. The user interface is extremely sophisticated and outclasses that of Gmail and other Google services. It is built with the Google Web Toolkit (GWT), an open source framework that allows developers to build dynamic and interactive Web applications with the Java programming language.

    The Wave Sandbox displays your content in panes within the window; the default layout has three columns. The first column is split vertically between the folder navigation and contact lists. The middle column has a message pane that shows the waves that are in the currently selected folder. These are displayed as summaries, with a subject line, an unread blip count, and icons that indicate who the other participants are. It also has a built-in search box that you can use to filter your waves. The third column displays the content of the active wave. It shows the current messages and has buttons for performing certain actions on the wave, like replying to the selected message or activating the timeline slider.

    The panes all have a minimize button that can be used to shrink them down into the top toolbar area. When a pane is minimized, you can click its dropdown button to get quick access to its contents without having to restore it to its standard position. As you minimize frames, other frames will grow to use the extra space. The wave display frame has a maximize button that you can use to expand it all the way, automatically minimizing other frames. You can interactively resize the frames by clicking and dragging the space between them.

    One of the most impressive usability features is support for infinite scrolling. Instead of paging through the inbox and viewing a certain number of wave subject lines at a time, I can just drag the scroller down and it will automatically load more as I go. I had to wait for it to catch up sometimes when I went too fast, but it generally worked well. I was able to scroll through over a thousand wave headings with relative ease.

    Another nice feature is that the wave list supports convenient multiselection. You can click one wave item, hold shift, and then click one somewhere else in the list and it will highlight all of the items in between. Then you can drag those highlighted messages to a folder, or do whatever you want with them. These aspects of the user interface contribute to a really strong, desktop-like experience.

    Internet Explorer rejected

    In September, Google released Chrome Frame, a plugin for Internet Explorer that makes it possible for Microsoft's browser to use Chrome's rendering engine. Microsoft wasn't happy about this sudden but inevitable betrayal. Google later revealed that Wave was one of the catalysts that compelled them to launch the Chrome Frame project.

    The developers behind the Wave project struggled to make Wave work properly in Microsoft's browsers, but eventually determined that the effort was futile. Internet Explorer's mediocre JavaScript engine and lack of support for emerging standards simply made the browser impossible to accommodate. In order to use Wave, Internet Explorer users will need to install Chrome Frame.

    Microsoft is the only major browser vendor that has failed to build a next-generation high-performance JavaScript engine. Mozilla's TraceMonkey, Chrome's V8, and Apple's Nitro all offer extremely fast JavaScript execution and are getting faster with each release. These browser vendors are competing to deliver near-native JavaScript performance in an effort to empower the development of significantly more sophisticated Web applications.

    Internet Explorer apologists and Microsoft's marketing department have largely responded to this trend by denying the value and relevance of high-performance JavaScript. The performance of the scripting engine has little discernible impact on today's webpages, they say, arguing that a faster JavaScript engine would offer no practical value to end users. The problem with this argument is that it ignores the opportunities that faster JavaScript engines will provide for making Web applications that are considerably more powerful than any that exist today. In some ways, Wave proves this by demonstrating what can be made possible when developers push the limits of emerging standards and refuse to be held back by Internet Explorer's inadequacies.

    When Internet Explorer users try to log into Wave, they will be presented with a banner informing them that their browser is unsupported. The message will encourage users to install Chrome Frame or one of the supported browsers. This is a very bold move by Google. On one hand, it could potentially impede mainstream adoption of Wave. But on the other hand, it could give a lot of Internet Explorer users a reason to adopt a better browser—one with much stronger support for emerging standards.

    Wave's dependence on the latest and greatest browser features are a characteristic that makes the service particularly interesting to Web developers. It sheds light on what the Web would look like without Internet Explorer and it provides an early glimpse at the next generation of Web applications—massively concurrent, highly interactive, and deeply collaborative.

    Concurrency and federation

    Wave is designed to operate as a decentralized communication network. Individuals and organizations will run their own Wave-compatible servers which will all interoperate through a federated messaging protocol. Although Google has developed the underlying technology, the company intends to open it up entirely to the community and make it a vendor-neutral standard. There will be multiple competing implementations, much like there are today for e-mail services, and it will be possible to use and operate independent Wave services without having to rely on Google.

    This highly open model greatly increases Wave's adoption potential and is absolutely essential to Google's strategy for making Wave a compelling replacement for e-mail. The complexity of the service, however, is one of the potential stumbling blocks that will pose challenge for third-party implementors. Google is opening the source code of several critical components of the Wave stack in order to reduce the barriers to creating Wave-compatible server software.

    One of the chief goals behind Wave's design was to achieve support for seamless concurrent editing with a level of responsiveness and conflict resilience that beats other mainstream collaborative editing tools. The synchronization model also has to be highly scalable and generic enough to handle the wide range of dynamic content types that Wave supports above and beyond mere rich text. To meet those requirements, Google's developers decided to build Wave's concurrency framework around the principle of Operational Transformation (OT).

    We first looked at OT back in July when Google began releasing Wave source code. The purpose of using OT is to combine changes that are being made simultaneously by multiple users in a manner that preserves the integrity of the document.

    Consider a collaborative editing system in which multiple users are modifying the same block of text at the same time and the changes are being transmitted across the wire in the form of instructions to perform operations at specific indices in the text buffer. Problems arise when you receive a change in a document that you have already modified locally. The incoming change could potentially be applied incorrectly if your local change has modified the text in a way that invalidates the index data of the incoming change.

    To make the example more specific, consider a situation where you are typing one word while your friend is typing a word in a later part of the document. The word that you have typed has increased the position index of all of the characters that follow it in the buffer. This means that your friend's word will be inserted in the wrong place because the instruction transmitted across the wire doesn't account for the change that you have made and consequently supplies an incorrect index.

    OT primarily entails programmatically adjusting the operations and indices while accounting for local changes so that the text mutations can be applied correctly. This makes it possible to achieve convergence between all of the active instances of the document. The original OT algorithm, called dOPT, was developed by researchers Ellis and Gibbs and was used in a collaborative editing tool called GROVE. This editor used optimistic replication to boost responsiveness, allowing the user's changes to be applied instantly to the local instance.

    In GROVE, each individual client hosts its own representation of the document state and propagates changes to other clients. When changes are received, they are transformed against the local document. Later research improved considerably on this model. A particularly significant advancement in practical OT research was made when the Jupiter collaboration system was developed at Xerox PARC. Jupiter provided a high-level widget toolkit and windowing system that was designed to facilitate concurrent manipulation of user interfaces and editable documents.

    Jupiter introduced a novel approach to OT architecture, one in which communication between clients is mediated through a server that maintains the state of the clients and applies the transforms. Google Wave is built largely on the Jupiter model. Wave uses the client/server approach like Jupiter, but will only allow an individual client to send new operations when the server has finished applying and propagating the operations already received from that client. This improves scalability and simplifies transformation.

    When a user manipulates the content of a wave, the changes will be applied locally right away before before being transmitted to the server and propagated to other participants. Each operation has an associated wavelet revision ID which will also be passed between the clients and servers. When the server propagates a change to clients, it will supply the operation, revision ID, and a hash value that is like a thumbprint of the operational history of the wavelet. The hash allows clients to validate that they are properly synchronized with the server and regain synchronization in the event that communication fails.

    Operations are performed on XML documents that are contained in a wavelet's blips. In addition to supporting basic text mutation, Wave also has operations for applying annotations to segments of the document. These are used to apply formatting and other characteristics.

    As we've already explained, Wave introduces a federated communication model that allows state information to be propagated across multiple servers—called Wave providers—to facilitate interoperability and enable self-hosting. The Wave federation protocol, which is built on top of the XML-based XMPP messaging protocol, is open and fully doccumented by Google.

    The company has also published the source code of a prototype Wave Federation server written in Java that implements the protocool. The code is made available under the terms of the Apache license and can be downloaded from a version control repository hosted by Google. You can compile the code and run it to host your own Wave server. At the present time, however, the prototype server only provides a trivial text-based interface. I tested this on my desktop computer at the command line.

    Google intends for this prototype to eventually become a production-quality reference implementation that can be used as the basis for third-party Wave servers. Wave requires an extremely high level of consistency between OT implementations in order to work properly. By making the source code of the reference implementation available, Google can provide a universal standard for everyone to use and test against. This will reduce the potential for rapid proliferation of third-party OT implementations that deviate from the specification in subtle but detrimental ways.


    One of Wave's greatest strengths is its potential for extensibility. Third-party developers can create automated agents called robots that programmatically manipulate conversations. This capability is important because it will make it possible to integrate Wave with a wide range of external Web services.

    Robots are treated just like regular participants in a wave. They have the ability to add, remove, and manipulate content. Robots can be programmed to automatically perform certain actions in response to events that take place in the wave. For example, you can have a robot automatically modify text based on certain parameters as wave participants are typing. Wave robots are roughly analogous to IRC bots, but they have greater utility because Wave's editing model allows them to interact with the conversation in a much richer way.

    One of the most impressive examples demonstrated by Google is Rosy Etta, a robot that leverages the Google Translate service to perform automatic text translation on messages in a wave as they are being typed. There is also a nifty Wave robot that will allow users to interact with Twitter.

    Robots are independent of the Wave server architecture and run on remote systems. To use a robot, you simply invite it to the conversation just like any other participant. At the present time, the Wave Sandbox only works with robots that are hosted on Google App Engine. This will change in the future, however, and it will be possible for developers to run Wave robots on conventional servers.

    Robots interact with the Wave service through the Wave Robot Protocol, which uses HTTP requests. Google encourages developers to refrain from using the protocol directly because it is still under active development and is subject to change. Google plans to eventually document the protocol and make it more accessible to third-party developers when it stabilizes. For now, developers who want to build their own robots can use the robot client libraries supplied by Google. These libraries are provided in Java and Python. I tested the Python library, which is downloadablefrom a repository at the Google Code website.

    The basic principles behind Wave robot development are relatively simple. You can register callback functions that serve as handlers for specific events, such as when document content changes or when participants join and leave the wave. A list of supported events can be found in the events module of the robot client library.

    The library provides a means of performing operations on the contents of a wave. The robot can programmatically manipulate wavelets, document content, and annotations. The methods for performing these operations are defined in various classes in the ops module. Wave event callback functions receive a context parameter that provides access to the relevant wave objects including wavelets and blips.

    The robot concept is very compelling and will provide a powerful tool for exposing the functionality of third-party services within Wave. If Wave ever gains broad traction, it's likely that we will see many Web 2.0 companies integrating their own services with the Wave platform through bots in much the same way that many have embraced Twitter integration. Some of Google's demos provide insight into the opportunities that Wave will provide in this capacity. For example, they showed a prototype that allows Wave to be used as the backend for a real-time comment system on Blogger.


    Wave's extension system isn't just confined to automated content manipulation. The service also provides a gadget system that allows third-party developers to extend wave presentation by introducing new kinds of interactive rich content that can be embedded in messages. This will bring an enormous amount of flexibility to the Wave platform and will allow it to be used as the foundation for many different kinds of collaboration in addition to regular text communication.

    Gadgets are small, interactive Web applications that are built with HTML and JavaScript. The interesting thing about gadgets is that they take full advantage of Wave's concurrent editing model. Gadget state is seamlessly shared between all participants of a wave. When one user manipulates a gadget, the changes are reflected to all users. For example, a Google Maps gadget can be used to plop an embedded map into a conversation. When a user drags the map to scroll it's position, all users see the position change. When a user adds a marker to the map, the marker appears to all users.

    Gadgets can be used to bring relatively sophisticated concurrent applications into a wave. One of the most impressive demos is a full-blown graphical chess game. There is also one that embeds a small piano keyboard in the wave and will allow participants to hear the sound when someone hits one of the keys.

    The Wave gadget system is based on the OpenSocial gadget specification. Individual gadgets are written in XML documents that can contain HTML content. JavaScript is used to define the gadget's programming. To make a custom gadget that can take advantage of Wave's collaborative features, your gadget can access the universal state object through simple JavaScript functions. These are demonstrated in a tutorial at the Google Code web site.


    Wave represents an extraordinary technical achievement and delivers truly remarkable messaging capabilities. The potential implications of the project are enormous. Although the current prototype still has some limitations, it offers the most compelling alternative to e-mail that I have encountered.

    Despite my enthusiasm for Wave and the underlying technology, I think that there are still a lot of unanswered questions. It is yet not clear if Wave will be able to scale gracefully to accommodate a significantly larger number of users and conversations. The enormous complexity of the operational transformation technology could also prove to be an Achilles heel if it becomes too difficult to create independent implementations that interoperate well with Google's. Over time, Google's current testing efforts will help to answer these questions.

    The Wave Sandbox is providing insight into Wave's suitability under an increasingly heavy load, one that will continue to grow as Google opens up the program to more users. The early availability of the source code has also helped to stimulate interest in OT theory and is encouraging third-party developers to get involved. Wave is obviously a long-term project for Google, but the steps that they have taken so far are promising.

    The concepts embodied in Wave and the advancements it represents in the areas of concurrency, Web interfaces, intensive JavaScript, and next-generation Web standards are already changing the way that developers think about the Internet. Even if Wave never gains enough traction to become a tsunami, the project is already showing signs of success as a catalyst for accelerating our ascent towards the Internet of the future.

    Disclaimer: No, it's clearly not mine.
    • Thanks Thanks x 3
    Last edited: Oct 2, 2009
  2. blackmagiquellc

    blackmagiquellc BANNED BANNED

    Oct 30, 2008
    Likes Received:
    great review. I'll be inside soon as well and may have some projects building up to utilize wave's capabilities
  3. q3ick

    q3ick Regular Member

    Oct 27, 2008
    Likes Received:
    Full Time Student -- Working On My Masters In Busi
    Any one have an account im looking for an invite.

    Looks very promising.
  4. nirose

    nirose Senior Member

    Oct 24, 2008
    Likes Received:
    Man thats long. and i too want a invite if some can offer.
  5. multimedia

    multimedia Power Member

    Jun 22, 2009
    Likes Received:
    Serious BlackHatter
    My eyes aren't that strong to read such Long Script LOL :D..can someone break it up into pieces for people like me :ebay:??

  6. Sippy79

    Sippy79 Junior Member

    Feb 13, 2009
    Likes Received:

    Copy to word and you're done.
  7. abhi1

    abhi1 Power Member

    Feb 12, 2009
    Likes Received:
    Student, Webmaster
    Planet Earth
    Anyone got some extra invites? I'd want one too :p was suppose to get one from google but errr...
  8. ProtoProtoss

    ProtoProtoss Junior Member

    Mar 31, 2008
    Likes Received:
    if anyone gets an extra invite they don't need/want, let me know.
  9. ForeverNever

    ForeverNever Power Member

    Sep 17, 2008
    Likes Received:
    If anyone wants an invite just let me know I'll send you to a website where all you have to do is fill out a quick survey then you'll have your invite within 72 hours!

    ...oh wait this is bhw. ;)
  10. RoadToMillions

    RoadToMillions BANNED BANNED

    Sep 27, 2009
    Likes Received:
    The invite system isn't an invite system. 100,000 webmasters were invited, and they each received 8 invites. The invites, however, end up being "nominations" to be invited. Whether all invites eventually end up actually being "invites" is a different questions. To put it short, you may be invited, but that doesn't mean you're in. All I can tell you is to be very careful with what you write in the additional comments if you decide to sign up for Google Wave.