(this is page 120 of 121)





Latest

The Boss has a Clue?

I'm not a big fan of most Microsoft stuff and I think their best product ever is still Excel. But I am a fan of two things: 1. their full-on embrace of openness with respect to letting their people represent Microsoft to the outside world without the usual corporate filters, and 2. Bill Gates's ability to run a $300 billion company and still keep all of the details of what his vast empire is doing in his head in a deeply technical way. It is the second of these two that I want to focus on here.

If you have not heard Jon Udell's interview with Gates at PDC 2005 run and download it now (for fans of text over audio, he put a full transcript on his blog as well. I am a big fan of Jon's style (going all the way back to a book he wrote that flopped but changed my perspective on software and the net in a deep meaningful way): Jon does his homework, thinks hard before he talks, and always gets right to the core of the issue. So getting him as Gates's interviewer was just an incredible treat.

[ As an aside, Bill is clearly thinking about all the right stuff even if it is from the wrong perspective (fat client). Pay close attention to the part about RSS as a two-way protocol and the way in which the various groups at Microsoft have gotten the religion. ]

Anyhow, I really dig Gates as a software boss because of the way that he seems to be able to operate at so many levels at the same time. He can talk at the CEO-level one moment and then dive right down to implementation issues that the team in charge of a particular product has faced the next. He should be a model in that respect, at the very least to all CEOs of tech companies. I know that McNealey is a ham and Jobs is the ultimate demo man but it would seem to me that above all else, this multi-level talent is what sets Gates apart from the rest of the crowd. (Plus, it's nice to see that he's just not afraid to poke fun at himself).

In fact with the recent fiasco around the handling of the relief effort post-Katrina, I have to wonder whether the Gates model of leadership might not have broader relevance outside of technology.

Comments Permalink

Update: for those that just want my furl2del.icio.us migration tool, click here.

This is much bigger than an individual post-- it's actually a riff I will come back to many times over the next few months-- but because I have something useful to share, I want to start with just a small post. And that needs to start with a story:

Back in the fall of 2003, my friend Jerry Michalski told me about this really neat service that had just been launched called Furl. Furl was a web-based bookmark manager that went a step further in that it could also suck the contents out of public URLs into your own private index. It was slick, it was quick, and in a way it was very Web 2.0 way it had been put together by a small team from western MA in just a few months. At the time I remember mentioning Del.icio.us to Jerry as they had also recently launched but we both agreed that Del.ici.ous was too crude and flakey to be relied on.

Not very much time passed (as Jerry said before the paint was even dry) before Looksmart snapped Furl up and made loads of promises about how they were going to keep it the same, scale it out, blah, blah, blah. And they made good on the promise in one way: they kept the features of the app pretty much static. Unfortunately it feels like they kept the backend scaling static as well because the webapp seemed to slow to an absolute crawl, at times stopping to get PI to a few million significant digits before letting you actually bookmark something.

In the meantime though, Del.icio.us just got better and better. The app stopped being flakey. It kept a nice simple interface that was AJAXed to kingdom come. And most importantly, as the userbase grew, Del.icio.us became a really interesting social experiment.

So, where am I going with this? Well after having invested 204 bookmarks worth of content into Furl (all carefully organized and rated) I realized that I would much rather be working with Del.icio.us and worried that due to the roach motel motel model that many portals pursue in their "monetization"" strategy, I was probably doomed to starting my bookmark list all over again.

Except that in the end Furl did exactly the right thing in this Web 2.0 world we live in. Right in the "Tools" section of the website is a one-button option for getting your entire Furl archive as xml. The format is absolutely trivial (if you've ever parsed an XML file) and a scant 60 minutes after discovering it, I had all 204 of my Furl bookmarks imported into Del.icio.us. Key to this was also Del.icio.us's great web API for remotely adding bookmarks (RESTian and very very simple) but it was Furl's openness that most struck me as just great (are you listening Yahoo? Google?).

For anyone stuck in the same quandry and looking to get off Furl, I've uploaded my script here so that you too can move over to Del.icio.us. It requires a Python 2.2+ runtime which is really easy to get over here and it doesn't have much in the way of error checking, but it might at the very least help you as a template. You use it by calling unfurlIt.py from the command-line and passing your Del.icio.us credentials and the path to your exported furl.xml file. If there is any interest in using it a serious migration tool, I might wrap it in a simple Tkinter GUI and add the ability to suck the furl archive straight off the site so just let me know.

Of course, it occured to me that you sort of have to be a geek to do this kind of thing. So I started thinking about a standard format for data and metadata that all of these sites could comply with, a la Steve's much-evangelized attention.xml. Maybe OPML (which seems to be all the rage) could fill in here? But after a little more thought, I realized that this places the burden on the wrong shoulders. Any Web 2.0 engineering plan will for sure have a line-item called "data migration/export" and it will also for sure be the first thing dropped from the schedule when time gets tight. Forcing hackers to comply with some external data format is expecting too much under these circumstances.

But what we could to is start a public repository of snippets of code, sort of like O'Reilly's new Codezoo that could serve as common pool of data migration tools for X web service to Y web service or Z application file-format. Folks could contribute their own little hacks and perhaps together we could then help all the non-geeks avoid the roach motel. How is that for a collaborative lazy-web way of fixing things?

In the meantime, thank you Furl. It's been a nice ride and I'm leaving (with my data) a happy user. Way to set an example for everyone else.

Comments Permalink

I've spent the last couple of months thinking about web development platforms (due to a project that I will soon be able to talk about here) and apparently so have other people.

The debates have ranged from thinking about the nature of the languages, to thinking about the points for modularization of functionality (the libraries versus frameworks question) to the value of the community in helping get the tedious stuff out of the way. In this post, I want to focus on the language part of my thinking; in future posts I will move up the stack to consider libraries, frameworks, and communities.

A long time fan of Paul Graham, I naturally started by focusing on the importance of the language in terms of productivity. This answers the whole Java/P-languages question on the side of the P languages (Perl, PHP, Python & Ruby). In my experience, dynamically-typed wins every time. In fact, it's funny how many Java web projects I've been involved with that end up supporting dynamic language semantics via internal Hashtables and some sort of "meta-method" call system. That said, here is the caveat: I have never worked (and hope never to have to work) on an engineering team that is bigger than 12 people but I could imagine how the formalism of Java/C# helps when the problems of coordination become more significant the problem the code is actually trying to solve.

The more interesting question to me over the last two months has been: once you know the P-path is the way to go, how to pick? And here is my conclusion: among the P-languages (Python, Ruby, PHP, and Perl), there is only one relevant distinction, designed languages versus evolved hacks with Python and Ruby in the designed camp and Perl and PHP in the hacked camp. I'm not going to go into this distinction in detail as whole religious wars are being fought over this right now on IRC. I will just say that OOP seems like a hack in Perl and a crazy global namespace with several different ways to parse a string seems like an even bigger hack in PHP. Both languages have strong advocates that are Very Bright Folks. These people have valiantly tried to smooth over some of the major issues in Perl and PHP but at the end of the day you can only polish coal so much and I am often left wondering how much further Python or Ruby could be if these Very Bright Folks had spent their efforts there.

Among the designed languages (by which I mean someone with a good sense for computer languages drove the core of the design early on), I think things boil down to maturity of the runtime and taste. Python beats Ruby on the former and in my opinion it beats it on the latter as well. Python's runtime seems to have received more attention: it has been implemented 3-4 times (CPython, Jython, IronPython and PyPy), there has been more solid debate about implementation internals, and CPython appears to release often with about 10-15% speed bumps every time. And more importantly, it has bytecodes! Ruby's running straight off the AST worries me, not because I am some sort of VM purist but because it seems like this sets a natural limit for the optimization of the runtime (and yes I know that Rite will move us to a bytecode-based runtime but I have to wonder how long this will take to get to the mainstream).

On the taste side, I dislike the @:@@# littering Ruby code and the parentheses-for-method-calls-as-optional and I haven't yet seen why I should go ga-ga over Ruby blocks, but I am willing to admit that is just me and that I need more deep experience with Ruby to really be conclusive here.

The thing that is clear however is that both Python are more alike than different at their core. They offer the same built-in types, they are both extremely dynamic, their C-based runtimes are relatively easy to understand, and their C-extension mechanisms are pretty clean. Which means that despite my slight preference for Python, once you've crossed the bridge to the P-world, the web application development question has to be answered higher up the stack.

Update: A fabulous piece on closures Ruby and Python. The best argument and link list I've seen yet.

Comments Permalink

Curves

Back at the beginning of the dot-com boom I worked for in BCG's high tech practice. There was a partner there that spent most of his time talking up big concepts like "disintermediation" and "realignment of value chains." Sometimes it was so thick that you could cut the bull with a knife.

But there was one slide in the various PowerPoint presentations he would give that stuck with me. Riffing on the theme of worse-is-better he would talk about how web technologies, while less powerful than those that came before in the client-server world (CORBA anyone?), had tremendous reach and that this was what made them unique. He would then present the most sensual of asymptotic graphs:

We had given up all of this richness but in return we got the kind of reach that really helped IT become ubiquitously useful, or so the story went.

I wasn't the only one who got stuck on that graph because pretty soon every nerd in the high-tech practice was going on about everything was a trade-off between richness and reach from the lunch venues near our office to the reward points earned during business travel (to this day I wonder whether a lot of the richness-reach lure doesn't go directly back to some monkey affinity for asymptotic curves. See the latest craze on the economics of media if you don't believe me).

Anyway, the one place where I (and a bunch of others) have continued to apply this richness/reach tradeoff has been in client applications. Until recently, any need for a rich user interface was always relegated to the fat client. At my current job, I spend about 35% of my time managing the development of a Win32 book layout tool because when the company looked at the marketplace two and a half years ago it decided that the online photo sites (Shutterfly, oFoto, and Snapfish) were not nearly as adept at allowing people to make photo albums than the fat client applications (iPhoto and Picasa). This was probably the right call (right before my time) but it has turned out to be a real pain from a development perspective: releases happen at what is now considered a glacial pace (one every 4 months), we never do enough platform testing (12 OS/browser combinations), and bugs are hard to fix due to people's unwillingness to auto update.

Which gets me to my point: the recent naming of what Google has shown the world we can now do with modern browsers (AJAX) has unleashed a torrent of energy from hackers that have been for a long time sliding up and down the same richness-reach curve that we were on when we embarked on BookMaker. XMLHttpRequest and all of its supporting cast of technologies has changed the curve to look like this:

This will not eliminate the need for rich applications: everyone's favorite example is always, who wants to run a DHTML version of Photoshop? But it will change the point at which we reach for VC++ and MFC. And that-- for those of us who have spent some time mired in that Windows client hell-- is a truly wonderful thing.

Comments Permalink

Lazy web telco

I love my 802.11g wireless card. Wifi has been one of those things that has just transformed the use profile of laptops all over the world. A connected computer is a productive computer plain and simple.

Every week I ride the Acela (Amtrak's northeast corridor high speed train). Sometimes, for kicks, I do the entire ride with MacStumbler open listening for open access points all the way between Boston and New York. I've picked up as many as 42 different access points in the 220 mile ride. Wouldn't it be neat if I could borrow little chunks of bandwidth all the way down and thus remain connected-- albeit in a very bursty way.

The problem is that when the Acela is doing it's job, my little wifi radio is a 70-100MPH moving target. So assuming that I am not just picking up stray beacon frames with MacStumbler and in fact I have a signal that is strong enough to connect to, I still don't have enough time to do the requisite DHCP negotiation (assuming most of these networks are running something like a Linksys router) and create and end-to-end TCP connection, nevermind having a full HTTP or SMTP dialog.

So here is my question/lazy web request: would it be possible to write an app that was sort of a MacStumbler/NetStumbler on steroids that would queue up network requests for when a strong enough signal is picked up for association between the client radio and the AP's radio. Then (and this is where the hand-waving starts due to my poor knowledge of 802.11 specifics as well as any non TCP IP-based stuff), the app could send any waiting TCP traffic as a burst of UDP packets to a specific server on the Internet. The server could reassemble the TCP dialog and make the connection to the actual endpoint. It would hold the conversation on behalf of the semi-connected client.

Now here is the part I haven't quite figured out: how do you send communication back to the bursty client? You can't presumably do the same UDP-to-TCP in reverse because the client is not addressable. Or can you? I haven't read up on it but this new NAT-traversal (or port-knocking) thing that all of the p2p apps do looks very promising as a way to do this. The question is: do you need an IP address on the client? Because if you do, I'd bet the negotiation between the client and the server (DHCP) would make the approach not work (though you'd have to work the numbers out).

If this could be made to work, I would be a very happy customer of the app-- even if the quality of the connection was flakey at best. Right now I pay out the teeth ($80/month) for a Verizon EvDO card that goes into my PCMCIA slot, radiates the hell out of my knee while sucking my battery down as though I had shorted it, and still doesn't really work that well. It claims to seamlessly switch between EvDO and 1xRTT which it does to some degree but it is nowhere near as reliable as my Bluetooth phone over its own antiquated 1xRTT connection.

So that is my lazy web request for today: an app that uses the software to make the people's infrastructure better than what the carriers can provide. After all, software can do everything, no?

Comments Permalink