Geertjan Wielenga
Geertjan Wielenga
Safari: For those unfamiliar with these topics, can you briefly tell us what NetBeans is and why it's important?
Wielenga: First, NetBeans is a 100% pure Java desktop development environment for people who program mainly in Java, but increasingly in other languages too, such as JavaScript and Ruby. Second, you can take the infrastructure of the NetBeans IDE, called the NetBeans Platform, and build any other type of Java desktop application on top of it, which saves a lot of time and trouble. Third, NetBeans has a world wide community of actively contributing members involved in contributing anything from code, to tutorials, to discussions on mailing lists and ideas for improvements.
And why is NetBeans important? Well, it helps and supports you when you develop desktop applications, web applications, and even applications for your mobile phone! For example, it tells you when you've made mistakes in your code, and it gives you templates for quickly setting up projects and files. This is useful when you are learning a programming language for the first time. It is also useful in a work environment where you always need to program quickly and efficiently.
Safari: Your new book is titled Rich Client Programming: Plugging into the NetBeans Platform. What do you mean by the term "rich client programming"?
Wielenga: "Rich client programming" is just a fancy term for programming for the desktop. For example, when you start up a calculator application on your computer, in contrast to a web application, you are not making a connection to a server. Your calculator application exists on your computer and does not depend on anything external to your computer. Similarly, when you start up NetBeans IDE, you're starting up a desktop application too. Our book is about creating this type of application, using the infrastructure of NetBeans IDE, which is called the NetBeans Platform, as your starting point. As a result of using this infrastructure, you don't need to create a windowing system, for example, because the NetBeans Platform provides one "out of the box." So, just as NetBeans IDE has a windowing system, allowing you to drag windows to different locations and minimize them into the sides of the IDE, your own desktop application can have this functionality too, without you needing to do any programming at all.
Safari: What distinguishes your book from the other NetBeans books out there? What were your goals in writing it?
Wielenga: There is no book anywhere that does what our book sets out to do. Although there are several books that describe how to do your programming in NetBeans IDE NetBeans IDE Field Guide being the principal one), there are no books that describe how to create your own desktop Java applications on top of NetBeans IDE's infrastructure, i.e., the NetBeans Platform. One book, called NetBeans: The Definitive Guide was written several years ago, covering similar issues as ours, but that book is now out of date.
Since the 5.0 release of NetBeans IDE, creating desktop applications on the NetBeans Platform has become a lot easier. Many of the APIs have been changed and improved, while NetBeans IDE itself now has a lot of tools, such as templates, for working with the NetBeans Platform. For example, if you want to create a new window in your application from the 5.0 release onwards, NetBeans IDE provides a click-through wizard, at the end of which you have a new window in your application. And it has the same functionality out of the box as any of the windows in NetBeans IDE. It is really that simple. So, it was time for a new book to show off all these new features, as well as to show off the simplicity with which one can now create desktop Java applications on top of the NetBeans Platform.
Safari: You've had a lot of experience writing about NetBeans, including being responsible for parts of the Help documentation. What were the biggest challenges in writing Rich Client Programming: Plugging into the NetBeans Platform? Was it more work than you expected?
Wielenga: Fortunately I didn't write the book on my own! I am only one of the three principal authors working on the book, and we were also very fortunate to have a set of actively involved contributors. My co-authors are Jaroslav Tulach, one of the original founders of NetBeans IDE and its platform, and Tim Boudreau, one of the core developers and one of its leading philosophers, as well as being the key NetBeans Platform trainer and co-author of the original NetBeans: The Definitive Guide. Their expertise has really lifted the book to a very high level. My own writing contribution was for parts of the second half of the book, which focuses mainly on editor APIs, such as those dealing with code completion and component palettes. Apart from that, together with Patrick Keegan, one of the other contributors, I "ran" the project, which involved lots of planning meetings and discussions about the content of the book, weekly updates on progress, interactions with the publisher and proof readers, and other organizational matters of this kind.
For me, the biggest challenge on the writing side was the continual question: "What I am writing here works, but does it work in the best possible way?" When there are multiple ways of doing something, it is quite difficult to identify the "most correct one," but that is really the information the reader wants to find in a book of this kind. Not only the "this works" information needs to be covered, but also the information that says, "this is why this works, this is why another way is better, and this is why yet another way is the best approach to take." Mainly thanks to my co-authors, I think there is a very high level of this kind of coverage throughout the book. This was definitely my biggest challenge while writing, because I know that this type of information is exactly what our readership will be looking for.
Overall, it was about as much work as I expected. We were given very limited time and resources to work on this book because there are so many directions that NetBeans needs to develop in at the moment. In about 2 months we completed a very solid first draft, which is really an amazing achievement considering the complexity of the material, the fact that we wanted the book to apply to both the 5.5 and the 6.0 releases, and the number of topics that we wanted to cover. There were a lot less hiccups than there might have been, considering the constraints that we had, and everyone really pulled together and worked as a very strong team. Working in a small group can be a very good thing, especially when you are as focused on the task as we were. We were also very fortunate to have many reviewers throughout the NetBeans community who were very conscientious and critical. That was extremely valuable.
Safari: Let's talk about that. In a sense you opened up your work to a community-wide tech review by releasing early versions of your book via the Rough Cuts program. This early access really pleased some of your readers. Tell us about the Rough Cut program and how it's been working out for you.
Wielenga: Initially, I saw the Rough Cuts program as serving specifically two purposes. First, I saw it as being able to create some buzz for the book. And it did that, definitely. Many people have bought the Rough Cuts version of our book, indicating to us that they want to buy the final book once it is out there. Just having the Rough Cuts version available shows the world that our book is real and not just something that we're talking about. When people use Google to find information about the NetBeans Platform, they might also come across mentions of the Rough Cuts book, which is good.
Second, I saw the Rough Cuts program as an aid for those who need to start their project today, and can't wait for the book to come out. The sooner they get the information, the better. Otherwise they might choose an alternative approach in the meantime. Even though we have many tutorials available, the book encapsulates the whole picture, which is exactly what beginners need, instead of an isolated tutorial that presents one of the pieces of the whole puzzle. So, on this level, the Rough Cuts program worked for us as well, because we know of people and organizations that bought the Rough Cuts book for exactly this purpose. They needed to start their project and couldn't wait until when the book was officially released.
Because there was a period of several weeks between the release of the Rough Cut version and the final date of the proof reading cycle, we were able to handle a lot of comments from people who were reading the Rough Cuts book. Inevitably, errors of various kinds slip through the cracks. Without the Rough Cuts feedback, many more would have slipped through into the printed book than is now the case. People we had never heard of, and therefore hadn't been able to ask to review the book during the review cycles, bought the Rough Cut and fed their comments back to us. And these were people who were actually using the book because they needed it, not just reading it because we had asked them to review it. That added a whole new angle to their review comments. For example, they commented on missing bits of code or explanations that did not quite cover the scenario in question. This unexpectedly added value to the Rough Cuts program for us and really nailed down a few shaky areas in the book, for which we are immensely grateful.
Safari: It's great that providing this kind of early access for your readers created a feedback loop that made for a better book. You also maintain an active blog where you have posted frequently about the book. What kind of feedback have you received there?
Wielenga: Well, the nice thing about my blog in this context was that I could post an update on our progress every now and then, and thereby indicate that we were still hard at work on our promised book! For example, at a very early stage I posted a draft chapter, just to see whether people found the approach taken in the chapter useful or not. And there were many comments to that particular blog entry. That not only improved the draft chapter, but also gave new direction to the book as a whole.
So, one can honestly say that the book was "user-driven," in that the blog's updates resulted in a lot of meaningful feedback that was incorporated in our discussions about where the book was going. For example, some people wrote that we needed more explanations for the code snippets in the book. Others recommended various types of fonts for various types of information. Still others suggested additional topics to be covered, after I posted a draft Table of Contents in my blog. All of this was really beneficial in the planning stages and also after those stages, since we were continually tweaking and adjusting the direction of the book, until it most closely matched the needs coming from the feedback we were receiving from a variety of sources, including those coming from my blog.
Safari: Scripting seems to be becoming more important to Java developers. What does this mean for NetBeans?
Wielenga: For NetBeans IDE, this means that the development environment will continue to be important for Java developers, but increasingly also for those who make use of scripting languages. One very prominent example of the latter is the very extensive support currently being created for Ruby. In fact, NetBeans IDE is clearly becoming the de-facto most complete IDE for developing in Ruby.
For the NetBeans Platform, the increasing importance of scripting languages is translating into a growing need for a simplification of the programming required to provide support features for new languages. Traditionally, in order to provide support for a new language, one would need to implement a large variety of fairly complex NetBeans APIs. Our book, in fact, discusses a very significant number of these APIs, such as the API required for providing code completion and the API for providing syntax coloring. However, from 6.0 onwards, providing language features of this kind will be vastly simplified, with programmers being able to declare the features they want to provide rather than needing to implement them via APIs. This will provide the framework allowing a far larger variety of scripting languages to be supported in NetBeans IDE than is currently the case.
Safari: What part of the NetBeans Platform do you think developers have the hardest time with and why?
Wielenga: The hardest thing for beginners to understand is the breadth of the NetBeans Platform, i.e., what do we mean by the "platform" concept, what is the total list of features that are supported, and what can it really do for me? And with this book we're really hoping to fill this gap of understanding, so that people will really get the purpose behind the NetBeans Platform and the range of features it offers. For slightly more advanced users, those who understand what the NetBeans Platform is supposed to deliver but who don't quite know how it does so, our book goes into a lot of very practical depth in answering the questions relating to the implementation of the features provided by the NetBeans Platform. Implementation tends to be a stumbling block, because once people know what the NetBeans Platform provides, they want to know how they should go about implementing those features. This is definitely covered in a lot of detail in the book.
Safari: Are you involved in the NetBeans Day at this year's JavaOne conference? Tell us a little about that event.
Wielenga: I'm not personally delivering presentations. However, in addition to hoping to bump into a lot of people I've only met online but never in person, I'll be there with a big stack of copies of
Safari: What else are you looking forward to at JavaOne this year?
Wielenga: There's going to be a session by my co-authors, Jaroslav Tulach and Tim Boudreau, about the NetBeans Platform. I'm really looking forward to this. I'll also be doing a presentation there, together with Dave Koelle from JFugue, about the JFugue API and the NetBeans Platform application that is built on top of it. Apart from that, I'm looking forward to anything about Groovy and Grails, which are becoming my new areas of interest. I've been to JavaOne once before, last year, and I've learned that you really need to book the sessions you want to attend in advance, because they fill up really fast. So, planning the sessions I'm going to attend will be one of the things I definitely want to do!
