Happy Birthday NetBeans -- interview with Jaroslav "Yarda" Tulach

Roman Strobl: Yarda, please tell our readers who you are, and what your role in the NetBeans project is!

Yarda: My name is Jaroslav Tulach and I am the "enfant terrible" of NetBeans.

Roman: Ugh, what is that?

Yarda: That is French and it means the "terrible child" of NetBeans.

Roman: Well, OK, can you explain what that means?

Yarda: Basically it means that I'm always unsatisfied with something and I make other people's job more difficult, e.g. by forcing them to write tests, design API's properly, and so on.

Roman: Sounds like an important job. How long have you been with NetBeans and what is your official role?

Yarda: I'm one of the founders of NetBeans, the company that got acquired by Sun later, and I am the last founder who still remains with the NetBeans project. I was also part of the group which started the original student project in 1996 at the Faculty of Mathematics and Physics of Charles University. So I have been with NetBeans since its beginnings.

As for the official role, I work at NetBeans as an architect.

Roman: How did the project get started? Tell us about its history.

Yarda: Originally, there were 7 of us working on a student project at school. We worked on an IDE written in C++ and it was aimed for Unix, so we called it Xelfi (meaning Delfi for uniX). We've been trying to create the IDE for a year or so, but we had little success. I got the idea that we could rewrite Xelfi in Java and got ridiculed for it at first, but after 6 months or so we started to code Xelfi in Java 1.0.2.

Roman: How did it go?

Yarda: It was terrible. As it is usual for many student projects, nobody led the project, so we didn't really get things done. But at the end we managed to get it into a demoable state, we've demonstrated it to our teachers and got excellent grades for it. One of the reasons for the success was probably that the teachers weren't able to install Java at that time and the screenshots looked pretty good.

Roman: What happened next?

Yarda: Well, we tried to make some money on this product, so we offered it as shareware on the Internet for $20 USD or so. At that time it was quite successful, we had an advanced form editor and a debugger, and we made nice money as students. Roman Stanek, a Czech entrepreneur noticed our product and offered us cooperation, so we founded the NetBeans company.

Roman: Interesting. Why is NetBeans actually called NetBeans?

Yarda: NetBeans basically stands for network JavaBeans. The original proposal defined how to describe network elements using JavaBeans. We got very much inspired by BeanContext, which was just being designed at that time and defined encapsulation of JavaBeans, their communication, and so on. So we wanted to create an abstraction of the network and allow people to manipulate it from any IDE (we would provide plug-ins for all popular IDE's). But it was very hard to extend the IDE's at that time because they didn't implement BeanContext (it was the time of JDK 1.2 in 1997) so at the end we decided to create a full-blown IDE. We already had experience from our work on Xelfi.

Roman: How did the design and implementation of the IDE go?

Yarda: At first, we needed to decide which GUI toolkit to use. We had basically two options: Swing, or a GUI toolkit from Microsoft for Java called AFC (Abstract Foundation Classes, Microsoft supported Java at that time!). Swing was at that time available in version 0.6, and it was very slow, so it was a tough decision. Finally we decided to create an abstraction for the GUI, so we created a bridge and the first implementation was done in Swing. But we had an open door to implement Microsoft's GUI toolkit in case Swing wouldn't be good enough. This way we created the GUI toolkit-independent components you can find in the NetBeans architecture till today: explorer, nodes,
views, etc.

That was in late 1997, and we created a beta version for Java One in 1998, and we still didn't have a name for this IDE. Roman Stanek, who unlike us had executive experience, was leading the team, and one day he said: "Let's choose the name for our IDE. Each of you developers has 1 vote, and I have 50 votes." (The whole company had around 30 people at that time). And he decided about the name of the product, but we found out that we couldn't use it because it was an existing trademark. Thus we searched for a different name and we remembered the "network javabeans" proposal I wrote some time ago. So NetBeans actually had nothing to do with the IDE we were building, but we decided to use it because we all liked the name.

Roman: And then Sun decided to acquire NetBeans, right?

Yarda: We presented the first beta of NetBeans 2.0 at Java One in 1998, and Roman Stanek was able to get Jonathan Schwartz to our stand and I showed him a quick demo of NetBeans. At that time Jonathan was not Sun's CEO. He was responsible for making decisions about acquisitions of companies in the Java technology area. I am glad he decided to acquire NetBeans in 1999 and I am glad that he is now the CEO of Sun. It really helps that he is aware of NetBeans project and I feel he is our strong supporter.

Roman: What happened next?

Yarda: In 2000, Sun decided to open-source NetBeans, which was quite a radical step -- Tim Boudreau can tell you more about the firedrills -- we had to get the source into the public domain in a few months. It was a good lesson for us, because we didn't have a lot of experience working with a community, so we learned a lot during this period.

Roman: NetBeans is not only an IDE, it is also a platform. Was it architected this way from the very beginning?

Yarda: Absolutely! We were creating the IDE to sell it in the nineties, so it was important for us, because by building a nice platform, we wouldn't make any money. But at the same time we did things in a generic way, so that people could build on top of NetBeans. We had things like filesystems from the beginning. These were necessary to create an abstraction layer on top of files and add support for change notification events when working with files. I actually copied most of the concepts from OS/2. If you look at the datasystems API for example, you will find out they are almost the same as in OS/2! At the time of NetBeans 2.0 (2.0 was the first version named NetBeans, the first version of the IDE was called Xelfi), we had the platform, but nobody used it, so it was bound to the IDE.

In version 3.0, the platform got separated better, but only at the time of NetBeans 3.4, people started to build applications on top of NetBeans. We were obsessed with compatibility, and although few people built applications on top of our platform, we thoroughly thought about any API change we made.

Roman: Why do you think there were not so many people building on top of the platform at that time?

Yarda: Because it was hard! The most difficult part was to actually build the modules, and although some people like Rich Unger wrote tools to do that, it was not well supported in the IDE. This has all changed in version 5.0, where we made it easy to build modules, provided many wizards and other support for modules and for building on top of NetBeans.

The platform has always been very important for us and its compatible evolution as well. The evolution was easy to control in 1999 when I was the only person who designed the APIs. This has become much harder as NetBeans evolved and more and more developers started to build the APIs. For a while we were struggling with this and did not know what to do. We tried a lot of ways, but at the end we found out that we need to encourage all the developers to write tests. We also created lots of tests which are executed automatically such as tests for method signatures and other means to check that the APIs do not change.

Forcing people to be precise when writing API was one of the activities that won me the "enfant terrible" title. It is really hard to convince people that tests are a must, otherwise our APIs and other work will never be good enough. On the other hand, at least I have something to talk about now. This year I had a BOF at JavaOne called "Test patterns in Java". Also I wrote an in-depth document about this topic, so if you are interested in building high-quality thoughtfully tested applications, read my document about test patterns.

By the way, if you are interested in the topic of designing good APIs, come to OOPSLA 2006 in Portland, Oregon, where I will speak about this topic together with Tim Boudreau.

Roman: What are your favorite features of NetBeans?

Yarda: NetBeans is a platform and I'm very happy about it. If you build applications today, modular architecture is a must. You can benefit heavily from reusing the NetBeans platform. So that's my most favorite feature.

Roman: Is there anything you miss in NetBeans?

Yarda: Until yesterday I missed the command line interface to NetBeans. The API was approved just yesterday so now you can control the platform easily from the command line. You can benefit from reusing NetBeans platform even if your application has no GUI. [Note: The command line module is available on the Auto-Update Center.]

The second area is debugging. There are a lot of threads running in NetBeans, and I would like to get better support for such complex use cases in the debugger.

Roman: Where do you think NetBeans is heading?

Yarda: I think NetBeans will play a bigger role at Sun - you can hear Jonathan Schwartz talking about NetBeans a lot these days. Modularization of the Java platform is very important, there's a relatively new JSR 277 - the module system for Java. You can be sure that NetBeans will support this JSR, there's a lot of need to write modular applications. Java needs to have a good answer for modularity.