Gmail is written using a classic MVC pattern — Model, View, Controller.  The View reflects changes in the Model, and the Controller tells them what to do.  Clearly the View is our web page, and in this implementation, the Model is stored on Google’s servers.  What this means is that when you do something like archive a message, you’re not going to see the results until a message is sent to Google’s servers and the response comes back.  Now Google has really fast servers, but networks are slow.  By following this design pattern, Gmail is easy to code new features for and maintain relatively bug-free, but it’s never going to be all that fast.

Gmail engineers could code up optimizations for special cases.  For example, when I’m looking at my inbox and I hit archive on a message, they could detect this case, and just remove it from the page and then tell the server afterwards.  This kind of coding will quickly make the Gmail hard to maintain and result in lots of bugs.  Especially when you consider that multiple clients can connect to a single gmail account at once.  Strictly following MVC makes it easy to resolve conflicts in one place — the server.

A Proposed Solution

There is a solution though.  Google Gears can help.  The Gmail UI could be (and for all I know currently is being) re-architected to use Google Gears as the Model in the MVC pattern.  This means any operation in the UI would be committed very quickly to the SQLite database on your hard drive.  Then another thread would synchronize these changes in the background with the master model on Google’s servers.  Everything works — UI operations are reflected to the user extremely quickly.  We don’t lose all the benefits of storing all our data on the server.  And as an added bonus, we can still work on our e-mail when our computers are offline.  Yet another reason why Google Gears is important.

So when is this coming?  Synchronization and it’s evil twin, conflict resolution, are complex software tasks, so it could take a while.  But if I were placing bets, I’d guess we’ll see this in the first half of 2008.

This simple idea is actually tricky to implement properly.  Rhapsody has a lot of music and a lot of artists.  So many that keeping the entire list in a javascript program is impractical, as is downloading the entire list from the server.  So I took the most popular 50-100 artists in each primary genre and combined them into a single manageable list of about 1,000 names.

This idea is made practical by one of my favorite features of Rhapsody.com — human-writable URLs.  Assuming your browser is set up properly (install plugin, enable pop-ups), opening http://play.rhapsody.com/Morcheeba causes Morcheeba to start playing.   This API (can URL’s be API’s?  I think so!) accepts punctuation too — http://play.rhapsody.com/R.E.M. will play R.E.M.  And thanks to a generous interpretation of the HTTP spec by just about everybody, http://play.rhapsody.com/The Postal Service actually works too.  (Note the technically illegal spaces in the URL.)  What this means is that my script just needs a list of the names of the artists, and doesn’t need corresponding ID values to generate the playback URL.  In fact, you can browse www.rhapsody.com for quite a while before ever seeing a database ID in your address bar.  Which brings me to the interesting part of this post.

Computer Science Interlude

Javascript is a slow, interpreted language.  The straightforward way to write this script would be to loop through a list of artist names, replacing each one in the document.  Something like this:

var artists = ['The Postal Service', 'Morcheeba', 'Massive Attack', 'Madonna', 'Tosca', 'Underworld' ];  // The actual list is much
longer...

for(var i=0; i<artists.length; i++) {
   document.body.innerHTML = document.body.innerHTML.replace( //... some regular expression
   );
}

This script would run very slowly.  To scan an HTML document with N characters for M artist names this way would take O(N*M) time.   Instead I wrote the script in just 2 lines as follows:

var regex = /\b(The Postal Service|Morcheeba|Massive Attack|Madonna|Tosca|Underworld)\b/gi;  // The actual list is much longer...

document.body.innerHTML= document.body.innerHTML.replace(regex,"<a href=\"http://play.rhapsody.com/$1\" title=\"Play $1 on Rhapsody\" >$1<img src='http://www.rhapsody.com/favicon.ico' alt=\"Play $1 on Rhapsody\"/></a>");

This might look like a cop-out — a cheezy easy way to do this.  But it’s actually much faster.  This will run in about O(N) time (assuming N>>M).  The single giant regular expression looks for any of the artist-name-keywords and applies it to the whole HTML document at once.  Firefox’s highly-optimized C++ regular expression engine compiles the big artist list into a single state-machine which is applied to the HTML much faster than anything I could possibly write in javascript.  Regular expression interpreters are brilliantly efficient.  Check out Jeffrey Friedl’s excellent Regular Expressions book if you want to know more about this highly practical topic.  The result is that the script can parse a document for a large number of artist names in a totally tolerable amount of time.  There’s a short delay when the page loads, but it’s still faster than browsing in IE.

Enough Theory.  Let’s get down to practice!

The script isn’t perfect, but it’s pretty neat to use it to browse Myspace or Facebook and have a lot of the music people mention be instantly playable. 

If you’d like to play with it, install Greasemonkey, and then install the Rhapsody Artist Linker script here.

[Update 5/4/07: a new and improved script is available here.  Read about the changes.]

First, a little computer science background.  Turing completeness is the idea that a computing system has the same capabilities as a universal Turing machine.  This theoretical machine moves along a long tape which has various symbols on it that the machine can read and write.  The machine itself is always in one internal state, but will change to different states based on its programming and input.  It is programmed by a huge state transition table which says "if you’re in state X, and you’re reading symbol Y, then write symbol Z, move left n spaces, and switch to state W" for all possible states and symbols.  It turns out that with a long enough tape and enough states this device can do just about anything you think of a computer being able to do.  In fact, computer scientists have shown that every modern computer system is functionally equivalent to a Turing machine.  That is to say all modern computers are Turing complete.  It’s useful because it’s simple enough to prove theorems about.  Some important things we know about Turing machines and anything which is functionally equivalent to one:

• Turing machines are deterministic — given a set of inputs they’ll always reach the same output.
• It’s impossible to reliably predict whether or not a program on a Turing machine will ever finish.

I see two ways to interpret the question of whether or not a human brain is Turing complete.  The first one is "Can a human brain perform the same functions as a Turing machine?"  I think that given a pen, paper, and enough patience the answer is clearly yes.  But that’s not the question that interests me.

As a transhumanist, the interesting question for me is "Can a Turing-complete computer perform the same functions as a human brain?"  This question is important to me because if the answer is yes, then it is possible for a computer to simulate a human personality.  That is to say uploading of a human consciousness into a computer is possible.  I’m going to dodge the detailed analysis of this question today, and get back to it in a later article.  For now, let’s assume the answer is "Yes" and see what that implies about free will.

Remember that theorem that says Turing machines are deterministic?  That is, once you start it going with a given set of inputs, that it’s always going to reach the same answer?  If this were true for us as humans, then we would have no free will — our actions would be entirely determined by our current state and our surroundings.  We might think we are making choices, but in fact a fast computer could run the same calculation and tell us what our answer would be before we thought we had decided.  So by this logic if uploading is possible, then humans have no free will.  Troubling, eh?

Fortunately, I think the above analysis has a flaw.  Let’s dive down a little deeper into neurochemistry.  Neurons fire as a result of electro-chemical processes.  Basic chemistry tells us that the rates of chemical reactions are deterministic based on concentrations of the relevant input chemicals.  But if you took stat-mech then you learned that these predicted rates are actually just statistical averages and that they’re only accurate if the brazillions of molecules involved happen to collide with each other at a constant frequency as they randomly bounce around in solution.  And quantum mechanics tells us that this apparently random bouncing around is in fact, to Einstein’s chagrin, truly random — god does play dice with the universe.  (I’m not sure I completely buy this, but I’ll have to save that for another article too.  Yes, I know that the Bell inequalities were experimentally observed in the 1980’s but it still sits funny with me.  Sorry grandpa.  More on this later.)  Because of this randomness, the instantaneous rate of any chemical reaction will vary randomly, while still averaging around the classically predicted rate.  So the upshot is that neurons don’t behave completely deterministically, but that the exact timing of neurons firing has a truly (quantum) random component to it.

Now this implies quite firmly that our brains cannot be simulated by a Turing machine since Turing machines can’t act randomly, and thus wouldn’t be able to properly simulate the randomness of neurons firing.  But if we modify a Turing machine slightly so that a spot on its tape read a different random symbol each time you check, I think we’re good.  Given this, it seems reasonable that a modern computer that has a source of truly random data could simulate a brain.  Some have argued that we need quantum computers to simulate consciousness, but I don’t think so.  (Again, more on this later.)

Computers are pretty good at generating psuedo-random data internally, and by listening to the outside world (hard drive vibration, microphones, etc) can generate what is probably actually random data.  If true randomness is really important, we can build small accessory cards that sample thermal noise on
a resistor and produce large volumes of truly (quantum) random data.  Some advanced cryptographic systems do this today.  So it’s totally possible today to build this modified Turing machine that also incorporates random input.

Now our transhuman dilemma is solved.  The essence of free will lies in the quantum randomness of electro-chemical processes in our brain.  Moreover, it will be possible to upload our personalities into computers, complete with our free wills in tact, by incorporating random processes into the hardware that simulates our brains.  If the computers we upload into are only psuedo-random (as almost all software is today), we will appear to have free will, in fact we will believe that we have it, but we will in fact be total robots.  Now, who can come up with a Turing test for free will?

[[Thanks to Barry Brummit.  This article is a rehash of a couple good conversations we had over New Year's and this morning after yoga practice.]]