Thus it is that I only recently joined Google Wave.

My impression before joining, based hazily upon half-remembered opinions I’d seen in the tech news and blogs, was that it was (like the laser) a solution in search of a problem. Nobody seemed to know quite what to do with it, at least at first.

It’s not that hard a problem: as email is optimized for two-party communication, wave is optimized for n-party communication. At its most basic, it falls back to simple email: asynchronous communication between two parties. If both parties happen to be online simultaneously, Wave updates the conversation in realtime. The content is stored online forever on a remote server whose administration and upkeep costs have been abstracted away from the user experience. None of this is beyond the capabilities of modern email.

Wave’s advantages come into play when more than one person is interested in the conversation. Native threading of replies lets sub-discussions happen naturally. Collaborative editing tools allow people to improve working copies of a document without the hassle of mailing the current revision to every person as each edit is made. The internet nature of the thing is exploited to give each message a unique URL, meaning that wikis are an extremely natural application of the technology. At the same time, permissions are all managed by the overall Google structure.

The most common use case for Wave in the general zeitgeist is that it’s useful for online gaming. There’s that, but there are also much simpler, more general cases. For example, my little brother’s birthday is coming up. Everyone in my family is going to get him something, but we’ll want to converse before buying both to share gift ideas and to ensure that we don’t duplicate gifts. Wave is very well suited for that sort of discussion. With email there is a list of recipients that must be managed per reply and a message-centric format which encourages excerpting and replies to all, generating much traffic and taking much inbox space. Wave’s format identifies the conversation itself as central instead, reducing traffic and repetition. In the end, it reduces the process involved in having the discussion, which makes it the superior technology.

Email has one major advantage that Wave currently lacks: interoperability. Email is at heart a message format defined by SMTP and extended with MIME. Any client or server conforming to the format and performing the expected operations will interoperate with any other, which has lead to the ubiquity of the tech. Wave is, for now at least, an application, not a format. To get on Wave, you need a Google account and an invite from a current wave user. Then you use the Google viewer to view the waves on the Google server. It is very much a one-company phenomenon. This, I believe, is to Google’s detriment. If they open the format and ideally the current software implementing it, wave could eventually become as big as email. It would no more be tied to Google than email is to ARPA, but it would be everywhere. Right now, Wave can’t replace email as a primary means of communication: even if I could sell the idea to everyone with whom I wanted to converse, they couldn’t all get accounts. Opening the format might change that.

Wave is still beta tech, and it is very obvious in places. For example, right now, anyone can edit any message in any conversation in which they are a participant. One major requirement for the final version will be the implementation of various levels of access control. Relatedly, there is some version control for the textual content, but rich content and in particular dynamic widgets which are deleted are gone forever.

Still, this is a technology with some real potential, particularly if some means of interoperability is established with classic email. Once it’s cleaned up, polished, and open-sourced, I can see it being big. Until then, it will remain a niche product.

I looked at the blog post, and I was skeptical. Then I looked through the comic, and found myself thinking that it’s worth taking a look at, even if I decide not to use it in the long run. The release is tomorrow; I think I’ll end up checking it out.

It’s worth noting, though, the original use of chrome: apart from a few engineering applications to resist corrosion and increase hardness, it is all about making an otherwise unexciting piece of machinery bright and shiny. Under the surface, the machine is still the same.

XML and Java have the same sort of flavor to them: they’re reasonably good and very widely used; they’re the sort of product that design committees everywhere aspire to create. Their flaws only really become visible after something better comes along. In Java’s case, Python demonstrated that a whole lot of the structure and required text that gives Java code its rigidity can be stripped away, leaving a language that’s a joy to develop in. However, there hasn’t been an analogous improvement on XML.

Until yesterday.

Protocol Buffers have a non-descriptive name; I had no idea what to expect when I clicked the link to the announcement that Google put out. As it turns out, they’re a generic data serialization format (much like XML), except without all the human-readability business that so bloats actual XML. From the announcement:

Protocol Buffers allow you to define simple data structures in a special definition language, then compile them to produce classes to represent those structures in the language of your choice. These classes come complete with heavily-optimized code to parse and serialize your message in an extremely compact format. Best of all, the classes are easy to use: each field has simple “get” and “set” methods, and once you’re ready, serializing the whole thing to – or parsing it from – a byte array or an I/O stream just takes a single method call.

In case you missed that, all you have to write is the schema. All the encoding and decoding crap that you have to wade through in XML has already been abstracted away; they generate classes to do that for you. This is, in fact, cooler than sliced bread.

Of course, there do exist times when XML might better serve your needs:

However, protocol buffers are not always a better solution than XML – for instance, protocol buffers would not be a good way to model a text-based document with markup (e.g. HTML), since you cannot easily interleave structure with text. In addition, XML is human-readable and human-editable; protocol buffers, at least in their native format, are not. XML is also – to some extent – self-describing. A protocol buffer is only meaningful if you have the message definition (the .proto file).

In my experience, the human-readability and self-documentation inherent in XML have always been bonus features not essential to the core mission, which was getting data from Point A to Point B. However, I’ve had to spend countless hours wrangling with DOM and SAX, dealing with the problem of getting the data into and out of that intermediate form.

There is one wart that I noticed: you still have to create and read the Messages entirely distinctly from your own native class structure. The natural thing to do, if you want to use this to serialize and deserialize a class, would be just to put all the members into the Message definition and put the methods into a subclass of the generated class. However, that is expressly forbidden. All is not lost, though: all you really need, at simplest, is a pair of methods like this:

class AClass(object):
     ...
     def toPBuff(self):
          out = AClassPBuff()
          for member in dir(self):
               if not (callable(member) or '__' in member or member in self.__excludeFromSerialize):
                    setattr(out, member, getattr(self, member))
          return out

     @classmethod
     def fromPBuff(cls, pBuff):
          out = AClass()
          for member in dir(out):
               if not (callable(member) or '__' in member or member in self.__excludeFromSerialize):
                    setattr(out, member, getattr(pBuff, member))
          return out

In short, even if only in terms of making efficient use of developer time, this is already an awesome project. Once you count in that it is also faster and slimmer than the alternatives, this becomes astonishingly cool. Expect it to be making appearances in my code from now on.

I remember the book as being quite good, and very funny. However, neither Google nor Amazon have successfully helped me determine the correct title or the author. This is the first time since the internet that I have not been able to locate and buy any book I wanted based on a few keywords–the feeling is disconcerting. I’m asking the world at large here if anyone else has read the book and remembers the correct title or author–with those, I can probably at the very least get an interlibrary loan copy, even if I cannot find a copy of the book worth buying.

The publishing date of the book is probably between 1950 and 1990.

Until that point, my only experience with Apple’s operating systems were on ancient System 7 machines, which I despised. I’d be hard-pressed at this point to name specific flaws with those systems, but I’m pretty sure my loathing wasn’t baseless. It was a pleasant surprise, therefore, to discover that the OSX experience was generally a positive one.

My overall impression of the current Mac OS is this: there are certain use cases which the designers expect of the owner of the machine, and for those cases there are well-polished applications which generally behave quite pleasantly. I was particularly impressed with the ease with which I could use it to keep my cell phone’s calendar and contacts synchronized with the contacts on the computer and my Google calendar–it took about 15 minutes of research and setup, and thereafter exactly three button clicks to update things. If you want to write a document, watch a movie, browse the internet, burn a CD, or any of a large number of other common tasks, the computer comes with a convenient application for the purpose.

On the other hand, once you stray from the expected use cases, the ease of use plummets dramatically. The only way I could figure out to export my Safari bookmarks was to download a third-party program purpose-built for that task. I tried feeding internet to the computer through the bluetooth link to my cell phone; it took about four hours of research to discover a cryptic magic incantation to type into a special terminal that would launch if I ran a particular program; this incantation had to be typed manually each time because there was no obvious way to automate it.

There were a few quirks that I didn’t really like. The alt-tab analogue seemed broken to me because it switched between programs instead of individual windows, which didn’t help me at all when I had four IM windows going at once. That was just a symptom of a more general trend: in Windows, someone who knows what they’re doing can generally get along without a mouse, even though things get much more cumbersome. Attempting the same on OSX, so far as I could tell, would be futile. I really disliked the tendancy to fly icon bars over, under, and around the working space in their own miniwindows; I like to keep my icons in one place relative to the workspace of a window, where they won’t overlap or be hidden by anything.

Other differences were noticeable, but easily adapted to. I still think that it is strange for a program to stay in memory after its last window has been closed, but I bet there are people who appreciate the near-instantaneous “load time” it gives their applications after the first time. Individual windows tend to take more screen space than I’m used to percentagewise, but that drawback is neatly counterbalanced by “Exposé”, which flies all your windows into individual panes which you can choose from. Putting the menu bar at the top of the screen didn’t bother me because there was almost never a need to use a menu.

Overall, I wouldn’t hesitate to recommend an Apple to someone with little or no previous computer experience, as it’ll do just about anything they’re likely to want to do with less trouble than they’d encounter on a comparable Windows machine. The only real exception to this general rule is that someone interested in computer games would be much better served to just get a Windows machine.

On the other hand, I also know that I would not be happy using OSX full time. I actually am interested in computer games, which is really the deciding factor. Beyond that, though, I have a decent understanding of how Windows works–I’ve been using it for over 10 years, and I know what to expect and how to do things the quick and easy way. It may be that the stuff I dislike in OSX can be configured around or have non-obvious analogues, but I wouldn’t look forward to going through the learning process again. Also, I have a FreeBSD box for “serious” purposes; while it’s possible to do most of the same stuff in OSX, I see no reason not to go for the free OS which runs on much cheaper hardware. I’d expect the same would apply to other power users.

OSX in one sentence: it is bright, shiny, rounded, easy to use for limited purposes–exactly like the toys given to four year olds.

And now google releases this:

In production, your code is compiled to JavaScript, but at development time it runs in the Java virtual machine. That means when your code performs an action like handling a mouse event, you get full-featured Java debugging, with exceptions and the advanced debugging features of IDEs like Eclipse.

This is unspeakably awesome. You get to write code for browsers, without having to write the Javascript!

Google just went up several coolness points in my book.

Google’s (beta) Japanese-to-English translator renders it as follows: “Yesterday, it occurred to o’clock of 2.”

I’m not trained in psychology and my dataset is limited to what I’ve personally experienced; any conclusions I reach are likely to be flawed and certainly not applicable to the general public. Even so, I figure that it can’t hurt to at least take a few tentative steps into introspection.

The most logical place to start is to describe the physical sensations. If I’ve been reading steadily, the following are generally true:

• There is no perception of the passage of time. Once I stop reading, usually because the book is over, I am usually surprised by how much time has passed. On the same note, it is nearly impossible to set an endpoint at a particular time and stop then
• There is no perception of the physical actions required for reading. I am obviously scanning lines and turning pages, but the entire process is automatic.
• There are certain limited perceptions. I am aware of my posture and general comfort level, just as I am aware of the color and texture of the paper. Despite the fact that I am continuously aware of all of these things, it’s all in the back of my mind, at a very low level, very far back. It’s kind of the same way that I’d notice the color of the wallpaper and the intensity of the lighting in a room in which I’m having a conversation with someone. Oddly enough, I don’t seem to pay attention the physical, printed words on the page at all.
• Though I tune out most of what I hear, an alarm that I’ve set will break me out of the book. I often listen to music while reading without really hearing it, but occasionally a song will come up with strong associations to some subject and I’ll break out of the reading for a few minutes to focus on the song and its associations. This focus on the music and its associations almost never happens when I’m just listening to music; I need to have achieved the focus first.
• I am highly focused on the information stream I am retrieving from the book, to the exclusion of everything else, as noted above. It feels like I am reading at the same pace as I normally think. This focus is such that the stream of consciousness which I think of as my train of thought is entirely suppressed. In some ways, it is as if the text from the book replaces my primary thought process. For example, small side-trains of thought branch, are considered concurrently with the primary train of thought, and go away in relation to interesting ideas in the text. This is identical to what happens when I think of interesting things on my own.

There are a few more data points to consider:

• People occasionally react with surprise to the rapidity with which I finish books. I infer from this that I read more quickly than average. However, without a proper test, I couldn’t quantify this in words per minute. I have read that the recommended method of increasing reading speed is increasing the block size that you scan and recognize as a unit. That is to say that children begin learning to read by scanning letters and composing them into words, but the real breakthrough into literacy happens when they stop scanning letters and start reading words as units. I couldn’t say at what block size I read, but I suspect that I scan entire sentences complete. This is because of my perception; reading feels like sentences arrive complete and in sequence, as concepts come complete when thinking naturally. However, I would not be surprised to learn that I read at a substantially lower level. I am fairly sure that I do not read paragraphs in a single block; digesting an entire paragraph in a single conceptual unit feels like it would take time to process, which I don’t experience.
• I notice anomalies. Misspellings, broken grammar, and typos all stand out and interrupt the flow of reading, if only for a few moments. Ripped pages, stains, and so forth generally get noticed in a small side-train of thought, but don’t interrupt the flow of reading unless they are severe enough to render the page illegible.
• I interrupt reading periodically to shift position, and I often fidget by bouncing one or both legs. However, though I can remember such things in retrospect, they are almost entirely subconscious while they are happening; it is as if the flow of my thoughts has been paused with the temporary cessation of reading, and the two resume simultaneously.
• I tend to be very reluctant to stop reading for any reason, even very important reasons that I know of in advance such as a class I am scheduled to teach in 15 minutes. When I am forced to stop reading for an extended period of time, there is an intense compulsion to resume reading as soon as feasible. Luckily, this compulsion dwindles over time.
• All of these things have been true since, at latest, second grade. I am not sure exactly when I learned to read, or when it became easy, natural, and focused; my memories from before second grade are fairly fragmented.

I know that by the time I was 7 and therefore elegible for a full ‘adult’ library card, the librarians at the children’s library knew me by name and I had exhausted everything it had to offer in terms of novels. I did skip the picture books and most reference books, but towards the end, I was getting desperate. By seventh grade, I was forbidden to bring novels into my school, or to buy them at the periodic book fairs; I read in class too often. In eighth grade I was suspended: my religion teacher attempted to enforce the ban and take the book from my hands, I refused to let go, and she slapped me. The suspension was for defiance of a teacher, but I think I won that one.

In summation, I find reading an intensely focused, very relaxing, and highly compelling exercise. I suspect that the state I enter while engrossed in a book is similar in some respects to that of people meditating to the exclusion of the world around them. However, instead of introspection, I focus on an external channel, the text of the book.

com -> amazon.com
net -> php.net
org -> apache.org
edu -> exploratorium.edu
gov -> whitehouse.gov
mil -> defenselink.mil
jp -> jpmorgan.com
au -> smh.com.au
uk -> guardian.co.uk
de -> amazon.de

What’s interesting here is that none of these resolve into a directory chart or table, or an explanation of the whole concept of how domain names are resolved. Instead, all of them lead to fairly prominent websites. I’m not sure whether this is just an artifact of my browser, which is why I made all of the TLDs into links… The real question, if it does turn out that the TLD resolves reliably to these addresses, is how those addresses were chosen. I doubt they were picked randomly from all possible subdomains; it seems fairly likely that someone in each of these domains paid some money to someone in a DNS provider to make them a top pick. This makes the libertarian in me fairly sad…

[UPDATE] It turns out that these pages are identical to the top result of a Google search for each TLD. That is, if you type in ‘edu’ and are feeling lucky, you will get exploratorium.edu. So I can blame Google for picking a company that is not even vaguely japanese for the .jp domain… More checking got me to the point where I can assert that aparantly, different browsers each resolve top level domains differently. Internet explorer brings up some sort of microsoft search page, and lynx brings up pages, although I couldn’t figure out the scheme by which each page got picked there…

Might it be a good idea to introduce functionality to the DNS servers, such that they do something useful when insufficient information is typed in? As things are, users get inconsistent results, and the results may or may not be useful at all. At any rate, I’d rather that a top-level request get recognized as a TLD, not just a search request, and get some information about how the domain naming system works.