Embedding Wave

You can embed a Wave into a web page by adding some simple JavaScript code.
The Wave Embed API provides the WavePanel object which can hold a wave. You ask the WavePanel to use an HTML element on your web page to show a wave. The conversations on the wave will be visible in the WaveClient.

The steps to embed a wave on a web page are -

1. Load the Embed API JavaScript -

2. Create an HTML element that will contain the embedded wave -

3. Initialize the WavePanel object -

   	function initialize() {
   	       var wavePanel = new WavePanel('http://wave.google.com/a/wavesandbox.com/');
   	      	wavePanel.loadWave('wavesandbox.com!w' + waveID);
         		wavePanel.init(document.getElementById('waveframe'));
       	}
   	...
   	  
   	...
   

The wave is embedded in an iframe created inside the supplied HTML element.
The argument passed to the WavePanel is the Wave server instance. This value is used to set up the URLs used in the iframe created. For the early developer access, it must be http://wave.google.com/a/wavesandbox.com/ (including the trailing slash).

Extending Wave – Robots

Robots are server side programs that can act as participants in a Wave. They can edit content, add users, extract content and post it to an external service thus acting as gateways between a Wave and an external service such as Twitter.
A robot can respond to wave events such as wavelet_blip_created or wavelet_participants_changed. You can also specify a Cron schedule to ask the Wave to contact the robot at regular intervals.

You use a capabilities.xml file to specify what events a robot is interested in. An example from one of the samples is -

There are Python and Java libraries to help you write Robots.

In Java, you can extend AbstractRobotServlet class and implement processEvents(RobotMessageBundle events) to create a wave robot. This class translates the incoming Wave events in the form of HTTP requests into Java method calls, and communicates the changes made back to the wave.

You interact with the wave by using objects provided by the Wave Robot API.
The following lines of code add a new “blip” to a wave -

		Wavelet wavelet = events.getWavelet();
            	Blip blip = wavelet.appendBlip();
            	TextView textView = blip.getDocument();
            	textView.append("Hello World!");

It seems that the only way to deploy a robot at the moment is to deploy it to Google App Engine. Then you can add the robot to a wave using its Wave ID, which is its App Engine application ID followed by @appspot.com. This should change in near future and allow you to deploy the robot to any URL.

See the Robots Tutorial for a step by step guide.

Extending Wave – Gadgets

Gadgets are small programs that add functionality to the Google Wave client. They are written in JavaScript and HTML.
Gadgets use the wave object defined in http://wave-api.appspot.com/public/wave.js file to interact with the wave they are part of. Each gadget has a state object, which is a a map of key-value pairs. You can implement callbacks that are called by the wave whenever the gadget state or the list of participant changes.
The HTML and JavaScript making up the gadget are packaged as an XML file, and can be hosted anywhere on the internet.
See the Wave Gadgets tutorial for example code for a gadget that allows you to run an auction in a wave.

Resources -

Google Wave Robots: Creating a Robot
Google Wave API samples
Wave Gadgets Tutorial
Wave Robot API
Google Wave API forum

At Google I/O 2009, Google unveiled Wave. Wave is a new way of thinking about online conversations.

Consider the following situations -

1. You write a blog post. Somebody comes around and posts a really insightful comment. Now, you or the comment author want to convert that comment into an independent blog post.
2. You have been having a long email discussion with a colleague. Now you would like to invite another colleague to the same. She will need to know the context of the discussion and how it evolved.
3. You email a few colleagues a draft of an article for review. They all email their comments back to you. A lot of them are suggesting the same changes without realizing that they have already been addressed.

With the tools we are using today such as email, blogs, IM etc., all of the above will require some kind of tedious copy – paste, and manual tracking of the changes being made.

Is there a better way?

The Google Wave model tries to provide a better way by doing away with the distinction between email, IM and other forms of online conversations. In this model, an email conversation, a blog post with its comments or an auction with its bids, are just online conversations with multiple participants. At the data model level, all you have is a wave, and you can look at it in many different ways.

Multiple participants can edit a Wave at the same time, and the wave client can show the changes in real time. The changes made to a Wave are stored as a series of operations. You can play the changes back, or revert the Wave to an earlier version. At the data model level, constituents of the Wave form a tree structure. You can take a particular node and spin it into an independent Wave.

Wave providers (servers) give out Wave accounts, and are responsible for sharing Waves with the clients, as well as with other Wave servers. Wave servers communicate with each other using Google Wave Federation Protocol, which is an extension of XMPP protocol. Wave servers use cryptographic signatures and certificates, in addition to transport level encryption provided by XMPP, to authenticate among themselves.

Google Wave Operational Transformation

A key concept at the center of Google Wave is Operational Transformation (OT).

---

Credit: Wikipedia

Many participants can edit a Wave at the same time, and they can see each other’s changes as they are made. These attributes, concurrent modification and low latency updates, are implemented based on OT.
OT is a framework for concurrency control. The document being edited is replicated at all sites. All editing actions are stored as operations that are propagated across all clients, local and remote. Concurrent edits are transformed by the server before being applied and the transformed operations are communicated to all clients. This is very similar to how version control systems like CVS manage merging of simultaneous edits of a document.

From the Google Wave Operational Transformation whitepaper -

Wave OT modifies the basic theory of OT by requiring the client to wait for acknowledgment from the server before sending more operations. When a server acknowledges a client’s operation, it means the server has transformed the client’s operation, applied it to the server’s copy of the Wavelet and broadcasted the transformed operation to all other connected clients. Whilst the client is waiting for the acknowledgment, it caches operations produced locally and sends them in bulk later.

For more technical details on these topics, see Operational transformation, and Google Wave Operational Transformation.

Google Wave Data Model

A Wave is made up of Wavelets. Each wavelet has a unique id within its wave. The Wavelet contains a list of participants and a set of documents. A document in a wavelet has a unique id within its wavelet. It is composed of an XML document, and a set of annotations. Some of these annotations specify the styling of the text content of the document.
Concurrency control and operational transformation are applied at the level of Wavelets. A particular wave user may only have access to a subset of the wavelets in that wave.

The state of a wavelet is defined entirely by an ordered sequence of operations that have been applied to it. Wave clients send these operations to the server to communicate changes to the underlying document, and the server propagates these operations (after a transformation, if required) to other clients and other servers participating in the wave.

Resources –
Google Wave Data Model and Client-Server protocol
Google Wave Federation Architecture
Operational transformation
Wave Protocol forum
Google Wave Developer Blog

In the next blog post on this subject, we will look at different ways of developing with Google Wave.