Wave reflections

Google Wave is huge. I am not even going to try to assess it dispassionately. As I explained in my last post, the same epiphany hit me just a few weeks ago, so I have already drunk the Kool-Aid. Basically: email is the original killer app of the Internet. We live in email, but email sucks. Wave fixes a lot of the suckage. I think it could become a platform for a whole new “wave” of applications. See for yourself. But Wave raises some big questions:

  1. How does Wave interop with email, and what is the plan for spam? It would be a tragedy if Google were to reinvent email without canning spam. This big issue was not mentioned in the demo, perhaps because it conflicts with making it easy to adopt Wave. It would ease adoption if you could have your incoming email pop up as incoming waves. Any replies in the wave could be reflected back as email replies, emulating the standard quoting conventions. But this means you open up the floodgates to spam. Wave could stop spam if it required some form of authentication in its email gateway, but that might hinder its adoption.
  2. How does Wave interop with forums and feeds? They demoed embedding waves in a blog, and the same would be useful in a forum. But why not completely subsume blogs and forums and feeds with Wave? One could publish a wave folder as a feed. And subscribe to feeds as persistent wave searches or virtual folders.
  3. What is the offline story? As presented, waves exist only when you are online. I don’t think Google Gears will help. What you want is a local wave server running in your PC (replicated to the cloud for data preservation). It could have been a Java applet instead of GWT. This may be a cultural thing: Google does web apps.
  4. Does Wave offer a niche for Subtext/Coherence to flourish? Wave is at root a platform for transporting and replicating changes within XML documents. Coherence is at root about declaratively forming tree structures like XML and reacting to their changes. Would it be useful to have a domain specific language for defining robots that can generate waves and script their behavior? Stay tuned…

27 Replies to “Wave reflections”

  1. One of the commenters on Tim Heuer’s blog nailed down why Wave will be successful, if not ideal. It goes back to Joel Spolsky’s criticisms of Chandler. http://www.joelonsoftware.com/items/2007/01/21.html

    @But why not completely replace blogs and forums and newsgroups with waves?

    The real barrier is the web’s inflexible meta object protocol. In a forum, I have a RESTful URL (the meta-object protocol’s state machine id). i.e., observe the following click sequence:

    http:// forums.somethingawful.com/
    http:// forums.somethingawful.com/ forumdisplay.php?forumid=202
    http:// forums.somethingawful.com/ showthread.php?noseen=0&threadid=3130736&pagenumber=2#pti21

    Technically, the SomethingAwful Forums aren’t fully RESTful, as it doesnt represent my user settings for how many forum posts to display on a page. If you were building a real-time forum (wave), you compound the problem. How do you encode the state machine id into the URL so you can link your friend?

  2. Centralisation is the turning point.

    It allows the company to mitigate the spams: they control the identities and it’s surely easier to remove an account with the offending message than in a distributed setup.

    It allows the software to have more features: developping a protocol that is restistant to abuse is hard. By passing all messages internally, they don’t need that guarantee since their environment is controlled.

    Next step for them would be to intergrate Wave into GMail.

    On the other hand, nobody seems to care that the whole system is owned by one commercial entity ? While people can choose to use Gmail or another system, using Wave restricts the offer to one choice. Individuals don’t seem to care (see Facebook) but I think/hope that Businesses would be less keen to outsource their data. One day, people will need to wake up and see that before “do no evil” means arbitration. In a democratic state, the three powers are separated but I don’t see that as a Google “citizen” (sorry for being over-dramatic)

    For returning on the original subject, Subtext could clearly compete if they provided that vendor-agnostic protocol. Only problem: it’s much harder to build a standard than re-using an existing one (like webapp frameworks did).

    1. Wave is open source and you can host your own wave servers.

      Companies will install their own and support their internal applications there.
      You can still share waves between servers so you will be able to have private corporate applications as well as shared public conversations including partially shared conversations.

  3. These are all very interesting comments and speculations, but where is Subtext/Coherence?


    1. Fair question Peter. I need to have a clear application target to guide the design and implementation. Building web apps is kind of boring. I had this great idea for instead supporting collaborative editing of structured documents. Now Wave has deflated the killer demo I was envisioning. I am currently considering whether there is a niche inside Wave, or if I am back to web apps again.

  4. I have a different take on why the Wave wave matters.

    I don’t think the demonstrated Wave clients matter all that much, per se, other than their utility in sparking interest and giving hackers of a certain bent something to hack on. I’m thinking that the future of Wave clients is still pretty wide open although new one’s will have to subsume or respond
    to the initial client.

    Rather, I think the real advance – albeit an incremental one anticipated in the designs it builds upon – is in the protocols and data model.

    And I don’t think the protocols and data model are anywhere near done and I’m certain that there are flaws in the current design, but here is why they matter:

    To a first approximation, every resource on the web as we know it today is identified by a host-based URL. Of course most commonly the URL has the form:


    Contrary to popular assumption, we do not name resources on the web – we name hosts and relative addresses within hosts. If I type into the location box on my browser:


    my browser operates correctly not when it returns to me a verbatim copy of the GPLv3 in plain text format but, rather, when it contacts the host “example.com” and asks it to reply to a GET request for “/docs/GPLv3.txt”.

    In effect, a URL of that form does not name the document – it names a question posed to whomever currently owns “example.com”.

    In fact, there is no widely accepted, human-friendly, secure, distributed and decentralized namespace in which I can name some specific text – like a GPLv3 text file originally published by the FSF – and expect a browser to find it.

    Wave opens that door a crack. There’s still some chains keeping the door closed but the deadbolts have been unlocked and the door cracked a couple of inches and with a few swift kicks the rest inevitably follows. The web-as-you-know-it has numbered days, now.

    Wave opens the door, more specifically, to a secure, human-friendly, browser-friendly (really, user-agent-friendly), distributed, decentralized, dynamically updated, secure, and location independent namespace for web resources. A namespace in which routing is based on content or resource name and goes to any convenient verifiable host of that has that content or can provide that resource.

    The way that Wave encourages this is by encouraging the development of clients that route to resources by host-independent IDs like wave ids, wavelet ids, and document ids — while at the same time leaving fairly open ended what a document id is and leaving open to extension what an id is.

    Wave initiates the game of building a much needed and much anticipated overlay network that can operate in a distributed and decentralized way, giving names to resources rather than questions to hosts.

    1. Thomas – I think I see what you are getting at, but wave ID’s are the domain name of the originating wave host plus a locally interpreted ID string. How is that different from a URL?

      1. Briefly, the difference is that wave IDs are treated as indexes into federated Wave Stores rather than as routing instructions to individual hosts.

        (For the record, we had some conversation about this off the blog, via email, and such…. I’ve now added the blog to my list of bookmarks so in the future, if something comes up, I’ll try to reply here in the first instance. And, boy, as you said, wouldn’t something along the lines of Wave make this kind of conversation easier and more integrated across various presentation media 🙂


        1. Another way to look at it is to use the distributed source code management system analogy.

          Let’s look at GIT vs. Other SCMs:

          Other SCMs:
          – Delta storage based
          – Tracking file permissions and ownership
          – Snapshot-based: takes a picture of what all the files in your tree (project) look like at a milestone of your choosing (via the commit message); you track changes to a tree (project) over time
          – Tracks file contents, not container (e.g., permissions and ownership)

          Git also has an explicit Object Model, whereas most SCMs piggyback off the filesystem, improperly abstracting away the backend storage from the repository-as-a-resource concept. Git goes so far as to guarantee data independence for all its primitive types: trees, blobs, tags and commits. Git uses a 40-digit SHA generator to assign “unique” names to files; after all, we cannot simply use the file’s filename as a unique name, because the fullpath is host-dependent and the local path is extremely limited and prone to collisions. The file’s filename is also strictly speaking part of its container and not its contents. It just happens that transport mechanisms like FTP, SFTP and FTPS all build in some minimal amount of metadata to be shuffled around. However, with GIT, that is unnecessary.

          Hope that by example this better illustrates differences between Wave and a dynamically federated, dynamically distributed system.

          1. John, I’m not sure I follow you there.

            True enough that Git, at core, uses content hashes to name specific versions of files and directories.

            The resolution of a normal every-day URL (http://example.com/…) are essentially names of network nodes and sub-node resources – routing instructions.

            A third kind of name is a verifiable name for location-independent, varying, content and services. Wave, at core, uses this third kind of name.


          2. I guess my analogy wasn’t good enough.

            You are right. There is an important difference between 1 and 3, and my analogy is defeated by this difference.

    2. Your describing something similar to Content-centric networking (also going under Content-based, Information-centric etc). Check out Van’s slides from a talk at MIT for example identifiers. He calls his named data for popular consumption. Apparently Ted Nelson envisaged this for hypertext [see Wikipedia for Content-centric networking].

      I agree Wave is an incremental step in the right direction, however federation is not the way to go. Federated identifiers just move the bottleneck to the outer hubs and we have centralized name servers all over again.

      I believe it was Thomas on the mailing list who said: “There is nothing new under the sun.” 🙂

  5. @zimbatm

    Good point. Google and Yahoo have been trying to push DomainKeys forever as a way to combat spam. However, you don’t need centralization to implement DomainKeys-like concepts. You can embed GPG in a dynamically distributed Wave-like protocol, getting some element of federation for free.

  6. I have a project suggestion for Jonathan.

    The “No Ifs Ands or…” presentation blew me away and I liked the paper, too.

    My suggestion is to build a product (free software, plus papers and documentation) which:

    1) Is a similar-concept interface for writing programs that are compiled into XQuery. This interface should run in browsers as Javascript code.

    2) Uses WebDAV or some similar off-the-shelf thing as backing store. The editor-in-browser can both save the table-based description of the program as the “preferred source form” and compile it to XQuery.

    3) Has a simple little XML DB with stored queries as where programs (and the data they work on) gets stored. I can help with this part: it is easy to build out of “Berkeley DB/XML” and I have some experience in that area.

    The programs you write using the new 2-d language get compiled in stored in the DB and XML-ized data also accumulates in the DB. A pure client request can be interpreted as selecting a stored query from the DB, running that query, effecting any DB-side-effects it specifies as output e.g., XQuery “update” stuff), and replying with a response computed by the query. Meanwhile, the editor/compiler is the programmer interface.

    6-9 months to alpha. Foundations of an “Apache subsumer/killer”.

    1. Thanks very much for suggesting this idea. What I would really like to do is replace XQuery altogether. My latest paper is about how to do the “update stuff” with a declarative semantics, unifying updates with triggers and integrity constraints.

      But in any case, what good is a better-than-XQuery anyway? What are the compelling use cases? This is not a rhetorical question – I am trying hard to focus on concrete benefits.

      1. Thanks very much for suggesting this idea. What I would really like to do is replace XQuery altogether.

        I think that that’s a bad idea but only for a pragmatic reason:

        XQuery does land in the neighborhood of the parking lot of the ballpark of a sweet spot – it’s “workable”. AND, lots of other folks are doubling down on XQuery meaning that highly optimized XQuery engines are developing. Hence, I suggest using it as a target platform. (There is no implication intended that programmers using your system would have to think of themselves as “writing XQuery code” – just that the code they write gets compiled to run on an XQuery engine.)

        My latest paper is about how to do the “update stuff” with a declarative semantics, unifying updates with triggers and integrity constraints.

        But in any case, what good is a better-than-XQuery anyway? What are the compelling use cases? This is not a rhetorical question – I am trying hard to focus on concrete benefits.

        Looking at my own (obscure, un-/barely published) work but even more at Mark Logic and eXist DB and Berkeley DB/XML and various XQuery work at IBM and Oracle (beyond just Berkeley DB/XML)….

        We’re converging on a situation where you can write most familiar-style web apps nearly entirely as XQuery code.

        I’ve written a modest but non-trivial amount of XQuery code and the limitations of the language and awkwardness of it seem to me to cry out for the kind of approach you showed in “No ifs…”. Most of the hard time spent on writing XQuery code is, basically, doing in-yr-head translation of simple concepts into gawkard FLOWR code.

        More concisely: while I don’t predict market timings I do think that programs that can run on XQuery engines are sharply rising in value and at the same time I think there’s huge head-room to improve the ways in which people can write code for such engines.

        what good is a better-than-XQuery anyway? What are the compelling use cases? This is not a rhetorical question – I am trying hard to focus on concrete benefits.

        The compelling use cases are not guaranteed but seem likely to me. Again, we’re getting to a point where a familiar web app (say, Facebook or Flickr or Amazon.com) could be usefully written almost entirely in XQuery – whence (due to the functional nature of the language and its analizability owing to its simplicity) optimizers and interpreters can really go to town on the code. It’s “the new SQL” if you want to put it that way.

        What’s “better”?

        I found that I missed functional abstraction, for one thing, but not *that* much.

        That aside, writing the nested loops and conditionals and complex XPath expressions was always just very, very eye-splitting headache-inducing tedious. I longed for a development environment that let me interactively build-up or load XML schema and then write code about transforming data of those types by pointing, clicking, dragging and dropping pictures of the resulting data type. That’s vague, I realize — try writing a simple Wiki or some such as XQuery code to see the experience.

    2. OK, in fact that is the substance of my latest paper: building interactive web apps with a declarative tree-transformation language. But all query languages suck at update (as do pure functional languages), and that can only be fixed by introducing a whole new semantics. Thanks for the suggestion – front-ending XQuery is certainly a viable project, it is just that I have greater ambitions.

      1. Would you mind saying a word or two about why, in your view, XQuery Update sucks?

        A little ways back I tried (and failed) to get some angel funding for a programmable service that, in a nutshell:

        * had an XML database that included stored queries

        * upon a request would select a stored query to run

        * that query would return a sequence of side-effecting operations, including updates and…

        * would optionally return a “continuation” (a next query to select and run)

        In my demo systems I found that you could definitely hand-code simple things to that but really hoped to get to a point of using it as a target platform for a higher-level language.

        1. I guess I should look at XQuery closer, if you really think Amazon.com could be built with it! My theoretical objection to XQuery update is that updates can not interact or trigger each other, so there is no way to abstract or encapsulate updates, and no way to maintain constraints or check invariants. Do I have that right?

        2. Thomas,

          Such a programmable service already exists today. It is called XRX. It stands for:

          XForms on the client
          REST interfaces
          and XQuery on the server

          As an aside, I think you, Jonathan and I are all gunning towards roughly the same objectives, but our motives and methods all differ.

          MarkLogic is actually trying to popularize this stuff. If you wanted angel funding, you should’ve be hanging around Dave Kellogg’s blog, warming up to him.

          1. Yes, XRX is a similar approach. I had not heard of it before. I thought XForms was dead and buried. And XQuery is widely considered to be too complicated for normal programmers to understand. Now I understand the point of Thomas’ idea about font-ending XQuery with Coherence. This warrants further discussion, which this margin is too small to fit. Maybe I will start a new post.

          2. XForms is not dead and buried. We basically re-invented XForms here at work for our web-based forms that are “open to the public” using XSLT and XHTML forms. We have yet another separate web-based forms solution for “closed to the public”scenarios. There are good reasons for this, although those good reasons disappear as answers when the question can be made to disappear entirely.

            Just googling for XForms, the first page of Google has an excellent current events article by Kurt Cagle. http://broadcast.oreilly.com/2009/01/analysis-2009-xforms-and-xml-e.html

            However, let me be clear, that I don’t think XForms is the underlying representation for this sort of thing. I think it is just a data interchange format, co-opted into something much more.

    3. @2) Uses WebDAV or some similar off-the-shelf thing as backing store.

      WebDAV is not a backing store.

      WebDAV is really just a way to connect to a distributed repository with many authors/versions. Like REST, the backend is anonymous. Hypermedia cannot exist without backend independence.

  7. Which part of making interactive web applications are you trying to make easier? I can’t say that I understand your paper but it seems that you’re trying to make a database view equivalent for GUIs? E.g. you write the code to generate the UI, and if a user updates the UI then the backend data gets updated automatically. In my experience the code to update the database is only a small fraction. Most code is spent generating HTML, CSS and making the page more interactive with Javascript.

    It could be that if you make updating the backend data from the UI easier then people will change the way they write webapps so that updates become more important, but I doubt it. On the other hand, this could make writing abstractions to write HTML generating code possible.

    You are doing great work, much better than another type system!

    1. Thanks Jules

      When I say “update” I am really referring to the entire input side of the app, including the interactive Javascript, the controller classes, the model update methods, and all the setup in the templates needed to provision for input. If all that stuff is still a small fraction then maybe I am in the wrong application domain.

Comments are closed.