Updated Eclipse toolkit shines

Eclipse SDK 2.1 leverages Java’s strengths in IDE toolkit, but beware of too much expansion

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 suites 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 (see “Understanding Eclipse’s architecture,” page 43).

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 of the 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 behavior, 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. Remove a statement or block of statements that might otherwise disrupt the indentation of surrounding text, and indentation is automatically corrected throughout the file.

Refactoring and Hyperlinking

Eclipse’s refactoring abilities have been boosted as well. These are automated editing activities that occur if you make an alteration that has ramifications beyond the line you’re currently editing, such as moving a method from a subclass up into its parent or creating an interface based on a class definition.

Not only do the refactoring tools save typing time, but they ensure that the alterations — which could span several source files — are made so that “referential integrity” is maintained throughout the project.

Eclipse 2.1 cleverly employs hyperlinking for quick inter- and intrafile navigation. Hold down the Ctrl key while the mouse hovers over an identifier (class name, method name, etc.), and the identifier turns into a hyperlink; click the hyperlink and you’re transported to proper source file and line where the identifier is declared.

In the debugger, when an exception is thrown and a stack trace erupts in the console, hover over a line in the trace, and it becomes a hyperlink. Click on the hyperlink, and the associated Java source file opens already positioned to the proper line.

Hyperlinking through stack traces is not the only debugger improvement. Deadlock detection has been added, so the debugger can now show which threads are holding monitors and which threads are waiting on monitors.

The debugger’s conditional break points have also been refined. In the past, a conditional break point was triggered when a specified expression evaluated to “true”. Now a conditional break point can be triggered whenever a specified expression’s value changes, allowing more versatility.

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.

InfoWorld Scorecard
Performance (20.0%)
Setup (10.0%)
Ease of use (30.0%)
Value (20.0%)
Reliability (20.0%)
Overall Score (100%)
Eclipse 2.1 SDK 8.0 9.0 7.0 9.0 9.0 8.2
Mobile Security Insider: iOS vs. Android vs. BlackBerry vs. Windows Phone
Join the discussion
Be the first to comment on this article. Our Commenting Policies