On the XO Laptop

Software’s Firewall, Microsoft

leave a comment »

[First published as Software’s Firewall, Microsoft on November 23, 2007.]

The project that made my reputation in the world of open-source was Jikes, a Java sourcecode to bytecode compiler. It was released in open-source form in December, 1998 as part of IBM’s first open-source project.

Philippe Charles and I wrote the code for Jikes. He wrote most of it. It was built from the ground up, the only code I recall that we Microsoft’s mathematics runtime routines could not be trusted. I think we may have gotten help from IBM’s Alan Webb for that code.)

We started work together in early April, 1997. Philippe had written most of the front end, but he had no way to generate code. I volunteered to write a back end so we could run actual code. We got “Hello world” working by the middle of July.

Our main goal from the start was to learn about Java and also to write an accurate Java compiler.

However, Philippe believed that most folks care more about speed than correct behavior. He was right. For example, look in your rear view mirror the next time you drive a car. So he made the compiler fast. Jikes was written in C++, while Sun’s Java compiler, javacc, was written in Java. From the start, Jikes was 10-50 times faster than javac, depending on the platform. For example, when I used Jikes to work on a Java project back in 2002, I could routinely compile about 20,000 lines of Java in well under ten seconds on a modestly-powered laptop.

We then told a few people about the compiler. Most were impressed by the speed, but we were most impressed to learn that Jikes compiled some things correctly that Javac did not. Also, Jikes detected some errors that Javac did not.

We then realized that, while there were only two of us, we might be able to compete with Sun’s best effort, and so we decided to work on Jikes as hard as we could, for however long it took. That was in August, 1997; we worked continuously on Jikes until the end of 1999, when IBM management told us it was time to move on.

We divided up the work. I suggested that Philippe should only code, as that was what he most enjoyed. I volunteered to write what code I could (I wrote the bytecode generator), and to “do all the other stuff,” though I used a different word than “stuff,” being more earthy, replacing the first three letters by the first letters of my last name, and replacing the final “ff” pair with the letter “t”.

We had completed the first cut at the compiler by the end of 1997 and were ready to release it on IBM’s alphaWorks site when, in early 1998, we were told we would have to pass all of Sun’s Java tests before releasing it (as part of the contract/agreement with Sun IBM had accss to the tests). That took a month or so, during which we found more errors in the tests than the tests found errors in Jikes. This experience, by the way, if why I wrote all those “What if?” posts a year or so ago, pointing out that for Sun to release the source code for Java without releasing the tests was … well I won’t go down that road once again; you can dig up the old posts if you have any interest in Java (I no longer do.)

Shortly before we were told that Jikes would go out in mid-April of 1997 I wrote a short note to Peter Coffee, a columnist for PC Week, as I had read him columns for quite some time. I told him Jikes would be coming out and he might want to take a look.

Peter made mention of Jikes in a piece that was published soon after Jikes was released. The good news was the he said good things about Jikes, and , while the article was mostly about some Java initiative from Sun, it appeared as the main story in that weeks’s issue.

The article made our reputation. Within a week I was asked to give a briefing on Jikes to Paul Horn, then the director of Research (he retired just a couple of months ago).

That was my first briefing to Paul. That experience taught me a very valuable lesson: IBM didn’t appreciate Jikes was good until the world was so. Put another way, IBM didn’t appreciate Jikes was good until the world outside IBM’s firewall told IBM it was good.

Within a corporate firewall, reputation is all. Quality of work doesn’t matter, only the quality of the reputation. Though the two often go together, it is hard to get recognition for quality work if you don’t yet have a reputation.

This results in a corollary of Parkinson’s Law that applies to projects in large corporations. Once a project reaches a certain critical size you know it will succeed no matter what, for management will never admit it backed a loser. (The moment of truth comes when you see the good folks fleeing the sinking ship, though a few usually linger on to receive some of the awards that all know will be given shortly before the project is pronounced a great success… and then allowed to gracefully sink into oblivion.)

Outside the corporate firewall, only the quality of the work matters. Few know your internal reputation, and even those who did will judge you by the work. If they find it flawed they will move on to better things.

This, by the way, is why alphaWorks, is such a good idea. [1] It provides a way for the world to tell IBM what works.

A couple of years later I was involved in another open-source project. It lasted only a couple months oafter we released it outside the firewall, as it turned out the other developers, including the project leader, had a philosophy of “Design Until it Drops (DUD),” while I was in the “Release Early, Release Often (RERO)” school. (See On designing software: DUD, RERO and BLOAT.)

My next encounter outside the firewall came briefly in early 2006 when I wrote the first of about thirty posts in this blog in a period of a few weeks. I stopped blogging by the end of March, and only resumed blogging in September, 2006. That blogging, which has continued to this day, was part of a decision, based on the Jikes experience, to work outside the firewall, as I had not had much success working within IBM’s firewall finding people willing to volunteer. By the way, I haven’t had much success outside the firewall getting people to volunteer, but I now realized you can’t expect to volunteer, no matter how noble the cause. You just have wait until someone decides to step forth.

Almost all the volunteer work I have done in the last year or so, work that has resulted in writing close to six hundred blog posts, have been about promoting the use of open-source and other open technologies to, as I put it, “help educators and librarians in their vital mission.” I do believe they should only use open-source; I just think it should be presented to them as one way to possibly reduce the cost of what is known as “IT infrastructure,” a polite way of saying, “The Microsoft Tax.”

This volunteer work can be summarized briefly as follows.

From October, 2006, to March, 2007, I worked mainly in the college/university space. I was asked in early March of this year to prepare a presentation for k12 educators and librarians. Being new to this space I spent several weeks learning more about it. As part of this work I realized that k12 was much more in need of volunteers than the Sakai and Kuali folks (the major university open-source efforts underway these days) as universities have professors, law schools, discretionary resources in terms of staff and graduate student’s time, and so forth.

The main lessons I took away from my work in k12, including preparing the May talk, a visit to two school districts in nearby Connecticuty, several months of participation in the K12OpenTech Technical Advisory Board, and the recent k12OpenMinds conference in Indianapolis this past October, are:

  • Education is in wretched shape, especially in large, poor, urban school districts. This is not news, just the continuation of decades of neglect. Schools are strapped for resources, and have no capital funds to innovate.
  • Promoting open-technologies is hard because it must be done at the retail level. There are over 17,000 school districts in the United States; for example, there are over ten school districts within ten miles of my house: Chappaqua, Mt. Kisco, Briarcliff, Ossining, Pleasantville, Bedford, Armonk, Bedford Hills, Yorktown, Somers, Katonah, Hawthorne, Valhalla, and I’ve probably forgotten a few others). Most are quite small.
  • Microsoft software is established, and will be hard, very hard, to dislodge. School districts have little knowledge of open technologies such as open-source, don’t have the resources to conduct experiments, and lack the resources to provide basic training in new technologies. There is thus a strong incentive to go with what is in place, even if it is known to be lacking. By the way, the nation’s school districts have decided to put off moving to Vista as long as they can, knowing both that it isn’t significantly better than Windows XP; more importantly, they can’t afford the expensive new hardware that would be needed to run Vista.
  • There are only a few case studies about the successful use of open-source and other open technologies in k12 schools. This makes it even harder to promote these technologies.
  • The available open-source stack is quite, more than “good enough” for almost all schools, at least at the simplest level, where thin-client solutions relying on providing just internet access via a browser and perhaps a few other core programs more than suffice for most students. However, selling it remains hard, for all the reasons cited above.

The K12OpenMinds conference did offer some hope. This was the first national conference that brought together educators and open-source experts. Over 300 people attended. Most were educators, as I estimate that less than ten open-source developers were present (I was one of them, attending on my own time and my own dime, as a volunteer), and at most twenty or so others were well-versed in open-source issues.

Indeed, I went away from the conference quite excited, and soon concluded that I could spend an entire year, until the next conference, working on just the opportunities that came may way while at the conference. I do plan to attend the nextconference, and have recently volunteered to serve on the program committee.

However, the work to promote open technologies in k12 in this country will take years. I would be surprised to see much progress within five years, and I am an optimistic person. The main obstacle to progress will be Microsoft’s dominant position.

The problem in dealing with Microsoft is that is a great company that has achieved extraordinary success by writing software that has been as commercially successful as it has been awful in design and implementation. I don’t begrudge Bill Gates, Steve Ballmer, and all their colleagues the gigabucks that have come their way. I just wish they had written some decent software while amassing them.

Microsoft’s central position in the software industry has thus made it a central focus of media attention, controversy, and also driven many open-source and free-software advocates to needless distraction, by focusing in Microsoft as the “Evil Empire.” For example, I have been working on open-source for over a decade now, yet the only time I have had a site deny me access, with no appeal, was when I ventured to say that lxer.com was being too over-the-top in its attacks on Microsoft. My account was cut off within minutes.

Too many people, including myself, have a “bash bashing Microsoft,” when their time could be better spent using the “bash” shell to write code to compete against Microsoft’s

I have often said that open-source is all about fun, and if you aren’t having fun then something is wrong, and you should fix it..

However, the net effect of all the above factors is that there is a “firewall” of distraction, misinformation, and cruddy Microsoft software, that collectively drives most of the discussion of software within the United States, so it hard to have any fun when trying to market open-source software against Microsoft.

However, there is now an opportunity to do really meaningful work on free and open-source software that could have a global impact, and in a space where Microsoft will be at best a weak competitor. For we now have at hand the XO Laptop, an instance of what I call a “terraputer,” a global computing platform based on free and open-source software.

We need no longer rely on commodity Intel “white boxes” to do battle with MS. We have our own box, our own laptop, the first terracomputer, and we can use the terracomputer to bring the benefits of the open-source “stack,” the software packages that have taken us over twenty years to put together, with a value that is at least five billion dollars, to work, for the most part, outside the Microsoft firewall, until we have learned enough to make another go at bringing that wall down.

1. alphaWorks was the creation of Irving Wladawsky-Berger. Known within IBM as IWB, Irving recently retired. His is one of the best blogs around, period.


Written by daveshields

December 12, 2007 at 2:37 pm

Posted in xo-laptop

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: