Humpty-Dumpty on IT

humpty

Herewith a collection of the most ill-defined terms in the computer business today. I’ve chosen them because in the last few months I’ve encountered at least two WILDLY incompatible uses of each one of them – often many more!

  • policy
  • virtualization
  • agent
  • edge
  • web service
  • solution
  • service
  • architecture
  • SOA

Anyone like to suggest a few more? I’ll roll them into the top-level blog item as updates. By the way, I’m not suggesting that we stop using these terms, but I would like to see more judicious qualification and less universalization…

New blog on e-voting

There’s an interesting new blog on E-Voting News and Analysis, from the Experts. Sample issue under discussion: “Suppose, hypothetically, that I knew of a vulnerability that would allow someone to corrupt vote counts or interfere with voting on some e-voting system being used in tomorrow’s election. And suppose further that it was too late to get the vulnerability fixed. What should I do?”

(I’ll be watching the RSS feed.)

It's a small world: The Votemaster

For some months now one of my “must read” web sites has been Electoral-Vote.COM. (Me and over half a million others every day!) I’ve watched the maps showing the aggregated results of recent opinion polls, I’ve read “the Votemaster’s” pained accounts of wrestling with different algorithms for aggregating, averaging, aging, and presenting the data. I’ve even contributed a few bucks to support the effort. Through all this, I had no idea who “the Votemaster” might be, until today. In the Votemaster FAQ , all is revealed: “My name is Andrew Tanenbaum. I am one of the 7 million U.S. citizens living abroad. I am a professor of computer science at the Vrije Universiteit in Amsterdam, The Netherlands. […] I can write fairly complex software. I wrote MINIX, the precursor to Linux, for example.”

Ah, that Andy Tanenbaum! “Mister Minix.” Now where did I put my battered copy of Operating Systems: Design and Implementation?

Charging, charging…

charging.jpgIt was my own fault. I put down the power adapter for my PowerBook in the cafeteria, and when I returned a little while later it had gone. I blame Apple’s sexy styling: it’s simply irresistible. Whatever: I was chargeless. I kept working on battery power until the system went to sleep to save me from myself. That was yesterday evening.
This afternoon, I was driving back from Sun’s Santa Clara campus to Menlo Park, and I decided that I had just enough time to stop in at Micro Center to pick up a new charger. They didn’t have the model I needed (scratch that store in future) but they did have a third-party “universal” charger. Reluctantly, I bought it.
Now I’ve always thought that electricity is electricity, right? The charger supplies juice, the battery charges, that’s it. Simple. Well, maybe not. Take a look at the X-Charge graph above. It shows my PowerBook charging up from zero to full over the course of 5 hours. There’s a 2 hour gap (leaving work, getting food, doing a conference call), and then after a weird curve (sure looks like it’s approaching an an asymptote to me!) the system decides that it’s not 85% charged, it’s 100%. Finished. Complete. Instantanteously. Weird. And iBatt confirms that it’s fully charged, at 4.151 Ah.
I never got that kind of curve with a standard Apple charger. And besides, this “universal” thing is running awfully hot. I think I may have to stop by the Apple company store tomorrow and pick up a kosher unit. I wonder if I’ll bump into Steve Jobs, as I did on Monday….

Did I say that?

One curious feature of search engines is that they remember stuff better than you do. I bumped into this truth earlier this morning, while testing the new a9.com search engine from Amazon. I naturally(?) began by searching for my name. After getting the usual hits, I found a bunch of stuff I’d never seen before – things like email exchanges about the NFS implementation in the BSD/386 distribution, and JXTA discovery. And then I came across this article by James Odell from 2002: Objects and Agents Compared. This post-dated my active involvement in the autonomous agents community, but nonetheless James quoted me twice – and both seem relevant to my recent pieces on software engineering, such as this.
On synchronous vs. asynchronous interactions:
According to Geoff Arnold of Sun Microsystems, “Just as the object paradigm forced us to rethink our ideas about the proper forms of interaction (access methods vs. direct manipulation, introspection, etc.), so agents force us to confront the temporal implications of interaction (messages rather than RMI, for instance)”.
On typing:
Geoff Arnold has considered the question of third party interactions which are very hard for strongly typed object systems to handle. Here, two patterns come to mind. The first involves a broker that accepts a request and delegates it to a particular service provider based on some algorithm that is independent of the type of service interface (e.g., cost, reachability). The second involves an anonymizer that hides the identity of a requester from a service provider. Models based on strong typing, such as CORBA, RMI, and Jini, cannot easily support these patterns.
Hmmm. I wonder what else I said. In the meantime, I’ll happily cite myself as these issues unfold….

The computer is the network is the computer

In a recent blog posting, Masood Mortazavi waxed lyrical on the importance of the fundamental statement of Sun’s vision: The network is the computer. He wrote:
In my mind, there’s no more revolutionary concept in computing, networking and information technology than the motto which Sun coined in many of its corporate PR campaigns: The Network is the Computer. […] Many others, including Tim O’Reilly, have opined on the motto.[…] To me, it has an almost esoteric meaning.
I added a comment that I then decided to reproduce here:
Masood: I agree absolutely. As a 19 year veteran, I have found that “the network is the computer” has always been at the core of what Sun means to me. Occasionally we get distracted: we focus on the components and lose sight of the vision; but we always come back to it. You’ve reminded me to do something that I’ve wanted to do for a while, now: grab the domain name thecomputeristhenetwork.com. I want to use it to talk about some of my thoughts on the future of computing. Much of what I do revolves around the question that Rob Gingell asked a few years ago: “If the network is the computer, what is the computer that is the network?” It sounds Zen-like, but there’s a profound issue here. Hint: it’s NOT a Von Neumann machine. And no, it’s not isomorphic to a Turing machine. Turing machines are fundamentally synchronous. The network is fundamentally asynchronous.

The future of software – postscript

Jim Waldo expressed an understandable skepticism about my inclusion of autonomous agents in my piece on the future of software; I thought I’d share my reply to him:
I think that autonomous agents may be an ever-receding category, a bit like AI. Remember how every advance in AI would provoke the retort, “But that’s just X – that’s not A.I.” Every time we add a bit more autonomous capability to a software component (advertisement, peer group discovery, self-monitoring for SLO, negotiating over a shared security context,….) people will say, “Oh, yes, I see how you can do that, but that’s not REAL agent behaviour.” Some people will insist that we expose the inner workings, and if there isn’t an obviously “AI-like” mechanism like multi-level planning or BDI they’ll deny that it’s an agent. Whatever. [shrug] I just want software systems that are a bit more robust, a bit more tolerant of version skew, a bit better about proactive resource management and self-diagnosis, a bit more flexible about how they organize themselves with their peers.

The future of software

Many of my colleagues at Sun are busy blogging about the software technologies that they work on – Solaris 10 features like zones (sorry, N1 Grid Containers), ZFS and dtrace; Java platforms (J2*E) and applications like speech synthesis and phone games; even Perl. And all of this is important – as Bruce emphasized, it’s important to articulate who we are and what we do.
I spend much of my time thinking about the future: about what cutting-edge systems and software will look like three or five years out. Now I know that this isn’t fashionable: Jonathan’s priorities for the year, immortalized here, emphasize the tactical rather than the strategic, and that’s just fine with me. And I also know that for most people the answer will be “same as it ever was”, because innovation in computing tends to be additive: augmenting rather than replacing. But the beauty of the future is that it’s already happening. Check out two articles in last week’s Computerworld if you don’t believe me.
Have Jini, will travel describes how Orbitz built their travel reservation system using Java and Jini. To quote from the article:
Under the Orbitz architecture, a customer request to book an airline ticket passes to a Java servlet container — the Jini client — running on BEA Systems Inc.’s WebLogic application server. The Jini client uses the Jini discovery protocol to find a Jini lookup service, which sends a proxy back to the Jini client. Through the proxy, the Jini client uses the lookup service to find a Jini service that can do what it needs. The lookup service then delivers the Jini service proxy back to the Jini client, and the client uses the proxy to communicate directly with the Jini service.
Orbitz registers its 1,332 Jini services on multiple instances of lookup services for redundancy, so there’s never a single point of failure in the event of a power supply or hard drive failure. It also builds redundancy into the servlet containers and the services themselves, scaling horizontally through Intel-based dual-processor PCs running Linux. The PCs act as servers in the Orbitz environment. “It’s not just redundancy; it’s also capacity,” says Hoffman. “If you need today 10 boxes to service a particular request and your traffic doubles, we can just add 10 more, and it’s not only handling twice the capacity but it’s now twice as redundant as it was before.”

While analysts are starting to label every kind of new software methodology as “Service-Oriented Architecture”, Orbitz is running a system consisting of thousands of services, with a high degree of self-configuration and self-healing. It’s a compelling vision. And it’s happening right now. (Shameless plug: I used Orbitz to book last week’s vacation trip to England.)
So what will all of these thousands of application services be doing in the future? Another article in the same paper, Agents of change, looks at the current developments of autonomous agent software. (This is an area that I worked on some years ago; some of our thoughts are summarized here.) Agents represent a paradigm shift as fundamental as object orientation: from building software as a bunch of reactive services and wiring them up according to a fixed pattern, to creating a community of self-interested goal-driven agents that can negotiate with their peers to solve complex problems. (The anthropomorphism is inevitable.) What I find interesting is that the ideas apply at so many levels – to application business logic, as described in the article, but also to service lifecycle and systems management.
What links these two articles is that today the technologies are widely regarded as rocket science, or even science fiction. It’s tempting to hand-wave and assert that a little syntactic sugar and tool-building will allow us to transform these powerful techniques into Lego components for the journeyman programmer. Well, maybe. But we should also consider how they might be used to solve intrinsically complex problems – the kind of thing that today we don’t even try to tackle. One size definitely won’t fit all.
(The other thing that links them is that they describe how our customers are building the future today. And that’s a tactical business opportunity – right, Jonathan?!)

More on Interrelated Aspects of Interaction

I got a number of interesting comments on this piece. I think I’m going to follow up in a series of individual posts rather than one big chunk. Jim felt that most of the ideas were XORs rather than continuums (continua?). I suspect that this is because I was trying to pack too many ideas into each axis. Let’s try again.