Updated Eclipse toolkit shines: review

Documentation for the Eclipse platform rightly describes it as “an IDE for anything, and for nothing in particular.” Eclipse is written in Java, and Java suits Eclipse’s extensibility well. But such easy extensibility is fertile ground for overgrown features.

Eclipse is the umbrella name for three related projects: the Eclipse Project, the Eclipse Tools Project, and the Eclipse Technology Project.

The Eclipse Project oversees development of the Eclipse IDE platform and the JDT (Java Development Tooling) – a Java development environment built on the Eclipse platform. It also sets the code and specifications for the plug-in development environment.

The Eclipse Tools Project coordinates many development environment implementations on the Eclipse platform, including CDT (C/C++ Development Tool), which creates a C/C++ IDE out of Eclipse; a GEF (Graphical Editing Framework); and – hold your breath – a COBOL IDE. Further along than the GEF and the COBOL IDE, the CDT already ships with an editor, a debugger and a number of wizards.

Finally, the Eclipse Technology Project scouts future directions for the Eclipse platform.

For my purposes here, I focused on the Eclipse SDK, the product of the Eclipse Project. The SDK includes the components and tools that would be used by someone interested in working with the Eclipse IDE, either as a user or as a developer hoping to extend the IDE’s capabilities. Users and developers alike will find welcome additions in Eclipse SDK 2.1.

New Editing Powers

Eclipse SDK 2.1 comes with the platform, the JDT, and the plug-in development environment. The JDT is a reasonably complete Java IDE, really an embodiment of the Eclipse platform. I explored the new features of Eclipse 2.1 using the JDT.

Many new features of the 2.1 platform revolve around improved editing capabilities. Some enhancements are small but useful, including visual cues such as line numbers and current-line highlighting in the editor itself. Others are navigational improvements. For example, the platform now provides a browser-like back-arrow that returns you to previous edit sessions as you move from one source file to another.

A more substantial change involves how the navigator window tracks the current editing target. Previously, Eclipse synchronized the navigator to the editor automatically. Move to a new document in the editor, and the current position in the navigator view changed to match the move. Although this was usually the preferred behaviour, it was occasionally confusing. Eclipse 2.1 lets you sever the implicit connection between navigator and editor so your position in the navigator stays put as you leap among source files in a project. The “Show In” menu selection lets you resynchronize if you’ve leapt too far.

Improvements to JDT are also related to editing, though within the context of a Java development environment. A good example of this is the expanded “quick fix” capability, an automated activity provided by the IDE to accelerate necessary but tedious text-entry chores. You can call on a quick fix to create a missing constructor, add missing catch or throws declarations, conjure stubs for as-yet unimplemented methods, and so on.

Quick fixes clean up some compiler detected errors such as a nonstatic method attempting to access a static method, or an instance field being declared in a static method. It can also detect errors prior to compilation, such as unused variables or uncaught exceptions.

“En masse” editing is also improved in Version 2.1. Rename an identifier, and the “linked rename” capability will change all occurrences of the identifier in the file.

Beware of IDE Overload

Most of the additions to the Eclipse platform and the JDT are associated with editing, but there are also a host of incremental modifications in code generation (specific to the JDT) and enhancements to the PDE. Many of the latter additions provide tools that help developers discover and navigate among plug-in dependencies. These tools will be most helpful to those who want to write Eclipse plug-ins, but not to the larger group who will use Eclipse as an IDE.

Individually, each addition or enhancement is reasonable, even downright clever. But each adds its volume to an already densely-packed and increasingly daunting UI, which can become overwhelming if you don’t monitor its growth.

It gets a solid thumbs-up, but Eclipse will have to extend itself cautiously, lest it begin to stagger under the weight of all its spiffy features.

I ran both the JDT included with Eclipse SDK 2.1 as well as the more-extensive WebSphere Application Developer Studio built atop an earlier Eclipse version. In both cases, I found the environment so feature-rich that it was difficult just to get started. However, once I became more comfortable with building and testing projects, I could focus on employing some of the automated editing capabilities (such as refactoring) and found the automated features very useful.