NetBeans 6 is a big release that we've been working on for quite a while now. The number one thing that developers will find really exciting about this release is that we completely re-wrote the editor infrastructure. This was driven by feedback we got from the community.
The feedback boiled down to people liking the the tools that were part of NetBeans, but they didn't like the editor—it was not fast enough, not smart enough. One of the key focus areas for this release was to fix that problem. When I say we re-wrote it, I don't just mean a few changes around the edges - it's a new infrastructure. When you're using an integrated development tool, that's where you spend a lot of your time, in the editor.
There are several new things at play here. We wanted to build something that was much faster and more capable. For example, we wanted to give people the ability that when they type in the editor, things like smarter code completion for very well and very fast. If you're typing along and on a new line of code you declare a variable of a particular type, and then type an equal sign, and then type in
new, what should come up as possible choices to complete that statement? The editor should be intelligent enough to figure that out based on what's on the left-hand side.
This extends to many other uses cases as well. If I'm not creating a new object, on the other hand, and instead call a method of an existing object, the editor should be smart enough to figure out what options to show, and in what order, based on what's on the left-hand side of the equals sign. Other things include much better code formatting preferences, nice and intelligent things to fix things in the code for you, and many other things that just make life easier for developers.
We are also leveraging the work that folks working on JSR 199 [Java Compiler API] have done, as well as the work on
javac. They made an API available that we can use to parse some of the edited code. That helps us figure out some of the problem areas in the code so that, for instance, we can highlight a line to show a warning or an error. The longer-term payback there is that the next time there are significant changes in language features, we'll be able to leverage their work and get that support for those language features into the IDE very quickly.
Ruby support is leveraging some of the smarter editor infrastructure we've got. For example, the editor is smart about finding all instances of variables in the source file you're editing. This is not just a look at the actual characters in the variable, but is semantically smart about the code. The Ruby editor also provides in-place rename refactoring, smart indentation, and nice hints that allow you to create your code faster. That's going to be a value to anyone in the Ruby world. Also, we have a very nice integration with the Ruby debugger. There is also an integrated gem manager built into the IDE, letting you see what gems you have and allowing you to download new ones.
For Rails, the IDE understands the structure of Rails projects. We also have support for actually creating a different artifacts. Behind the scenes, the IDE runs those generators that come with Rails to create controllers, models, and so on. But you can interact with that from within NetBeans, and there are nice UIs to configure those tasks.