jducoeur

I'd like to take a dig around Novell Vibe, which is approximately a corporate version of Google Wave. The projects were developed in parallel, far as I can tell; when Wave came out, Novell quickly adapted their communication protocols to match Wave, and then kept going. Now, Wave is kaput as a public site, and Vibe is more-or-less released: there's a shipping on-premises version and a cloud-based version in Beta. (Having lifted some of Google's now-open-source code, I gather.)

I'm once again getting annoyed at email for project communications, and am intrigued by Vibe: it has the sort of corporate attitude that Wave never did, and might be a viable tool for us. But before I go pushing it at the company, I'd like to mess around with it with friends and kick the tires a little, and decide whether or not it sucks. It's obviously over-complicated, and the UI is far from perfect, but if the functionality is strong it might be worth using anyway. I'm specifically looking for a good tool for having in-depth group conversations, which integrates with ActiveDirectory in some reasonable way and provides strong enough security that the company might be willing to use it.

(Wave was great for the conversations, but integration was non-existent and they provided no assurance of decent security. Wave in a Box may well eventually be the ideal solution for us -- I found yesterday that setting up a copy inside our firewall is a snap, astonishingly easy even on a Windows server from a standing start -- but it's really not ready for prime time yet.)

So -- anybody want to play a little? I'm looking to have some random conversations about -- well, pretty much anything, but Planning And Designing Stuff would be ideal. If you're interested, the beta program is open and free (for now). I'm signed up as vibe at waks org (under my mundane name); I encourage you to follow me there, tell me you've signed up, and think of random chit-chat to talk about...

Just spent an hour or two doing a quick installation of Wave in a Box, the now open-sourced version of Google Wave. A few thoughts:

On the plus side, installation and setup was astonishingly easy. Admittedly, I'm a couple of years out from the open source world, but it's clear that folks are continuing to make strides in the area of ease of development and use. From a fairly vanilla Windows Server with none of the prerequisites, I had Wave up and running in less than two hours flat, with almost no head-scratching involved. The instructions are clear, and they work. (Which, when dealing with open source on Windows, impresses the heck out of me.)

On the downside, it's not ready for prime time yet, even for limited in-company use. My (admittedly bare) hope was that I could set up an internal Wave server for some project communications that need more depth than email -- someone said, "let's set up a forum system", and I immediately thought of Wave. But the UI still demands Chrome: IE is slow as mud and sadly buggy, so it's clearly still using some of the old Wave client codebase. It's missing a lot of basic UI functionality, including some of the bits I most love about Wave. (Especially the ability to interject a thread into the middle of the base blip.) And unsurprisingly, there's no apparent Active Directory integration yet, which makes use in the corporate environment problematic.

Oh, well -- frankly, it's further along than I expected, and the problems are likely tractable. I'm going to have to deal with something more primitive for my current project, but there's at least plausible reason to hope that, by the time my next one starts up, I'll be able to set up an inside-the-firewall Wave server for its chatter...

Small but significant announcement from Google today: the embedded Wave element, which allows you to put a wave inside of a webpage, can now be configured to allow anybody read-only access, even if they aren't logged into Wave. You just inject a bit of code into the webpage, the Wave shows up there, and anybody can read it.

Which leads me to wonder: how much of CommYou is now doable with Wave? Things have advanced a lot in the past six months, with critical new features being added pretty regularly, and I'm beginning to think it could be done. Let's take a brief wander through that idea.

The core ideas of CommYou were similar to those of Wave, but with more of a focus on blogging in the LJ style, and (most crucially) tying into existing social networks. The notion is that you should be able to post these rich conversations, and they would automatically be visible to all of your networks. Wave has pretty solid conversation mechanisms -- if anything, it's a bit *too* powerful IMO, but the general flow is extremely close to the CommYou design: good but not excessive threading, easy navigation of conversation updates, stuff like that. What's needed to really make this thing hum?

First, there's the unified social network. The idea was that you have an account in CommYou, but you don't actually maintain your network that way: instead, your CommYou account is the union of a bunch of "identities" on other social networks. So my CommYou account would be my LJ, Facebook, Twitter and Google identities, all rolled up. It would be up to me to decide whether these all *looked* like the same person -- I could choose to still present three different identities publicly or just a single one -- but I could go into CommYou and not worry too much about which friends were on which networks if I didn't want to.

This was a key concept of CommYou, and was always dicey, but for legal reasons rather than technical ones. Facebook had a long-standing rule that you can't cache any FB information for more than 24 hours, which makes this hard to implement. However, they've just rescinded that rule, which may make the idea entirely possible. What's needed is a network aggregator that has a good, subtle understanding of these different identities, and lets me manage what I look like to the outside world. I don't believe that's actually hard to write. (It might even already exist -- this needs some research. Plaxo *might* have all the necessary functions: in general, they've done more to push the open social network idea than anybody else.)

Next, there's what I'm thinking of as the Socialite Bot inside of Wave. When I create a new post and include Socialite, that goes out to the social network system, finds out my identities, and asks which ones to post this conversation to. It posts a brief notification about the new conversation (maybe with some/all content) to each of those networks. It figures out which of my friends on the relevant networks have Wave identities, and adds them to the conversation. It sets appropriate "bloggy" permissions on the conversation, so that everyone can add comments, but can't edit the root blip unless I let them do so.

This bit is potentially tricky, since it should allow *them* to control whether they want to be added to my conversations by default or not -- I shouldn't be able to force it on them. That is, the reader determines what they read, not the creator. (This was one of the things I spent a long time getting right in CommYou -- the data structures are tricky.) Moreover, there's an issue here, in that Wave's Inbox is kind of a grab-bag of everything, but as a reader, I want to be able to group people into different buckets and read them at different times. Possibly Socialite could do something clever with Wave's Folders, letting me creates lists of people and put their posts into different filters that way?

Then there's the public blog site. This would use the Wave Embed feature, to show all of my Socialite postings in traditional public blog format, so that non-Wave users could easily read it. (The links that Socialite posts to the external networks should probably point to here.)

Hmm; not perfect, but not a bad start. There are a lot of rough edges that would need to be worked on, especially WRT locked posts, and getting the identity-management right would be *very* important. Indeed, I'd probably recommend that the identity distinctions be baked not only into the APIs, but right down into the internal data structures, to minimize the risk of accidental privacy leaks. (That is, if I have friended Joe on LJ, what I see is Joe's LJ identity, *not* the underlying "person" of Joe, to avoid me being able to accidentally see information I shouldn't.) My guess is that getting these internal protocols right would not only be safer, they'd probably enhance scalability in some ways -- in a perfect world, Joe and I should be able to have different "identity servers", but still be able to work together in this ecosystem. This just *begs* for a new open-source infrastructure for identity management.

That's rather neat, and I think the world is getting to the point where it could be built. Hmm: I wonder if I can scare up a little time to start exploring this...

Today's entry in Catching the Wave talks a bit about what I call "tempo", and how Wave tries to straddle the traditional lines in this respect, combining the best of up-tempo tools like IM and down-tempo ones like Email.

Today's entry in Catching the Wave shows a real-world example of Wave in action, to work on (wonder of wonders) something other than navel-gazing about Wave itself...

Today's entry in Catching the Wave goes through the new-and-different jargon it brings in: "waves", "blips" and other such stuff. (Wouldn't be an Internet tool if it didn't have stupid jargon, right?) It also briefly talks about one of the most interesting things about Wave: its hyperactive notion of threaded conversation.

The series about Google Wave is restarting, now that Thanksgiving is past: the latest entry does a quick overview of the UI, before we dive into the details.

Today's entry in Catching the Wave talks about the distinction between Google Wave -- the very early release of the client from Google -- and the larger open protocol they're trying to encourage. Check it out...

For the past couple of weeks, I've had a major back-burner project simmering. Since Google Wave is the nearest I've seen so far to a realization of the ideas underlying CommYou, I and a bunch of friends have been working up an extensive examination and critique of Wave: both the theory of where it's going and the practice of Google's initial version. As of today, I'm starting to post it in my professional blog, The Art of Conversation. I'll be posting the series in little bite-sized chunks, theoretically one every weekday for the next few weeks. (I don't know exactly how long it'll be, but there's over a week written so far, and we're still warming up.)

Frankly, this is a topic that I'm deeply passionate about, so I'm going to be encouraging folks to check it out. So I'll be posting pointers from here to there as I post the series. I'd love to have more people getting involved in the discussion, so come join in over there and spread the word.

So to begin with: Catching the Wave: Prologue.

I've been putting off writing this entry for a week now, but I really should just wrestle with it.

I've spent much of the past two weeks playing with Google Wave, experimenting with it, and talking with people about it. Right now, I'm reading into the nascent project to build an open-source version of it. (Which Google claims to support 100% -- they're trying to develop a whole new Internet infrastructure here, and are fully aware that nobody's going to take it seriously if they have the only implementation.)

A lot of people have been asking, "What the heck *is* Wave?". The answer is complicated, and I'll get into it more in a later series of posts, but the short answer is, "CommYou".

It's really pretty startling, not least because I'm fairly sure that this isn't quite what Wave set out to focus on. When you look at what it is good at, Wave is principally a co-editing system. It's a generalized infrastructure for allowing people to work on Stuff together, live in realtime as well as more gradually. It is basically taking a lot of ideas that have been floating around for many years (not least, in the game industry), and applying them in a pretty rigorous and generalized way.

But of course, CommYou has always been largely about that, just specifically for conversation. I've talked a lot about "multi-modal" or "semi-realtime", and this is exactly what I've been trying to describe: conversations that speed up nicely when multiple people are present, slow down when zero or one are there, but generally keep going and stay relatively distinct and on-topic. The latter point is essential: like CommYou, Wave is about *accomplishing* stuff together, which is what distinguishes it from a random chat room. The ethic of Wave, like CommYou, is that off-topic threads should (ideally) get taken to a separate wave, so conversations are broken down by community *and* topic.

They wound up arriving at bloody near exactly the same answers I did, enough so that I've occasionally found myself wondering if they hacked into my server and stole my ToDoList. Heavyweight threads: check. Semi-realtime interactive conversation: check. Summary window that live-updates when a conversation changes, and shows when and how much changed: check. UI that efficiently pops open an new-message window below any random message: check. Tracking which messages you've already read, so you can catch up on new stuff easily: check. Metadata and plugins: check. Etc, etc -- while it's not identical, it is *very* close to what I've had in my mind when trying to describe CommYou's design.

Make no mistake, Wave is damned cool -- there are a lot of nay-sayers, but they're mostly missing the point: they're taking an early alpha (which is what we've got now), full of bugs and lacking in features and integration, and saying "there's no there there". But having spent the past two years thinking about this stuff, I see *exactly* where Google is going with this, and it's a game-changer. We're at the beginning of a new model of communication and collaboration, probably more important than the rise of IM, nearly as important as the Web itself. (And vastly more important than Twitter and its micro-blogging ilk, which will gradually be subsumed into the Wave-like systems over the next 2-4 years.) Many people have complained that there's nothing *new* in Wave, which particularly misses the point: as I've long said about CommYou, it's not about coming up with a single new-and-revolutionary idea, it's about taking all the existing communication models and combining them *correctly*.

But the sense of "squish" is palpable, and I'm still wrapping my brain around it, and processing the emotions. Mind, Wave doesn't yet do *everything* that was in the CommYou design, not even everything that is already in it. But there is nothing in CommYou that would be *hard* to do in Wave, so I expect them to catch up to me fairly fast, and they already do a lot that I hadn't even contemplated: Wave's purpose is similar to CommYou's, but it is even more grandiosely ambitious.

Most importantly, they've almost casually swatted down my business plan. The idea was always that CommYou would be a cheap-or-free consumer service, as a loss leader for selling integrated high-quality conversation to websites. But Google has already announced that they will be giving away site embedding, and have even begun to demo it. So I'm left without the possible future income stream that justified all that work and present forgone salary.

I may be ambitious, but I'm not dumb, and I don't like tilting at windmills. It's one thing to grab at the brass ring of a startup, knowing that the odds are weak. It's quite another to try to compete against Google giving something away for free, especially now that they're starting to realize what they've got. I'm not going to win this one, at least not in the way I've been thinking.

So the existing CommYou plans are looking to be toast. I'm crushed, but part of surviving in the startup world is being good at crying in your beer for a little while, then picking up, moving on and getting the hell over it.

All that said, I don't think it's all going to be entirely for naught. Those two years of work have taught me a huge amount, not least about how a system like this can and must work. The open-source project is still pretty early, and I have a huge amount I can contribute to it. I've still got the passion for this project (which, remember, started as me trying to build the conversation system I've always wanted), and a lot of relevant knowledge. So I'm diving in head-first, trying to catch up to all the developers who have been in the loop for five months already while I was in denial about it.

We may even see the return of CommYou. We'll see how it plays out, but as I said -- there is a lot that Wave doesn't yet do. They've made great progress on the conversation problem, but they're missing a lot yet and they have made some decisions I don't necessarily agree with. (In particular, that realtime conversation is character-by-character Talk style, not message-by-message IM style: that's cool, but I think it's a mixed blessing.) And they've scarcely touched the community side of things, which has always been as important to me as the conversation part.

We'll see. I probably can't justify doing this as a true part-time job any more, so it'll have to turn spare-time, and I don't have enough of that. But there's a strong temptation to help the open-source project get up to speed, and then revive CommYou as an experimental variation of Wave that ignores the co-editing part entirely and focuses on conversation and community. If so, I'm going to do it right this time, as a pure open-source project end-to-end, using seriously cutting-edge tech. Programming geeks out there, think about whether you might be interested in playing.

BTW, for those who asked for invitations: sorry, they're mostly gone. I got a lot more people asking than I had invites, so I've been doling them out gradually and carefully, but I'm down to a single one left. (They mostly went to people who have been particularly helpful on CommYou, unsurprisingly -- those are folks who I know have a clue about this stuff, and have been demonstrably passionate about using it.)