A fully integrated development environment is the ultimate toolbox for the software engineer. It combines all the tools necessary for producing software applications into a single, self-contained environment.
Having all tools under one roof provides a workbench for development; integration between tools such as the editor, compiler, and debugger enable code to be quickly assembled, syntax-checked, and debugged. This close integration of toolsets makes for a rapid development environment and avoids the need to work with different and disjointed development tools.
Despite the advantages of toolset integration, an IDE is not mandatory for software development. You can produce applications with a good code editor like emacs from GNU and an Ant build file. In the past, a valid alternative to the services of an IDE was to take a best-of-breed approach to development tool selection and create your own toolbox of top-of-the-line development tools.
The best-of-breed approach has merit, but as IDEs have matured, the tools provided in an IDE now match many of the features of these standalone tools. Moreover, the synergy afforded by having the tools integrated makes them far more effective than when used in isolation.
In the upcoming sections, we examine what features we should expect our chosen IDE to provide for effective J2EE development.
IDE Core Features
A good IDE should provide all the tools and features necessary for developing, debugging, and testing an application. J2EE projects call for an enhanced feature set from the IDE beyond that of conventional J2SE applications. The IDE must contend with multiple file types, additional build steps, deployment concerns, and interaction with J2EE servers. Some products also support the design phase and provide additional modeling features.
Whatever IDE you select, one of the most important selection criteria is whether the product can support the way you work. We have covered software engineering practices that can greatly assist in the rapid development of J2EE solutions. Here is a summary of some of the techniques covered:
Use of multiparadigm development languages such as Jess, Jython, and AspectJ
The importance of frameworks
Modeling techniques with UML diagrams
Active and passive code generation with tools such as Velocity, XDoclet, and Middlegen
Transparent data access with O/R mapping products
Model-Driven Architecture using AndroMDA
Incremental build processes with Apache Ant
The ideal IDE should support us in applying these techniques and working with the products and frameworks listed. In addition, the IDE must also be J2EE-specific and have built-in support for all the J2EE artifacts we are likely to work with.
So, what can we reasonably expect an IDE to provide beyond a standard code editor? The following lists some of the core features an IDE should offer for J2EE development.
Support for syntax coloring for different languages in code editors was seen as a major step forward in editor functionality when it first appeared. Now syntax coloring is an expected feature. A good editor should intrinsically understand the language it supports, offering such features as code assistance, instant error detection, source formatting, and essential refactoring capabilities.
Passive code generators can remove much of the drudgery from development tasks. The IDE should provide wizards and code templates for standard tasks such as creating Java classes and Enterprise JavaBeans. Code wizards that allow code for common design patterns to be laid down are a powerful feature in any IDE. In addition, an IDE should support customized wizards implemented by the development team.
The ability to inspect code in a running state is an effective means of investigating defects and understanding the behavior of the executing code. For a J2EE project, debugging support is also required for languages other than Java, with JSP being toward the top of the list. Support for debuggingand remote debugging particularly for J2EE serversis an important feature of an IDE supporting a J2EE development.
To test and debug a J2EE application, it must be packaged and deployed to a J2EE server. The IDE should support this package-and-deploy phase and allow the execution of the target server to be controlled from within the IDE. Control of the server involves not just startup and shutdown, but also having the server executing in a state whereby the deployed application can be tested and debugged.
Quick access to the help on any of the various APIs that make up the J2SE and J2EE specifications removes the need to go hunting through the documentation for the semantics of a particular API call. This feature is an immense time saver and assists the software engineer in selecting the most appropriate features from the API for the current task.
Refactoring code has become a watchword for agile development. Refactoring patterns must be applied consistently across the entire code base. An IDE should support a number of refactoring options, allowing the sweeping changes refactoring calls for to be applied consistently and accurately.
Source control integration.
The use of a source control system, such as CVS, is fundamental to any software development project. An IDE must be able to work seamlessly with your choice of source control repository.
A fully integrated development environment should support the unit testing of components. The ability of an IDE to autogenerate unit tests, run test suites, and report on the success of test runs has gained significant attention since the rise of the XP-style test-driven approach to development.
The use of an IDE for unit testing is covered in Chapter 14.
Reliability and accuracy.
Finally, no matter how long the feature list of an IDE, it must provide a robust platform for development. Few things are more frustrating than losing work due to an unreliable editor.
These features are in no way a comprehensive list, and we should expect to see most IDE vendors providing development productivity features that add additional functionality to the workbench. Such additional functionality might include metrics-gathering, code quality analysis, and profiling support.
To showcase the features we would expect to find in an IDE targeting J2EE projects, the remainder of this chapter concentrates on the Eclipse IDE.
Key Features of an IDE
Language-aware editors offering syntax coloring and code completion facilities
Code wizards for generating program artifacts
Application debugging support
Facilities for deploying J2EE applications
Online help for the J2SE and J2EE APIs
Integration with source control systems
Ability to generate and run unit test suites
High reliability and accuracy