Quite poor
testing
Tutorial Details:
Updated Eclipse toolkit shines
Updated Eclipse toolkit shines
By: By Rick Grehan, InfoWorld Test Center
Eclipse SDK 2.1 leverages Java's strengths in IDE toolkit, but beware of too much expansion
ocumentation 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 (Common Business Oriented Language) 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 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 (PDE). The JDT is a reasonably complete Java IDE, really an embodiment of the Eclipse platform. I explored Eclipse 2.1's new features using the JDT.
Many of 2.1's new features 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 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, and so on), and the identifier turns into a hyperlink; click the hyperlink and you're transported to the 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.
How We Tested
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.
This page formated for crawlers and browsers that don't support scripts and tables.
Home
EZone
Read
Tutorial at: Click here to view the tutorial
Rate Tutorial: Quite poor
testing
View Tutorial: Quite poor
testing
Related
Tutorials:
 Commercial applications with Java
Commercial applications with Java
|
Java decompilers
compared - JavaWorld - July
1997
Java decompilers
compared - JavaWorld - July
1997
|
Accelerate your Java apps! - JavaWorld - September 1998
Accelerate your Java apps! - JavaWorld - September 1998
|
JavaWorld Developer
Tools Guide: Testing Tools
JavaWorld Developer
Tools Guide: Testing Tools
|
Alternative deployment
methods, Part 1: Beyond applets - JavaWorld May
2000
Alternative deployment
methods, Part 1: Beyond applets - JavaWorld May
2000
|
Design for
performance, Part 1: Interfaces
matter - JavaWorld January
2001
Design for
performance, Part 1: Interfaces
matter - JavaWorld January
2001
|
J2EE project
dangers! - JavaWorld March 2001
J2EE project
dangers! - JavaWorld March 2001
|
Master Java with these introductory books - JavaWorld May 2001
Master Java with these introductory books - JavaWorld May 2001
|
I want my AOP!, Part 1
I want my AOP!, Part 1
|
Put Java in the fast lane
Put Java in the fast lane
|
Best tools for
mobile application development
Best tools for
mobile application development
|
Java tools reign
supreme - JavaWorld celebrates the
leading Java tools
Java tools reign
supreme - JavaWorld celebrates the
leading Java tools
|
Quite poor
testing
Quite poor
testing
|
Bug patrol
Bug patrol
|
Java Testing and Design
Java Testing and Java Test and Design is the companion to any book on Java software development practices, techniques, and testing. Software developers, QA analysts and IT managers working in large corporate IT groups, software development companies, and
|
Martin Fowler\'s usual terrific writing
The term 'Mock Objects' has become a popular one to describe special case objects that mimic real objects for testing. However the term mock was not originally meant as a more catchy name for stub, but to introduce a different approach to unit testing. In
|
Testing J2EE applications
Testing J2EE applications
There are certain aspects of J2EE applications that people associate with end-to-end tests rather than object tests. These include page flow—or navigating a Web application—and using container services, such as security and
|
JDemo: Interactive Testing Refactored
This article will introduce the JDemo framework and its techniques for writing code for interactive testing. It will also show the benefits that can be gained from writing demo code.
|
A lightweight nonintrusive EJB testing framework
A lightweight nonintrusive EJB testing framework
Summary
This article presents a simple, easy-to-deploy framework that enables fine-grained tests to be run on the container, making it possible to develop and maintain Enterprise JavaBeans components usin
|
Introduction to JSP
Introduction to JSP
Introduction to JSP
Java Server Pages or JSP for short is Sun's solution for developing dynamic web sites. JSP provide excellent server side scripting support for creating database driven web applications. JSP enable the
|
|
|
|
