Tomcat’s origin story

The story starts in 1997. I had joined the JavaSoft division of Sun Microsystems to work on the Java Web Server. It featured an extension mechanism called servlets that James Gosling had come up with in 1995. This idea was then implemented by a team led by Pavani Diwanji. By the time I joined the team, the Java Web Server was impressively fast and easy to work with. There was just one big problem: it was a commercial product.

This was a problem because many of the companies that JavaSoft partnered with to support Java as a platform were also competitors: IBM, Oracle, and Netscape, to name a few. These companies were cooperating with JavaSoft to define the enterprise APIs for Java, and they didn’t want to have the reference implementation for these APIs be direct competition for their products. On top of all this, Sun had just initiated a lawsuit against Microsoft around their licensing agreement for Java.

Just a few months after I arrived, JavaSoft put many of its projects, including the Java Web Server, on hold for a few months while the powers that be figured out what to do. Jim Driscoll, one of the developers on the team (not to mention the person who was responsible for me getting hired) called these months “Daiquiri Summer.” Management didn’t want us going anywhere, but without a concrete plan for going forward we kept ourselves entertained the best we could.

After a lot of deliberation, Sun decided to pursue a “church and state” approach. JavaSoft would be the “church,” dedicated to defining and evangelizing the platform. Sun would be the “state” building for-profit products. As part of this decision, the Java Web Server was moved to a group in Sun proper, while the team I was on would remain at JavaSoft to work on many of the specifications that would eventually become Java 2 Enterprise Edition.

Despite the fact that I was a relatively junior member of the team, I was given the task to formalize the Servlet API and steward its adoption with partners. Connie Weiss, my manager at JavaSoft, must have seen something in me. This was both exciting and daunting, especially since the Java Community Process (JCP) hadn’t yet been defined, so I had to make up some of the details about how to do it as I went.

The first step was to reach out to the partners we’d been working with before on the Servlet API and add a few more, including open source developers Jon Stevens, Stefano Mazzocchi, and Pier Paolo Fumagalli to represent the Apache Software Foundation as well as Jason Hunter who was working on a book for O’Reilly about servlets.

The next step was to define what form the reference implementation would take. There was a small subset of the Java Web Server that had been split out to serve as the reference implementation called the Java Servlet Development Kit (JSDK). Given the “church” and “state” separation that we were trying to adhere to, however, I decided that it was best to sit down and write a new reference implementation that wasn’t encumbered by legacy. I also wanted to try to drive the “church” idea a bit further and release the code for the reference implementation as open source.

JavaSoft wasn’t ready to do something that ambitious, and the reference implementation was released as updated version of the JSDK. But people in the outside world quickly dug into the package and found the name I had given it: Tomcat.

Why Tomcat? At JavaSoft, we named our projects with codenames. For example, Java was originally called “Oak.” The 1.2 version of the Java Development Kit (JDK) was called “Playground.” So, when I sat down to start writing the servlet reference implementation from scratch, I had to give it a codename. I found inspiration in the row of O’Reilly books on my bookshelf which all featured animals on their covers. I asked myself what animal I wanted to see on the cover of the book that covered servlets. So I thought of an animal that was small and could take care of itself: a tomcat.

Annoyingly, O’Reilly didn’t use a tomcat on the cover of Jason’s book. Instead of their animals, they decided for a few years to use a different theme for their Java-related book and used a teapot as the cover. When they later reverted back to animals for the second edition of the book, they decided on a European bear. I found out later that they thought using a tomcat would be too obvious. What a miss...

In any case, in addition to asking about the name, people outside JavaSoft started asking if we could release the source code for it as open source. I really wanted to, but for a while the executives at JavaSoft weren’t comfortable at all with the idea. They worried that if we opened up a small thing like the JSDK, it would put more pressure to release all of Java as open source. I thought that would be a positive scenario, but I played the game I was given.

Then, in 1999 the mood shifted a bit. JavaSoft had seen the positive effect of bringing open source developers from Apache, and wanted to expand the partnership. In addition, while I was working on servlets and Tomcat, my colleagues Anselm Baird-Smith and Satish Dharmaraj had created Java Server Pages (JSPs). JSPs were built on servlets and were our answer to Microsoft’s Active Server Pages (ASPs). JavaSoft wanted to make sure that JSPs were successful and in the run-up to the JavaOne annual conference I got the clearance to work with the folks at Apache to pave the way for donating Tomcat to them. I jumped at it and set up face-to-face meetings.

Interestingly, these meetings took place in a conference room in the JavaSoft office in Cupertino called “Jakarta.” So when we decided what to call the project at Apache that would host Tomcat and other Java-related source code, we lifted the name of the room and called it the Jakarta Project.

Now, this wasn’t the only interesting thing to happen in that room. The building it was in was actually Apple’s corporate headquarters from 1982 to 1993. I’ve been told by a few people that the meeting room we called Jakarta was the very same meeting room in which Steve Jobs was ousted from Apple in 1985. If true, that’s a very interesting room, indeed. The building was re-acquired by Apple in 2002 and at one point I had heard it housed the iPod group. I have no idea what’s based there now, but every time I drive by the building, I wonder what else those walls have seen.

In any case, with a JavaOne announcement serving as a forcing function, we were able to work out an agreement. Just a few weeks later, Apache Software Foundation president Brian Behlendorf was on stage for the reveal of the Jakarta Project and the release of an open source Tomcat. It was a huge moment. I couldn’t believe we’d actually done it.

Then reality set in. It took months more work with our teams at JavaSoft to actually ship the code to Apache. While our executives were on board in order to make a splashy announcement, a lot of other people had questions. Some of them valid, others were more... obstructionist. I spent way too much of this time in meetings with legal teams. But in the end, it happened. We got the code out.

Once the code was out there, I took a step back from it. Partly, I was giving space to the open source developers to make it their own. And partly, I was moving on to work on other projects with Danese Cooper in the Open Source Program Office at JavaSoft, including working on the NetBeans acquisition and the open sourcing of the NetBeans IDE. We even took a few runs at getting the Java Development Kit released as open source that didn’t work out until much, much later. But these are all stories for another time.

Tomcat was quickly re-written by a group spearheaded by Craig McClanahan. And over the next 25 years, it has continued to undergo significant development. Despite the code I wrote having been long lost to the past, I’m super proud of what the work I did at JavaSoft became, and incredibly humbled that so many others have put work into it, reimagining and recreating it over the years.

And, I still wonder how the hell a junior member of the Java Web Server team even got the chance to make it happen.