Archive for the ‘Wave’ Category

Co-editing and conversation

September 29, 2010

I found out today that Microsoft has finally added live co-editing to Word.  In Word 2010, you can have several people working in the same document simultaneously, seeing each other’s edits live as you go.

On the one hand, this is a useful and interesting feature.  I confess, I’d be more impressed if we hadn’t implemented more or less exactly this functionality at one of my earlier startups (Buzzpad) all the way back in 2002; I’m a little distressed by the fact that it’s taken MS this long to catch on.  But be that as it may, it’s still useful.

That said, I suspect that the process is going to turn out to be a bit weak.  (Caveat: I haven’t played with it yet, so I’m going by what the above post says.)  The reason is that they appear to have failed to think about the conversational nature of the interaction.

The thing is, when three of us are co-editing a document, we’re not doing so in isolation.  The co-editing is, usually, an interactive process, where each of us is reviewing each other’s changes, commenting on and tweaking them, and generally bouncing ideas off each other.  Sure, we can each edit in our own little silos, but that’s nowhere near as interesting and useful as a more interactive experience.

So we need to have a conversation as part of this.  As currently constituted, it looks like we need to do that out-of-band.  Microsoft would probably recommend opening up a Messenger conversation for it, and that works, but it’s not a great solution: it loses the document’s context, and the conversation is not itself preserved with the document, so it’s harder to go back later and reconstruct why you made the decisions you did.  As it stands, I suspect that I’ll wind up horribly abusing Word’s comment features to hold in-line conversations.

Moreover, this doesn’t do enough for the asynchronous side of the conversation.  In practice, we’ll usually be editing this document for a while; when I go away and come back, I want to clearly see the changes.  Moreover, I want to see the conversations that led up to those changes, so I can understand them properly.  You can get a bit of this with some of Word’s other features, but it doesn’t look well-integrated.

My guess is that MS decided to finally implement this capability because Wave scared them, and I have to say that I’m disappointed that they didn’t really learn from Wave: this is a comparatively naive-looking version of co-browsing.  The Wave notion, of a root blip (typically the document you’re co-editing) with deep conversations both embedded inside it and attached as later blips, takes the conversational side of co-editing much more seriously.  And the ability to quickly review all changes — both new conversation and edits to the blips — makes asynchronous conversation work pretty nicely.

So points to MS for trying, but it’s still pretty weak.  I hope they’ll keep evolving it in better directions, but I suspect that’ll only happen if the open-source Wave project continues to give them a good fright.

How about you?  Do you think you’d use Word’s new co-editing capability?  Is there anything that would make it better for you?

Wave isn’t as dead as you might think

September 15, 2010

A month or so ago (while I was off on vacation), Google Wave quite publicly failed.  There was much hubbub about that, including my own analysis of what they did wrong.  What has gotten a lot less press is that this is probably the best thing that could have happened to the project.

A couple of weeks ago, Google announced on the Wave Blog that they would be producing “Wave in a Box”.  Basically, they already had made moves towards an open-source version of the server, the FedOne project; however, FedOne was competing with Google’s own product, so it was always a bit second-class.  Now, they’ll be beefing that project up, adding some of the UI power, as well as key features like gadgets and robots, so that the open-source version is at least roughly comparable with what Google themselves had produced, if not as full-featured.

IMO, this is great news — arguably better than if Google had continued the project themselves.  Wave had a lot of problems, but so long as the main implementation was closed-source and controlled tightly by Google it was subject to everything from staffing limitations to Google’s own biases about how things should work.  Now, the open-source version has the potential to let the proverbial thousand flowers bloom — it allows the open-source community to experiment, and figure out what really works in the wild.

Things I’m personally hoping will eventually evolve out of this:

  • External Identity Integration.  This was the biggest single failing of Google Wave, and the biggest roadblock to adoption.  Put frankly, it sucks to have to come up with a separate “Google identity” to use the system.  The open-source version should move aggressively towards a pluggable identity system, with different modules for different needs.  In the wild, it should allow you to authenticate using OpenID or Facebook Connect.  In a corporate environment, it should allow you to integrate using Active Directory.  (The latter alone has the potential to turn this into a far more useful business tool.)
  • Lighter-weight UI.  Google Wave was a very clever idea, but it got way out of hand in its ambitions.  One of the key impediments to adoption was the incredibly complex, sophisticated, slow, bulky client.  Frankly, everything I’ve seen leads me to believe that much of the weight comes from what have proven to be misfeatures: in particular, the customized scrollbar (which is kind of neat, but not obviously better than the scrollbars that the rest of the world uses) and the as-you-type synchronization (which is mildly useful, but which annoys more users than it helps).  So a UI that loses a few of those flashy features, but which loads and runs faster, would be welcomed by most people.
  • IE Support.  Closely related to the above, really — a lighter client would be less demanding on the browser.  I confess, this matters more to me than to most folks, precisely because I want to use Wave in my business, and the simple reality is that most people here use IE.  I don’t expect IE6 support — but having the thing work with IE8 would be a huge plus, and IE9 is almost a no-brainer, now that Internet Explorer is looking to stop sucking so much.
  • Mobile Support.  With everything centered on Google, this was hard.  But if I can create my own Wave site?  Seriously, the first thing I want is a decent mobile client — light-weight, not as full-featured, but enough to let me participate in the conversation from a small screen.  And in principle, there isn’t much preventing me from doing so.
  • A Real Ecosystem.  Google claimed from the beginning that they were trying to create a whole new platform for Internet communications, but shot themselves in the foot by putting themselves too much at the center of it.  With the playing field leveled, that changes dramatically.  There is now real impetus for consistent standards, and a potentially much bigger and more complex market.

Put it all together, and I’m actually excited again.  There are lots of ways it could screw up, but there’s also a real chance that this could start changing expectations about communication.

What am I missing here?  What should folks be doing with an open-sourced version of Wave?  Do you think it has a chance or not?

Wave Postmortem

August 19, 2010

Naturally, I was off on vacation and away from most of the Internet when the news broke that Google was going to cancel Wave As We Know It.  (I love my Android phone, but it’s not really the tool for serious blogging.)  Lots of people have written about the topic, mostly along the lines of, “Wave was always a piece of junk”.  They’re wrong, but the fact is that Google managed to screw this one up in a lot of ways.  Let’s go through some of the problems, and their implications.

Lack of Patience: From what I can tell, Wave has been tossed to and fro based on management whimsy and panic; there doesn’t ever seem to have been a properly designed plan.

It was released very prematurely, when it was barely alpha-grade (and I suspect well before the engineers wanted it released), apparently because they wanted something to show off at Google I/O.  This meant that the development team had to spend the entire past year mostly firefighting, instead of doing the sort of hard and principled sanity-checking and redesign that it needed before public rollout.

And now they’re killing off the public project after scarcely a year: ridiculously too quickly for a product that they had sold as revolutionary.  Twitter is the exception, not the rule: most revolutions take years to percolate before finding mass-market acceptance.  (Think about ICQ, or Friendster, or Mosaic — the first version of a revolutionary idea is usually several years before it hits big.)

I’m coming to the conclusion that Google’s biggest problem right now is that they are being surprisingly clueless about how to manage new products.  Wave is a great product at its core, and Buzz a decent one, but both rollouts have been mismanaged on an epic scale.  If Google needs to fix one thing about the company, this is it.

Identity Integration: Everyone treats this as an afterthought, sometimes even something to be avoided for pure business reasons.  But it’s a huge problem, and Wave demonstrated why.

At initial rollout, Wave didn’t work with any existing identity system, not even Google’s own: you had to get a new “@googlewave.com” address to use it.  Even when they started to open things up, it only worked with Google IDs.

Frankly, this is dumb.  I understand Google’s motives for doing so — it’s technically a hair easier, and it encourages people into Google’s ecosystem — but it’s a foolish hurdle to put in front of a radical new tool that you are trying to get people to use.

The public is suffering a really bad case of identity fatigue: too many incompatible logins to manage.  Each one is a minor thing, but each one leads to an additional reaction of, “What, again?” when folks have to create another one.  In a perfect world, Wave should have been built on a generalized concept of identity that accepted, eg, Facebook logins, but at the very least it should have worked with OpenID and the rest of the open stack.  I remain extremely disappointed that Google put far less thought and effort into this problem than I did on my own for CommYou — you just can’t keep pulling this on the public and expect to win.

Lack of a Killer App: The biggest complaint about Wave has been the constant question, “What is it for?”, and I have to lay a lot of blame at Google’s feet for not answering that more clearly.

The thing is, Wave has multiple killer apps.  It is a brilliant co-editing system, easily the best tool I’ve ever encountered for group document development.  And while it’s a bit overweight, it is in many ways the best conversation tool I’ve found to date (aside from CommYou, of course), mixing realtime and asynchronous conversation smoothly.  In general, it’s a fine collaboration mechanism.

Either of those (and probably other stories) could have been a fine selling point — but Google dropped the ball.  Instead, they simply tossed it out with a vague and confusing “It will replace email!” (what?), and never pushed any motivating examples properly.  So it never developed the core audience that any tool needs in order to survive.

My sometime CTO Chris Herot has occasionally lectured me about the problem of Crossing the Chasm — taking a tool that is great and making it successful.  A key element of that is always the killer app: showing at least one core group of users that they can’t live without this thing.  Google simply assumed that others would do that job for them.  That was arrogant, frankly, and it didn’t work.

Bloated and Slow: Mind, this is a hard problem, and it’s a damned sophisticated tool.  But seriously: Wave runs kind of slowly even on Chrome, and doesn’t run at all on Internet Explorer.  (No, Chrome Frame is not an answer.)

That’s just plain unacceptable for a current web-based tool — again, it was kind of arrogant on Google’s part.  It’s especially unacceptable for a social tool, because social tools are all about critical mass.  If a large fraction of a community is unable to use the tool, that’s an enormous handicap, usually an insuperable one.  And much though Google might wish otherwise, a large fraction of the world is still IE-based.

I can sympathize with Google here, and cutting out IE6 is entirely reasonable at this point.  But not supporting at least the same browser set as Gmail was a serious mistake.  They need to trim down and optimize the UI to the point where it will run acceptably on the full range of modern browsers, if they actually want this stuff to ever be real; anything else is simply wishful thinking.

(The engineers in the audience might want to take note of a general lesson here.  Successful products usually follow the path of starting with a simple tool that implements a great idea, and then slowly expanding from there.  Wave did the opposite: it has a lot of pretty innovative ideas, but has proven to be a bit too ambitious for its own good, putting features ahead of the basics like broad compatibility.  I’d bet that, if you teased Wave apart into its component parts, there are half a dozen great products to be had there, that would be more successful.)

No Mobile Support: Similar to the above, but worth calling out separately, is the fact that there hasn’t yet been any practical way to interact with Wave on a smartphone.  Nowadays, that’s pretty much unacceptable.  I mean, how can you claim to be a replacement for email and not have a mobile solution?

Now let’s be clear: this is hard.  Really hard.  It’s arguably a fundamental design problem — the way Wave works, it really wants both a powerful machine and a big screen, because there is no obvious way to do the co-editing thing without it.

But really — Wave is, as much as anything, a conversation tool, and it is ridiculous that there is no lightweight and easy way to interact with the conversation.  Indeed, if Wave has a killer flaw, this is it.  The conversation mechanism looks and feels great (okay, I’m biased — it’s identical to CommYou), but is fundamentally tied into the co-editing.  A conversation is basically just a document that a bunch of people are co-editing together, and that means that there is no way into the conversation without all that co-editing weight.

This could probably be retro-fitted.  There needs to be a standard robot that monitors your waves and provides a two-way conversational bridge for them, an API for interacting with that, and an Android app that knows your Wave identity and talks to that robot.  A third party could have built that, and still could.  (Indeed, bits and pieces exist.)  But why would they?  This is core functionality, to make Google pieces talk to each other.  Google should have built it and publicized it properly, so that the hardcore members of the Google ecosystem — the sort of people who are mostly likely to use both Wave and Android — could work in a natural way.

Poor Business Support: I’ve spent most of the past year wishing desperately that I could use Wave at work.  Not a week goes past without us getting into some ridiculously nested email conversation with ten participants, where everybody is commenting on each other’s comments, nested five levels deep, using every color of the rainbow to try to distinguish each new set of comments from each other.  It’s idiotically painful, and Wave is precisely the right tool to do this instead: it excels at deep group conversations on a complex topic.

But I’ve been unable to even suggest that we use Wave: there’s no way it would fly.  Let’s get into some reasons why:

  • No SLAs: serious businesses require service-level agreements.  We need to be able to count on a tool that is reliable, and Wave is nothing of the sort.  This isn’t surprising — it was released at alpha-quality, and even today it’s basically a beta.  But it’s no wonder that the business community hasn’t flocked to it, if we can’t take it seriously.
  • No security assurances: I’m an engineer, and I get that nothing online is ever totally secure.  But Google hasn’t been willing to even put a stake in the ground about protecting my intellectual property, even to the degree that Salesforce does.  Without that, there’s no way I can go to my bosses and say that we should hold even casual business-related discussions there.
  • No identity integration: okay, yes — it’s probably hopeless to wish that Google would provide a way to integrate with Active Directory.  But really, it’s a huge issue.  The above problems aside, my IT department is quite reluctant (with good reason) to add a completely parallel user-management system for the company: it’s a recipe for security problems, as well as simply a maintenance headache.

Of course, little of this is unique to Wave: these are common complaints about the Google ecosystem in an enterprise environment.  But it’s particularly acute this time around, because Wave is something new.  No Microsoft-centric shop is likely to use Gmail seriously, since MS is pushing Exchange at you so hard.  But MS has nothing even remotely like Wave, and it is a great business tool, so this would have been a great opportunity for Google to get their foot in the door.  Unfortunately, I think it’s been pretty much flubbed.

Next Steps: okay, so enough about the mistakes.  What comes next?

I’m going to stick my neck out and say: Wave is dead (well, dying); long live Wave.  There are actually a bunch of reasons for optimism.  Google has said that they will be repurposing the technology elsewhere, and that’s appropriate — most of the interesting bits of Wave are infrastructure.  I’ve argued for months that combining Wave’s conversational strength with a social network (eg, Buzz) would produce the first serious competitor to the LiveJournal platform.  So I hope that Google is smart about that: that they are finally getting serious about the crossing-the-chasm problem by integrating the Wave technology inside real apps.

On the downside, if they don’t replace the Wave Inbox in some smart way, that’ll hurt.  Inbox is one of Wave’s quiet strengths: a concise and very effective way to catch up on what’s been going on, whether you’ve been off having dinner or on vacation for weeks.  I do worry that, if Google uses the Wave infrastructure without providing Inbox or something like it, the system will lose half its usefulness.

Also, there’s probably a bit of brand poisoning here.  Frankly, Google handled this a bit clumsily: by killing off the main Wave project so publicly, I think they’re going to associate the whole thing in the public mind as a failure.  That would be a damned shame, since so many of the individual pieces are so right: the failure has been mostly a management one at Google, failing to put it all together correctly.

But the underlying Wave protocol is open, and I think is here to stay.  Competitors like Novell are already adopting it, as are open-source projects using Wave.  I hope that projects like the Wave Forum (an open-source effort I’m helping with, to build a truly great forum system on top of Wave) will simply change gears a bit and move forward whether Google is pushing things or not.

So: opinions?  Counter-arguments?  What are the problems that I’ve missed above?  What pieces of Wave do you think can and should be pulled out and reused?

Wave getting better at talking to the rest of the world

March 2, 2010

Yes, yes — one of these days I’ll get back to Catching the Wave.  But in the meantime, keeping up with the news: the Google Wave Developers blog announced today that they’ve come out with a major revision of the Robots API.

To explain what’s going on here, I need to briefly get into the kinds of automata that Wave allows.  There are two types:

  • The obvious ones are gadgets.  A gadget is something that you see on the screen, generally, and tends to be interactive.  So the Google Map embedded in a wave would be a gadget, or the various implementations of thumbs-up / thumbs-down voting.
  • Subtler, but more important for conversations, are robots.  A robot is an external process that can listen to and modify a conversation.  The most obvious and trivial kind of robot that people started playing with initially was the censorbot: one that would keep an eye on the conversation and bleep out bad words.  But there are lots of others doing all sorts of things — and in particular, mediating between Wave conversation and other media like IM.

The new API has all sorts of new capabilities, but two aspects seem most immediately interesting.  First, a robot can pro-actively push data into a conversation.  This implies to me that you can start building really powerful, really interactive bridges between Wave and other services.  For example, an IM bridge becomes considerably more useful when you can send IMs and have them immediately reflected in a persistent Wave.

Second, again most obviously useful for bridging, is the new Proxying-For capability.  Basically, the robot can say that a change is being made on behalf of a specific person.  This opens up *breathtaking* opportunities for abuse, but you really have to trust the robot before you allow it into your wave in the first place anyway.

Put together, it sounds to me like Google is putting a major emphasis behind allowing Wave to interact with outside systems.  That’s smart: they’re trying to make this a key new component of the Internet ecosystem, and the more other parts they can hook into, the more it will be.

What sort of things would you be interested in hooking Wave to?  We’ve seen a lot of examples: pushing bug reports into waves; stockmarket information; IM and email bridges; and so on.  What else?  The sweet spots here appear to be recording transient events, and making it easy to hold conversations around those events as they happen.  I can see lots of obvious applications based simply on email and IM bridging, but I’d bet there are far more off-the-wall possibilities here, like live game scoreboards…

Catching the Wave: Tempo — Up, Down and everything in-between

December 7, 2009

Let’s talk about the concept of “tempo”. (For this term, I have to thank Stowe Boyd, who introduced us to it while I was at Zingdom — I think it’s evocative and right.) It’s helpful to think of online social tools as being focused on either “up-tempo” or “down-tempo” conversation.

Email is the classic example of a “down-tempo” tool. It takes a while for a message to get from the sender to the recipient, and the ecosystem has evolved around that. Conversations often last a long time, pinging and ponging over the course of days. The assumption, when you send a message, is that the recipients may not be present, so their messages are saved, and they might respond at any later time. The conversation is gradual in its pace.

IM, on the other hand, is “up-tempo”. While there are exceptions, most IM conversations take place between people who are present at their computers right now, and everything is built around that. Presence is key in IM: if the other person isn’t online, you probably don’t bother to talk to them right now. There are no guarantees of reliability: if you send them a message, and they’re not online, they may never get it.

The thing to keep in mind about Wave is that it is multi-tempo. If everyone is present, it can get very fast and interactive — indeed, even more interactive than IM. But all changes are stored, and it is specifically designed so that, if you come to the conversation three hours later, you can catch up.

This is a big deal: while Wave isn’t the only system built for multi-tempo, it takes the problem more seriously than most. It’s specifically intended to let you collaborate very effectively and interactively when multiple people are present, but still be easy to jump in later and catch up.

Chad has pointed out to me that the terms “synchronous” and “asynchronous” are often used where I use “up-tempo” and “down-tempo”. They’re nearly synonyms, but I prefer the “tempo” approach mostly because it implies less of a dichotomy. We generally think of “synchronous” and “asynchronous” as very different modes of communication, and they traditionally are — you can lump most online media into one or the other. But the reality is that it’s a sliding scale, even for the more traditional media but especially on Wave, so I have a mild personal preference for terminology that matches that.

Pushing and Pulling

Closely related to this is the question of “push” vs. “pull” methods of interaction. In their most traditional modes, email is “pull” — you go to a mailbox on your own time, and look for new stuff that has come in — whereas IM is “push” — when someone has a new message for you, you get immediate notification so that you can reply immediately.

Of course, these lines have been blurring for years. Many IM systems allow pull: if you’re not around, they will save the messages you have missed until you log in again. And my email is now very “push” — my cell phone rings when I get a message via Gmail.

Wave takes a very pragmatic view of this: it allows you to use both push and pull pretty much as you want, and is well-optimized for both. In particular, it’s designed to push stuff to you instantly if you’re around, but makes it easy to catch up later if you’re not. I’ll talk about this more in a couple of days.

Next: Threading the Conversation

Catching the Wave: Shall We Play a Game?

December 2, 2009

Let’s work through an example, which should give you the idea of how Wave is used.

Say I want to work together with my friends on something — say, figuring out some new poker variations for our monthly poker game, which is going to be Halloween-themed this month. (A shout-out to my friend Charley for providing the fine real-world example, and who was the real “I” in this story.)

I create a wave, and start off with some text describing the idea, and one or two sample ideas for games that I’ve thought of. I include the members of the poker group in the wave. (This isn’t quite email, so I don’t really “send” it to them. I can add new people to the wave at any time.)

At this point, Chad decides to jump in with another idea or two, and some critique of my initial ones. We’re both online at the same time, so the conversation goes quickly, with messages zinging back and forth inside the Wave. Both of us are editing the original article — the list of games — as we go, and in the course of a few minutes, we’ve beaten out a bunch of bugs in the games.

A couple of hours later, Mark logs onto Wave, and sees that there is a new conversation in his Inbox. He’s got some questions about several of the variations, though. He replies to several of the messages (creating subthreads by doing so); he also goes directly into the main document and replies right next to a couple of the game descriptions, starting threads in the middle of the document.

Chad has Wave open, and notices that his Inbox shows activity in the poker conversation. He opens it up, and starts a real-time conversation with Mark. Right there in the middle of the document, they chat back and forth a bit, and figure out where Mark is confused. They edit the document a little to make it clearer, then delete the conversation they just had (which is now just in the way).

Hopefully, that example gives you at least a hint of how the tool is used. Most useful waves seem to follow this general model: a bunch of people working together to refine the stuff that is contained in the initial blip. This is a somewhat controversial assertion, and certainly open to debate, but it is what I’ve observed in practice. In its current state, Wave has issues with more open-ended and less-focused conversation — I’ll talk about those more later in the series.

(For the record, the end result was one pretty good game, and one insane but amusing one.)

Next time: “Multi-Tempo and Heavyweight Threading”, as Google tries to square the circle of conversation models…

Catching the Wave: Sprechen sie Jargon

December 1, 2009

Okay, for real this time: let’s start talking about what Wave is. Bear in mind, I’m going to be talking about how I see it, not the official Google hype.

At its heart, Wave is a tool for shared workspaces that involve conversations. In this, I’m using “conversation” in the most general sense: a group of people interacting. At the moment, that’s mostly through text, but in the long run those interactions will involve everything from party-planning tools to maps to spreadsheets.

To begin with, here’s some terminology. Okay — some jargon. But it’s official Wave Jargon, so we may as well get used to it now.

  • Wave (with a capital W): the tool itself. If I specifically mean Google’s version, I’ll sometimes say Google Wave, but since that’s the only real implementation yet, that’s usually what “Wave” means.
  • wave (with a small w): a shared workspace/conversation, which includes a specific group of people who are working together. (You can have public waves, but they have lots of problems. Personally, I think they’re currently a bad idea; I’ll get into why later.)
  • wavelet: a single permissions boundary within the wave. This is the bit that matters a lot to the techies, and very little to everyone else. A wave is composed of any number of wavelets, each of which potentially includes a different list of participants. This is how you can have what are called “sidebars” in some conversation systems or “private replies” in Wave: side-conversations that only a couple of people are in. In practice, though, most waves contain exactly one wavelet.
  • ping: a private wavelet between two people, sometimes inside another wave, sometimes on its own. Pings typically look a lot like IM conversations inside Wave.
  • blip: an individual element of collaboration. In practice, usually a single message sent by somebody. If you think “blip” == “message”, you’re reasonably close most of the time.
  • thread: a bunch of blips that are responding back and forth. Threads can be stuck anywhere: as sub-threads that reply to a particular blip, or even inside another blip. This is weird, different, and possibly the most useful single thing about Wave: that threads can not only be deeply nested trees, but that you can put one of those trees wherever it seems useful.

So you create a wave to talk about a given topic. This contains one or more wavelets, each of which is essentially a separate conversation about that topic. Each wavelet contains a root blip, which is most often the thing you’re talking about, and lots of other blips that make up threads of replies; these threads can be placed more or less anywhere in the wave.

Next: an example of Wave; or, Shall we Play a Game?

Catching the Wave: the Nuts and Bolts

November 30, 2009

Okay, most of you probably don’t care so much about the open-source project. You want to know what this tool looks like, and how to use it. Here are the rough basics of the initial Google Wave client, for those who haven’t seen it yet.

This picture shows the typical layout of the Google Wave client:

A typical view of the current Google Wave client

A typical view of the current Google Wave client

There are four major pieces —

  • On the top left is the Navigation pane. This includes your Inbox — the list of waves that you’re involved with — as well as less-used groupings like your Trash, Spam and so on. It also has separate lists for saved Searches — lists of waves based on particular criteria like tags — and Folders. (Yes, Google has knuckled under and included Folders, which they’ve never done for Gmail. I believe this has to do with the way Tags work in Wave, which doesn’t let you use them quite the way you do in Gmail.)
  • The bottom left is your Contacts: the people you know in Wave. This can get a little subtle, but in general it works like you expect a contact list to work. It is integrated with your Gmail Contacts, but includes both “My Contacts” (the people you’ve expressly put on the list) and “All Contacts” (a wider group of people you’ve talked to), so it may appear larger than you expect.
  • The middle pane is a list of waves, and intentionally looks a lot like a normal email inbox. By default, this lists the conversations in your Inbox — the Inbox consists mainly of waves that you were invited into, or started, or include a group that you are in, plus other waves that you have read. But if you select another search or folder, it will show that instead of your Inbox. (This picture shows my waves with the tag “ArtOfConv”.)
  • Finally, the right-hand pane shows the currently-selected wave, in reading mode. You can switch over to editing mode instead; this looks almost the same, but replaces the toolbar (which currently shows buttons like “Reply” and “Playback”) with editing controls instead.

Those are the basics, as you will see them out of the box. There are some more bits and pieces that will show up sometimes — for example, pings show up in a “minimized” form along the top, or you can open multiple waves at once — but most of the time, you’ll probably be seeing it more or less like this.

Next: Sprechen sie Jargon; or, what do all these words mean?

Catching the Wave: The Tool and the Project

November 19, 2009

So the first question everyone asks is, what the heck *is* Wave? There’s been a lot of contradictory opinion about that, but the next several articles will try to provide a little perspective.

You have to keep in mind that Wave is two very different things, right out of the gate. First, it’s a new tool from Google, that is currently in an early alpha release. It’s buggy as all get out, and we’ll talk about that more later, but it’s improving rapidly. It is in a pure invitation-only mode right now, as most Internet tools start out — you have to get someone you know to give you an invitation. Those invites were rare as diamonds in the beginning (thanks to Michael Kleber for getting me an early one), but successive rounds of growth have made them a little easier to get.

Second, it’s a new open protocol. Google is trying to make something really new and different here: a new online ecosystem that is as pervasive and important as email or IM or the Web. They know that they can’t do that on their own: plain and simply, they’re not that deeply trusted. So they are fostering efforts to build alternative versions of these ideas, and to standardize server-to-server communications: the “let a thousand flowers bloom” approach. These other visions will come both in the form of open-source projects and commercial software — for an example of the latter, check out this announcement that Novell Pulse is planning to federate with Wave. (Thanks to Michael Kleber for pointing this out to me.)

So keep in mind that the current thing people will usually point to as “Wave” is just Google’s first-draft realization of these ideas. It was released a bit hastily (and perhaps a bit too early), and has lots of flaws, but this client is just scratching the surface here. There’s a lot of evolution yet to come here, both from Google and from other folks.

One thing Wave is not is email. In my opinion, Google did themselves a disservice by spreading the word that Wave is what email would be if it had been invented today, because it leads people to think of Wave as a new version of email. Put that out of your mind: the only thing Wave really has in common with email is that they are both conversational tools for sharing and collaboration. (Well, and they both have things called “Inbox”.) Wave has elements of email, but it also has elements of IM, forums and lots of other things.

An implication of that is that there actually isn’t all that much new about Wave, and a lot of people are dinging it for that. But that misses the point. Wave isn’t about radical new ideas, so much as it’s about a new way of combining a lot of old ideas. You’ll often hear it described as “Forums plus IM”, or “liveblogging plus email”, or something like that. It has elements of all of those, but the combination is what makes it interesting.

The discussion below will mostly be talking about Google Wave — that is, the initial Google client/server version. But the ideas here go far beyond Google, and much of the potential lies in what folks will do with both their tool and the larger architecture.

Next: The Nuts and Bolts

Catching the Wave: Prologue

November 18, 2009

This is a personal introduction from Justin. Many hands contributed to the following series — it was drafted in Wave itself, with lots of back-and-forth discussion — but this bit is my own perspective, so the reader can take my biases into account.

A month or two ago, thanks to my friend Michael, I got an invite to Google Wave; since then, I’ve been playing with it fairly heavily, getting a sense of what it is and what it does. It’s time to talk about that in detail. Those of you who have been curious about Wave, this is the series for you. This is going to be really, really long and in-depth, far moreso than most of the glossy overviews in the press, but I’m going to break it into lots of little articles on particular topics, one per day. I encourage you to share the URL around — this subject goes right to the heart of what this blog is about, and there’s a lot to say here.

(BTW: no, I don’t have any more invites. Sorry, but they went pretty fast, even limiting myself to people who I knew would dig into it seriously. If you ask around, they seem to be getting easier to obtain now.)

Disclaimer upfront: as many of you know, I’ve spent the past two years of my life mainly consumed by trying to build a system called CommYou. That was largely the inspiration for this blog: CommYou was all about fostering productive multi-tempo conversation online. It had a lot of cool ideas — it’s basically my attempt to create the conversation system I’ve always wanted. But it’s never made it past early alpha, because my standards are high: it’s actually in the middle of the second major rewrite now.

So you’ll understand my mixed feelings when I say that the most concise way to describe Wave is, “CommYou, only more ambitious”.

That’s over-simplified, of course: Wave isn’t trying to do *precisely* what CommYou does. But along the way, they wound up coming to remarkably similar conclusions about how you structure multi-tempo conversation in order to achieve serious collaboration. In particular, the look and feel of their conversation system, and the framing of how you present things to the user, are awfully close to CommYou’s.

The result is that I’m just now getting over a sense of frustration at having been “scooped”. The CommYou project is pretty well dead — I’m not dumb enough to try to compete head-to-head against a serious Google project.

That said, the purpose of CommYou was to produce my ideal conversation system. Wave currently has lots of flaws (which will be discussed at considerable length in later articles), but it comes closer than anything I’ve seen to date. So as I get past the frustration, I’m turning into quite a serious Wave evangelist — if I seem to complain a lot, it’s mostly because I can see how great this system will eventually be, and I’m impatient. This is the realization of a lot of the ideas I’ve had for some time now, and I’m hoping to see it evolve into a truly great system.

Hence, this series. Over the next few weeks, I’ll be discussing Wave in enormous detail, focusing less on the basic “what it looks like” (which you can find lots of articles about), and more on what’s really going on here, what Wave is good at, what it’s bad at, what you should be using it for, and particularly why this is going to become an absolutely indispensible tool once they get the bugs ironed out.

So join in, spread the word, ask questions and provide your insights, as we dive into Wave (which shall, henceforth, be the subject of altogether too many mixed metaphors).

As the rest of this series gets posted, I’ll be updating this article with links to the later ones. So bookmark this page, and it will serve as the table of contents for the rest.

Credits: lots of people have helped me with this series of articles. I’d like to especially thank Michael Kleber, Chad Bergeron, Alex Feinman and Anna Bradley, who have done much to help crystallize my thinking, as well as Jessica Polito, my wife Jane for proofreading, backboarding, and generally putting up with me, and Charley Sumner for organizing the first serious Wave I participated in that was about something other than self-referential navel-gazing about Wave itself.

Next time: okay, so what do we mean by “Wave”?

Table of Contents

Prologue

What is Wave?