It’s been a while since I’ve taken the time to actually post anything substantial on this site.  I have been swamped at work.  And I have focused more of my personal time on family matters and on micro-blogging.  And today was going to be no exception to that rule.
I got up first thing this morning.  My intentions were to spend time on yard work and to enjoy time away from the computer.  After two months of heads-down work, I wanted the break.
But I decided that I would spend a few minutes on Google Reader.  That was my first mistake.  It didn’t take long for me to notice lots of kerfuffle about Google Chrome and built-in support for Native Client.  I remembered the Native Client buzz from Google I/O but I hadn’t really dug into the subject.  That changed this morning.
Native Client was a Google Code initiative that has developed into something far more transformative.  Stated simply, Native Client is a way that web applications can access/run native instructions on an x86 system.
That’s nothing new, per se.  Indeed, the idea of interpreting code to make it portable has been around for a long time.  When I built my first computer (a Heathkit H89 system), I decided to run UCSD’s Pascal p-system as an OS.  For those too young to know what I’m talking about, this was a PC operating system that ran completely on interpreted pseudo-code (i.e., interpreted byte-code).  Since then, the more obvious examples of this are Java and .Net applications.
And Google is now building their own instance of portable code.  I think this is all preparatory for Chrome OS and the cloud-based services that they are soon to unleash upon the computing world.  But that is a subject for a different post.  Today’s post is about getting started in Native Client.
So after sharing a few articles in Google Reader and tweeting a little bit about it, I decided to launch down the path of understanding it by installing the new platform.  But that was easier said than done.  Now that I am done, it doesn’t seem all that hard.  But it took me quite a few fits and starts.
Before launching into the list of tasks, let me note that I did all of this work on my Windows 7 system.  So I spent a lot of time figuring out which issues were part of the Native Client experience and which were part of the Windows 7 experience.  But I’ve been through the tunnel and it isn’t nearly as hard as it seemed while stumbling in the dark.
Here’s what I did: [I’ll update this post with links after I finish my dinner.]

• I downloaded the latest version of Chrome (4.0.220.1).  Actually, this happened automatically.
• I enabled the browser to run the Native Client. [You must add a run-time option to your Chrome invocation.  In my case, I used the following:  chrome.exe –enable-nacl
• I downloaded the Getting Started guide and I realized that there was far more to Native Client than just the browser additions.  Indeed, I needed to download and install the Native Client interpreter.
• Before I could launch into that installation, I needed to install Python.  I hadn’t installed that onto the Windows 7 system yet.  So off I went to http://www.python.org.
• Of course, Python wasn’t enough.  I had to also install the PyWin extensions.
• Once I had Python installed, I ran the installation and configuration steps in the Getting Started document.  Of course, things failed.  At first, I saw errors indicating that Visual Studio was not properly installed.  Huh?  So I had to actually go into the installation scripts.  Once there, it was obvious what the problem was: I didn’t have a working C compiler or development environment on this system.
• The next step took way too much time.  I had to decide which C compiler I should install.  I don’t have a licese for VS 2008 at home.  So I had to decide whether to use Cygwin, MinGW or gcw.  I had read that there were problems with Cygwin so I tried gcw.  No joy.  I then tried MinGW.  Also, less joy than anticipated.  Since I had great success with Cygwin on other systems, I decided to try it after all.  Well, I had no troubles at all installing and using Cygwin with Native Client.  [Note: The only problem with Cygwin was apparently a problem with the zip functionality in Cygwin.  I avoided this and had no issues whatsoever.]
• Now that I had a compiler and a scripting engine, I could actually run the installer as delivered from Google.  Lo and behold, things began to work. But I still needed to have a local web server for testing.  Since I didn’t want to use any of my other web servers lying around the bat cave, I decided to try the hpptd instance that comes with the Native Client code itself.  [BTW, I still don’t know if I like a Python-based web server, but it works fine.  So why not.]
• I ran the Mandelbrot and Life examples from the command line.  And they worked flawlessly.  So it was time to move on to the browser tests.
• I tried the samples in Chrome and ended up getting 404 errors thrown by the web server.  I was not feeling happy.  But I wanted to get this done.  So I pushed ahead and installed the Firefox extension.  And once I used the Firefox extension that ships with Native Client, everything worked.  All the sample apps worked like a charm.  At some point (probably tomorrow) I’ll try to get Chrome to use the Native Client environment.  But that is for tomorrow.

Now that I can sit down and think about what I’ve done, I realize that this is still a developer preview.  But the only reason that it is in such a state is because no one has packaged everything up properly.  The code works.  And it has immense promise.  It just needs someone to put a pretty wrapper around it.
And that person won’t be me – at least, not tonight.
-Roo
*Update: The solution to the Chrome issue was simple.  I mispelled the execution parm.  Once corrected, Native Client goodness is available within my Chrome browser.  w00t!
**Update: Curious…Native Client works with an invalid parameter (–enable-nacl) but doesn’t work with the valid one (–internal-nacl).  And it also works w/o any parameter.  I wonder if Chrome is using the NPAPI plugin.