Companies that are making the transition to an On Demand IT model can speed the process with an integrated development environment (IDE) that enables rapid development of Web, Java™, and Java 2 Enterprise Edition (J2EE™) solutions. IDEs that contain rapid application development tools automate many time-consuming development tasks. The best ones are easy to learn and can maximize productivity for developers with diverse backgrounds.

This article describes how an IDE consisting of IBM WebSphere® Studio and IBM Rational® Developer products can help speed up both Java/J2EE adoption for IT shops new to these technologies and the development process for shops already well-versed in Java technologies. We will focus primarily on IBM Rational Web Developer for WebSphere Software Version 6 (formerly known as IBM WebSphere Studio Site Developer) and IBM Rational Application Developer for WebSphere Software Version 6 (formerly known as IBM WebSphere Studio Application Developer). For brevity's sake, we will refer to Rational Web Developer and Rational Application Developer collectively as Rational Developer.

The Java platform has several basic advantages: It enables portability across platforms and operating systems, maintains open standards, promotes reuse via an object-oriented model, and simplifies construction and deployment of multi-tier applications.

Most IT shops recognize the desirability of using Java technology, but many are hampered by a lack of Java skills or daunted by the complexities of multiplatform applications that access heterogeneous systems. With respect to Java, most developers fall into three categories, each with its own challenges:

Novice Java developers. Experienced Java professionals come at a high price, so many companies want their current employees to learn Java skills quickly. Developers trained in client/server programming technologies, such as Microsoft® Visual Basic®, are scrambling to get up to speed on the Java language, especially J2EE technology. The main reason behind the popularity of Microsoft Visual Basic is its intuitive, point-and-click features for visual composition and object instantiation. Until now, Java technology has not offered any equivalent, and the transition has been difficult for Visual Basic developers.

Legacy procedural developers. Many companies have procedural programmers who possess a wealth of knowledge about the company's business, legacy systems, and databases but lack the object-oriented skills required to develop new e-business solutions. These developers are proficient in COBOL, RPG, C, or other procedural languages. They might also be well-versed in mainframe subsystems, such as IBM CICS® or IBM IMS.™ However, typically they are not trained in object-oriented programming.

Expert Java and J2EE developers. Developers already proficient in Java, J2EE, and Web services technologies are hindered by having to do tedious, repetitive coding of low-level programming interfaces that have nothing to do with an application's business requirements. Often, they must devote large amounts of time to ensuring a sound application design, verifying application performance and throughput requirements, and resolving the most elusive and obscure application failures. A tool that automates these tasks can significantly boost the productivity of expert developers.

IBM Rational Developer: A versatile solution for all Java developers

Enterprises with developers who fall into all three skill categories need a development environment that will support the entire team's work effectively. They also need a tool that allows non-programmers, such as user interface (UI) designers and information developers, to quickly develop artifacts within the same environment as the development team. IBM Rational Developer provides functionality that addresses the challenges facing every type of Java developer. Below, we will detail its unique advantages as an IDE. Let's begin with the broadest advantages.

Back to top

Part of the IBM Software Development Platform

The IBM Software Development Platform (SDP) is a set of integrated tools, best practices, and services that support a proven, end-to-end process for the application development lifecycle. Rational Developer works with other SDP tools to support structured application development, including modeling, proven design practices and patterns, and an iterative development process that helps ensure that applications meet user requirements.

Back to top

Based on the Eclipse platform

Eclipse is an open source, Java-based, extensible development platform for tool integration. Eclipse-based tools give developers freedom of choice in an environment supporting multiple languages, platforms, and vendors. Eclipse delivers a plug-in-based framework that makes it easy for teams to create, integrate, and use software tools together. Rational Developer is IBM's core application development offering based on Eclipse 3.0. It provides a comprehensive and productive application development environment for creating and maintaining J2EE-compliant enterprise application systems. It also includes many features not available in Eclipse. And because Rational Developer is built on Eclipse, development teams can adapt and extend their development environment with best-of-breed plug-in tools from IBM, IBM Business Partners, and the Eclipse community to match their needs and maximize developer productivity.

In addition to providing an open source IDE for coding applications, Eclipse also serves as a platform for building application development tools. Table 1 gives a quick overview of the features that Rational Developer provides beyond those included in Eclipse 3.0.

Table 1: Rational Developer features that supplement Eclipse 3.0

Back to top

Provides a complete family of tools

WebSphere Studio and Rational Developer offer multiple configuration possibilities to ensure that your IDE grows with your company's needs. As your e-business application requirements grow from simple Web applications to complex, integrated, cross-enterprise business solutions, your developers' skills are still applicable, and your investment remains protected. The core Rational Developer configurations provide progressive functionality as you move up the ladder; for example, Rational Application Developer contains all the functionality of Rational Web Developer.

• Rational Web Developer for WebSphere Software (formerly WebSphere Studio Site Developer) is an entry-level IDE for Web and Java developers. Useful primarily for building JSP and servlet-based Web applications, Java applications, and Web services, it provides visual development with JavaServer Faces components and EGL for generating Java code.
  
  
• Rational Application Developer for WebSphere Software (formerly WebSphere Studio Application Developer) supports more advanced J2EE development, including Enterprise JavaBeans (EJB) components. It supports portal and UML-based development, and contains IBM Rational ClearCase® LT for version control. WebSphere Studio Application Developer Integration Edition is another version of Rational Application Developer. It helps enable accelerated development and integration of composite business applications that deploy to the IBM WebSphere Business Integration Server Foundation. It provides a broad portfolio of rich application and technology adapters and J2EE-based visual workflow tools.
  
  
• WebSphere Studio Enterprise Developer adds support for COBOL and PL/1 development and for the development of applications that target legacy back-end systems, such as CICS and the IBM ~® zSeries® family of servers. It also provides EGL code generation that outputs COBOL source code.
  
  

The capabilities of Rational Web Developer and Rational Application Developer are also incorporated into Rational Software Architect. Rational Software Architect adds support for: UML 2.0 modeling, patterns, model transformation, and code generation; C/C++ development; and Java application structural review and control.

This article focuses on the rapid application development features of Rational Web Developer and Rational Application Developer.

Back to top

Increases developer productivity

The following basic design principles behind Rational Developer decrease the Java learning curve and increase programmer productivity:

1. Hides complexity from novice users. Using a series of perspectives, Rational Developer selectively offers users various tools, based on their role in the development team, project, or task at hand. All perspectives share a common look and feel, which reduces the learning curve and helps developers organize complex projects and focus on the task at hand. These perspectives are particularly beneficial to novice Java developers, who may need to access only a subset of the many capabilities available in the rich Rational Developer environment. Since it is based on Eclipse 3.0, Rational Developer can take this idea a step further: Eclipse provides capability to show features in a view only when a user actually needs them (progressive disclosure). Advanced users can also customize their perspectives to show either the tools they use most often or other plug-in tools not included with the base product.
   
   
2. Speeds development by eliminating tedious tasks. For more experienced Java and J2EE developers, Rational Developer automates many of their tedious, routine tasks. It automatically creates a program structure that conforms to J2EE standards as well as configuration files for specific types of projects, such as Struts and portlets. Rational Developer can also create skeleton entities for business logic, such as Web services and EJB components. Wherever possible, Rational Developer wizards and editors generate page-handling and component interaction code, allowing developers to focus on application functionality rather than low-level "plumbing."
   
   

Back to top

Streamlines all aspects of Web application development and maintenance

Now that we have discussed the general advantages of Rational Developer, let's look at the specific advantages it offers Web development teams.

Rapid Web application development

Rational Developer provides many features to speed up the development of interactive, form-driven Web applications. Most Web site development teams include an interface designer or Webmaster, a content creator, and a Web developer (in smaller shops, one person may perform all of these roles).

Rational Developer supports all of these roles. The Webmaster can design the site's overall flow in Site Designer, prototype the Web page layout with the Page Designer tool, and add controls without writing Java code. Web developers with minimum Java expertise can add dynamic elements to Web pages, such as a news feed or a registration application. They can rapidly lay out dynamic Web pages as JSPs and connect to existing databases, all without writing code. If the application will run on a portal server, Web developers also can create portal applications to improve usability and provide customized interfaces for end users. In addition, they can exploit existing frameworks for Web development, such as the Struts framework, which enforces good Web application design principles that make it easier to modify applications.

Easier Web site creation and management

Rational Developer's Web Site Designer tool helps developers create and manage the organization and layout of individual pages in Web sites. They can quickly develop a Web site structure, create a navigation bar and site map, and use page templates to enforce consistent design.

Web Site Designer offers a graphical navigation view to help developers understand how users navigate through the Web site. This view shows the site's pages as a hierarchy and represents their static navigational relationships. It allows developers to add, delete, and move pages within the site. To help developers keep track of pages to be added to the site, the navigation view displays a list of them.

Developers can use the navigation information to automatically generate navigation menus, links, and site maps. When they move pages around, the corresponding navigation links are automatically regenerated to reflect the changes. The resulting menus, links, and maps are in standard HTML, so they can be deployed to any HTTP server. Web Site Designer also lets developers import existing Web sites for redesign. Without this capability, they would have to create each navigation element by hand with a Web page editing tool. In effect, they would manually create page templates without being able to enforce their use.

After they design the site's static structure, developers can use the Web Diagram Editor to create a comprehensive diagram that shows relationships between the site's entities and maps the logic-driven navigational flows. They can use the tool's intuitive features to lay out Web pages, business logic, and data that passes through the application. The site can contain any combination of JSF and Struts elements in addition to regular HTML pages, JSPs, and JavaBeans. With the Web Diagram Editor, designers can visually code navigation between pages and specify simple text links or JSF or Struts logic-driven flows. This functionality not only speeds development for new Web sites, but also helps designers understand the structure of existing sites. Figure 1 shows the Web Diagram Editor.

Figure 1: How the Web Diagram Editor helps speed development of new Web sites

Dynamic Web pages without coding

Rational Developer's Page Designer lets Web designers quickly lay out a Web page using an interface similar to those offered by other what-you-see-is-what-you-get (WYSIWYG) Web editors. It provides tabs for viewing the page in design mode (WYSIWYG composition), source mode (code-level composition), and preview (page displayed as it will appear in the browser at runtime). Novice users can start with one of the many sample Web sites shipped with Rational Developer and modify as needed. They can also use predefined page templates.

Designers can quickly add images, links, and forms to pages by simply dragging and dropping from a palette of components. They can work with images supplied in a prepopulated image library or create their own images -- even animated ones -- from a single workspace. They also can add JSP tags, Java applets, or embedded scripts. These functions let Web designers work with elements that are created by others within the same environment -- by a Java developer or a graphic designer, for example. They can also add a JavaBean to the page and access its properties and methods through a simple, wizard-driven interface.

The source code view in Page Designer provides syntax highlighting and formatting and code assist; designers get a list of valid, context-sensitive alternatives for completing the current tag so that they do not need to look up the syntax.

Many sites use JSP include files to encapsulate common elements used in multiple pages. On each page that calls an include file, Page Designer displays the file's contents to enable quick editing.

Because of its tight integration with other views and perspectives, developers can lay out a Web page in Page Designer, switch to another view to create dynamic elements, such as servlets or portlets and then switch back to Page Designer to add the elements to the graphical use interface (GUI). Then, because Rational Developer provides an integrated WebSphere Application Server runtime environment, designers can test the page immediately within Rational Developer, without having to deploy the artifacts to a server.

Rapid development of interactive Web pages with JavaServer Faces

JavaServer Faces (JSF) is a powerful new presentation standard and framework which, when combined with appropriate tools, significantly simplifies the construction of Web interfaces and applications. Prior to the introduction of JSF, developers had to manually write code to handle almost all user interactions with the application, such as validating input, checking for errors, and validating and converting strings. The JSF framework consists of user interface (UI) components and a runtime that renders these components to the client and manages the page lifecycle (errors, validators, and navigation, for example). Using the visual JSF tools in Rational Developer, you can create rich, dynamic Web sites without writing a single line of code.

Rational Developer provides intuitive wizards and visual UI components for creating JSF files; the wizards do all the set-up work needed to use JSF in an application. Then, Rational Developer's Web Diagram Editor provides help with organizing the application.

Rational Developer provides base JSF components, plus more than twenty additional objects created by IBM that conform to the JSF specification. Among the components are a file upload feature, a rich text editor, charts, tabbed panels, and an enhanced data grid. IBM has further extended some JSF components to download client-side data for a more interactive user experience without time-consuming trips to the server.

Novice developers can use this functionality without working with the generated code, but more advanced Java developers will want to view the source that is generated by the JSF editor. Rational Developer creates code-behind files that contain the page source code, which is dynamically generated as you edit the JSF design surface. There is no additional generate step, so the code and UI design are always in sync. Developers can decide whether to display code-behind files in the Web diagram.

Quick addition of dynamic data to Web pages

Rational Developer makes it easy to access, create, display, update, and delete dynamic data in Web pages. Data objects can encapsulate a data source located in a relational database, a JavaBean, an EJB, or a Web service. The Service Data Object, or SDO (previously known as the WebSphere Data Object), sits between the Web application and the data source, providing a consistent interface to any relational database, EJB, JavaBean, or Web service.

Developers do not have to write the data-access code; the Rational Developer tools for the SDO write it for them. This means they do not have to create a data bean; they can simply drag and drop the data object on the page, fill in the fields in the wizard, and then design how they want the user to interact with the data (or even let Rational Developer generate the UI). They can work either with a tabular view of several rows of data (a data grid) or in detail, with a single data record. They can then use the JSF data grid to make a row selectable, add columns to rows, set widths and alignments, and even handle paging through data (for example, showing five rows at a time). The data column can contain images, hyperlinks, and more. The generated code helps to ensure that the interactions and data caching with the database are optimized, which alleviates the need to roundtrip to the server each time another row of the table is accessed. Figure 2 shows a data grid created from an SDO. Remember, no coding was needed to create this application, not even for the data connection.

Figure 2: Data grid created from a Service Data Object (SDO) with no coding needed

EJB session JavaBeans can also be directly accessed from a Web page, including EJBs that call SAP and Siebel entities. When an EJB is added to the page, Rational Developer can automatically generate the input and output forms, or developers can design their own through a set of wizards. Rational Developer generates all of the access code and descriptors.

Rapid development with the Struts framework

The Struts open source framework helps separate business logic from user interface elements -- making both easier to maintain -- and provides a proven architecture that performs well for the majority of interactive Web sites. The Struts tools in Rational Developer let novice developers create well-architected Web applications without coding the layout and connecting code. You can even combine the power of the Struts architecture with a JSF user interface.

These Struts tools include a Struts Explorer and the Web Diagram Editor. The Struts Explorer helps developers understand and navigate the various pieces of a Struts application. When you create a new Struts project, Rational Developer builds a Web diagram that shows the application's structure. You can then draw connections that indicate how the application should flow. As you edit the diagram, Rational Developer will update the Struts XML configuration files and generate new Java code.

The Web Diagram Editor can save you time by helping you organize and visualize dynamic Web applications, but the real time-saver is that it generates code when you define a Struts application. Developers only need to write the code to perform the action; all other code for managing the data and passing it between forms is created by Rational Developer and encapsulated in reusable JavaBeans.

EGL generation for Java and Web applications

The Enterprise Generation Language (EGL) provides a 4GL rapid application development environment for developing both Web- and traditional, character-based applications. EGL evolved from IBM VisualAge® Generator to help enable the movement of applications to the Web. Rational Developer extends EGL by incorporating IBM Informix® 4GL constructs and functionality. EGL is the strategic IBM language for providing procedural developers with an evolutionary path to Java.

EGL is a simple procedural language that is comfortable to use for programmers who work with COBOL, Informix 4GL, Oracle Forms, report program generator, and other 4GL technologies. Used with Rational Developer, it enables procedural developers to become immediately productive in Web and J2EE projects, and to rapidly create applications using familiar programming constructs.

Because EGL is integrated into the new JavaServer Faces implementation, developers can rapidly create JSF-based applications with all the page logic in EGL rather than Java. They can drag and drop records and data items defined in EGL onto a JSP while the JSP is being defined, automatically establishing the linkage between the JSP and the EGL data item. All productivity features of the Rational Developer context-sensitive editors and debuggers are supported for EGL. Developers can debug entire applications seamlessly without viewing the generated Java code.

Rational Developer also provides a special server-side event called onPageLoad that lets developers retrieve data and manipulate the UI component tree after it is created, but before it is displayed. Similar to GUI "aboutToOpen" events, this event enables more intuitive controller logic and helps procedural programmers map their traditional, text-based applications to more GUI-driven designs. In other words, instead of having to use an object-oriented approach, these developers can organize programs in a familiar way.

Rational Developer EGL supports rich data, which lets developers define just once all the validation, formatting, and display information for data items. These rules apply wherever the data item surfaces (TUI or page and business logic, for example). The EGL runtime automatically runs the application and displays appropriate messages.

Because the Informix 4GL language supports text-based interfaces only on the UNIX® platform, Informix developers have not been able to connect browser-based GUIs to Informix databases. EGL offers legacy Informix customers an evolutionary path from the Informix Data Server (IDS) to the WebSphere Application Server. A new migration tool that automatically converts Informix 4GL code to EGL language in Rational Developer 6.0.0.1 will ship as a patch, shortly after the 6.0 release.

IBM Rational Web Developer for WebSphere Software and IBM Rational Application Developer for WebSphere Software can generate Java code to deploy to Microsoft Windows,® AIX,® Linux,® and IBM i5/OS™ environments. Enterprise Developer can also generate COBOL code to deploy to the IBM ~ iSeries™ and IBM ~ zSeries families of servers (CICS and batch). EGL also provides connectivity to IBM Informix Dynamic Server, IBM DB2® database management, and other relational database servers through Java database connectivity.

Quick debugging and testing

Because Web application developers spend so much time debugging, Rational Developer is stocked with a very powerful set of facilities for this purpose. All the editors we mentioned above provide a task view that shows visual cues for possible problems, including broken links. A link view also identifies broken links, and the Link Utilities feature can either repair broken links or globally convert links to a new root when an application's directory structure changes. The source code view also provides visual cues to identify possible problems.

When running the application, developers can easily set breakpoints and step through all types of code, including JSPs, servlets, and even JavaScript. They can run snippets of code to view the results before doing full testing, and they can even update code on the fly, while it is running.

Rational Developer comes with an integrated instance of WebSphere Application Server. With a single click, developers can run an application on a test server without the overhead of publishing the application or installing it onto a separate server. They also can view the application running exactly as it would in the target deployment environment.

Rational Developer includes multiple versions of the application server to allow testing of applications that target an older version of the runtime. Using a special toolkit, you can also configure the Rational Developer server test environment to test a Web application on a Tomcat or BEA WebLogic server. Rational Application Developer adds a WebSphere Portal 4.2 and 5.0 test environment.

Rational Developer also supports publishing to remote servers. Developers can configure, start, and interact with WebSphere Application Server defined on a remote system (Windows, Linux/Intel, AIX, or iSeries). The remote server can be either a physically separate machine or another server instance on the same machine, running outside Rational Developer. This lets your team use a single, dedicated test machine to simulate a target production environment with multiple servers.

Rapid deployment

With Rational Developer, deploying a Web application consists simply of configuring a server instance and then publishing the application to that server. You can publish static Web applications to any HTTP server and dynamic applications to WebSphere Application Server, Tomcat, or BEA WebLogic. You can also add new Java runtime environment definitions and target different Java Development Kit levels. Since the robust server test environment lets developers do most of the server-side testing for an application on their client, the actual deployment is usually anti-climactic.

Back to top

Enables rapid development of complex Java and J2EE applications

In addition to Web application development tools, Rational Developer provides many rapid application development tools for programmers creating complex Java applications that require more Java programming knowledge and run most of their logic on the server. These developers work with more complex coding structures and need more control over data access mechanisms. They need tools to help them quickly write JSPs, servlets, portlets, and Web services, and then test them on servers. They also need tools to help them design the overall application architecture and track the various artifacts for their application. And, of course, advanced J2EE developers need tools to help them quickly code business logic, using the EJB component model.

Below, we will describe the capabilities that Rational Developer offers for these development professionals.

Visual programming functionality

Rational Developer provides both a visual editor and a traditional text-based editor. The Rational Developer Visual Editor for Java is based on the JavaBean components model, which defines the interface to a JavaBean through methods, properties, and events. This editor lets developers visually design the GUI components for an application and then implement the necessary JavaBeans to add application functionality.

Unlike other visual editors, the Visual Editor for Java is code-centric; it performs round-tripping of changes between the JavaBeans and the source code. When developers modify JavaBeans, they can see the modifications reflected in the source code. Conversely, when they change the source code, they can see the same changes applied to the JavaBeans. The JavaBeans and source code are displayed side by side, using a split pane. When you select a JavaBean, the source code shows the method that initializes it; when you select an individual property, it shows the statement that sets its value.

The Visual Editor for Java helps developers quickly create Java applications by providing an interface similar to those in other visual construction tools. Layout tools help them quickly prototype an application for user validation and reuse JavaBeans from Swing, SWT, or AWT component libraries, or import them from other libraries. Visual binding tools let developers quickly connect visual components to J2EE artifacts to bind components to data sources (including EJBs, Web services, or JavaBeans). Although developers do not need to understand the details of the binding code, they can modify the generated code to optimize performance.

Faster coding

The text-based Rational Developer Java Editor has several features that accelerate Java development. It provides visual aids, such as syntax highlighting and code assist, for completing the current language element. Because Rational Developer provides automatic, incremental compilation, the Java Editor can provide immediate feedback about code problems, and developers can eliminate many bugs before the program is compiled.

Developers can also reorganize code without having to manually fix all references to specific components. They can re-factor -- change the code while preserving its behavior -- using re-factoring tools that enable reorganization of program elements from any editor, and even rename elements. Rational Developer dynamically updates all references to the code and previews the impact of changes before making them permanent. This process eliminates the huge amount of time and effort developers would otherwise spend locating and changing references in code.

For EJB development, Rational Developer eliminates much of the handwork and helps ensure that the application complies with J2EE standards. It contains several wizards and guides that lead developers through the development process and generates wrappers for most code artifacts.

Rational Developer also simplifies EJB client access by generating common code patterns for creating or finding EJBs with the EJB Snippet Wizard. The Session Bean Fa$e pattern simplifies client access to container-managed persistent (CMP) EJBs. The Session Bean Fa$e is a Session EJB that is created as a client interface and uses SDOs to exchange data with the persistent EJB.

The Java editor recognizes EJB components and offers several extensions, such as a task list, that provide immediate feedback on the correctness of the EJB components and other J2EE artifacts. The code editor verifies that different types of Enterprise JavaBeans are constructed correctly and are consistent with other associated EJBs. Rational Developer also provides special editors for viewing and modifying EJB deployment descriptors as well as tools to create, edit, and validate Enterprise Archive (EAR) files.

To further automate deployment for most EJB patterns, developers can specify deployment information through Xdoclet metadata tags in the Java classes. Rational Developer supports the standard Xdoclet tag set that enables generation of necessary deployment artifacts at runtime, so developers can maintain a single EJB artifact rather than a collection of classes and deployment descriptors.

Rational Developer can generate cross-EAR EJB references and generate EJB components that tie into transaction processing systems -- so developers can quickly turn their EJB components into Web services. Collectively, the EJB features provide a J2EE structure that allows developers to concentrate on coding business logic.

The UML Visual Editor for Java and EJB also increases productivity by providing a graphical view of an application's structure. Developers can implement classes visually and manage the complexity of their programs through intuitive UML diagrams.

Rapid incorporation of data-access and reporting capabilities

One of the biggest challenges developers have faced is the need to integrate Java applications with back-end data systems. The older data in these systems typically has a predefined structure that must be brought into the Java application. In some instances, developers who are not familiar with data modeling must develop the data structures themselves. Rational Developer provides tools that automate much of the coding for both scenarios by importing a data structure from an existing data source or creating a new data model within Rational Developer and exporting it to the actual data source. It also provides a data view to organize all these tools.

Below we will describe just a few of the data tools Rational Developer offers to speed up data management processes in J2EE programs. These tools are not tied to a particular database; most of them support databases from all the major vendors.

Rational Developer delivers tools for visual or programmatic access to EJB data via the SDO. It provides a wizard that generates connection code to let developers visually bind the data to controls on a JSP. It also generates an EJB Session Bean fa$e that lets developers write code to access the SDO datagraph for EJB data.

Rational Developer has additional wizards that help developers quickly create certain kinds of EJB components. In particular, the EJB-to-RDB (relational database) wizard creates entity EJB components from a predefined data structure in a relational database, a process called bottom-up mapping. The tools in Rational Developer import the target data structure and handle all the mappings, which eliminates most of the coding in this type of EJB development.

Rational Developer also provides wizards for top-down mapping of EJB development, for both CMP JavaBeans and bean-managed persistent (BMP) JavaBeans. After defining the data structure, developers can map it to the data source using a simple Map Browser that shows the Enterprise JavaBeans and the database tables side by side. When they drag and drop entities from the EJB table onto the database tables, Rational Developer creates all the underlying mapping code.

These wizards provide incredible time savings in creating and mapping EJB components. Figure 3 shows the Map Browser.

Figure 3: The Map Browser speeds creation and mapping of EJB components.

The SQL Query Builder provides a visual interface for creating and executing SQL statements -- from very simple statements to complex expressions and groupings. It also provides an SQL-to-XML wizard to generate XML artifacts for use in other applications, such as a servlet or JSP.

The Query Builder provides a graphical view of the tables and columns in the database. It lets developers select which columns to work with, link them to specific join operations, and build expressions to qualify the data to be retrieved. Developers can also execute the query directly in the editor to verify that it works as intended, define host variables that the user enters, and call stored procedures from the query.

Fast integration of high-performance data reporting functions

Rational Developer provides a Crystal Reports component so developers can quickly incorporate high-quality reporting capabilities into their applications. Crystal Reports is a powerful framework for designing flexible, feature-rich reports that can access virtually any data source, including XML, JDBC, and enterprise data sources. Extensive formatting options provide complete control over data presentation and make it easy to deliver information in a consumable form for end-users.

The Crystal Reports feature lets developers create dynamic, visual data reports up to 180 times faster than they could with handcoding. They can either design reports within Rational Developer or use predefined report templates that provide a wealth of common chart formats, such as pie, bar, Gantt, and many more. They can also incorporate a JSF report-viewing component that allows them to render reports within Web pages running on their application server.

For larger enterprise reporting requirements, Rational Developer provides a test and development license of the Crystal Enterprise servers (Embedded and Professional). This encompasses a rich set of JSF components for deploying enterprise reporting applications with advanced features, such as security and scheduling.

Quick editing and debugging for SQL stored procedures

For expert developers who require more control over SQL queries, the SQL Editor provides the same features as the Code Editor (such as syntax highlighting and code assist) to help them quickly write their own queries by hand. Rational Developer has special code editors for writing SQL stored procedures and user-defined functions (UDFs) for DB2. The source-level debugger for SQL stored procedures supports all standard Rational Developer debugging tools, which can be run on a server without packaging and deploying the stored procedures.

UML-based visualization and code-editing capabilities

The UML Visual Editor for Java and EJB tool provided with Rational Application Developer gives a graphical view of the code and data objects. It displays code artifacts as Unified Modeling Language (UML) class and sequence diagrams, which show the structure and relationships of Java classes, data objects, interfaces, and EJB components. UML notation is an industry standard for object modeling, ratified by the Object Management Group (OMG). This view of an application helps you organize and document your code so others can use it. Even if you are not familiar with UML notation, the intuitive visual design can help you keep track of complex applications that contain many artifacts.

The UML Visual Editor now provides three categories of diagrams:

• Browse diagrams that help developers navigate their code without needing to create and manage their own diagrams. Just as Web browsers help you surf the Web, browse diagrams let developers explore the web of implementation artifacts in their workspace to discover the code's underlying structure.
  
  
• Topic diagrams that help developers document their code and ensure their documentation stays current. These diagrams query the current state of the application to show relationships between classes and program hierarchy.
  
  
• Edit diagrams that help developers create diagrams of their classes, which they can then use to design and implement aspects of their applications (including Java classes, EJBs, and data objects). These diagrams illustrate the relationships between classes that evolve as developers code the classes.
  
  

All of these diagrams help developers document their implementation and keep the documentation up to date. They can insert both the edit and topic diagrams into Javadoc files to provide a visual map of their program (clicking on any class in the diagram takes the user to the Javadoc for that class). Figure 4 shows a browse diagram.

Figure 4: Browse diagrams help developers document their implementation.

The UML Visual Editor also aids component implementation; for example, it provides powerful graphical editing capabilities for EJB components. The object model is saved along with the rest of the J2EE project and is used throughout the object's lifecycle, including testing and deployment. Because the visualization is derived dynamically, it is always synchronized with the underlying code. Any changes made in other editors, such as the Deployment Descriptor Editor or the Java Editor, are immediately reflected in the class diagram, and vice versa. The UML Visual Editor provides an easy way to re-factor code; as you drag and drop objects in the model, the references are automatically updated in the underlying code.

Because the UML Visual Editor supports both IE and IDEF diagrams, it also helps developers visually model their data by simply dragging and dropping a data object onto the editor. These UML visualization tools provide an easy-to-read, up-to-date UML view of the program's implementation.

Automated build process

One extremely tedious task for programmers is bringing together all the various pieces of an application into a build for system integration testing. They must perform this task frequently, as often as weekly or even daily. Now, they can automate this and other frequent tasks, through Rational Developer's support for the open source Ant tool from the Jakarta Apache project.

Ant, a Java-based build tool, has become a de facto standard for building Java projects. The build scripts are XML files containing targets and specifying the tasks (operations) required for each. Ant comes with a large number of built-in tasks that can perform many common build operations.

The ability to run Ant scripts is a built-in feature in Rational Developer. You can run any XML file as an Ant script simply by clicking Run Ant. And you can display Ant messages in an Ant Console view to help debug Ant scripts.

Efficient testing for J2EE applications

In addition to the quick debugging and component testing capabilities we described for Web applications, Rational Developer provides other, sophisticated features for finding and fixing defects early in the development cycle and automating regression testing. When you are unit testing parts of a J2EE application, such as EJB components, Rational Developer can automatically configure the server to access data sources and generate EJB deployment code. Developers can even modify the application on the fly; the server will detect the updated files and immediately reflect the changes. This tight coupling provides an extremely productive testing environment by reducing the overhead required for republishing and change deployment. Developers can also interact with Rational Developer's Universal Test Client (UTC) -- a Web application that makes it easy to test server-side components such as servlet and EJB modules -- via Rational Developer's built-in browser (or an external browser). The UTC lets you set breakpoints, define parameters to pass to JavaBeans, and fully test the component's functionality. You can load any Java class via the UTC, which makes it perfect for invoking multiple application paths, including the Java proxy generated for Web services.

Rational Developer also provides component test tools for building, managing, and automatically generating test cases for unit and system testing. The component test view lets testers manage manual test cases and automate testing of Web sites and Java applications running locally or remotely. This view is based on the Junit framework and the open source Hyades project. The test creation wizards offer a set of test patterns to automatically generate tests from code analysis and user selection. Rational Developer provides proven patterns for testing various components, including EJBs. It also supports data-driven testing, which allows for reuse of test scenarios with multiple data sets. You can automatically deploy and run the tests on the application server, capturing the results for later analysis.

Support for continuously ensuring quality

In addition to testing for errors, developers today need to ensure that their code meets user requirements and adheres to architectural guidelines and standards. In addition to component testing tools, Rational Developer provides a suite of tools to automate code reviews that include and extend the runtime analysis capabilities of IBM Rational PurifyPlus™ for the Java language.

These code review and architectural review tools let developers test their programs against a set of rules or patterns to improve performance, maintainability, and readability. They come with a set of predefined rules that test for J2EE best practices in areas such as globalization, performance, and scalability. Developers and architects can also define rules to ensure that everyone on a team develops to the same standards and conventions.

Rational Developer provides a simple interface for configuring and running code reviews. After an architect or team lead configures rules for a project, the developer simply selects the rules to run against the application, presses a button, and then reviews the results, which provide detailed information on how to fix the code. In many instances, a quick fix option can automatically fix the code.

Automating architectural reviews in a similar way can help your project team manage the complex relationships between program interfaces and ensure that their application meets original business requirements. The architect defines architectural constraints for the components and their relationships and records them as rules, based on predefined templates. Developers then check their components against these rules to verify the architecture's integrity and report all violations of the architectural constraints.

This suite of code review tools can significantly improve productivity by helping team members ensure program quality and correctness throughout the development cycle rather than waiting until the end. These tools help architects and team leaders enforce a coherent architecture, consistent coding guidelines, and development best practices without time-consuming, manual code reviews.

Rapid deployment of J2EE applications

Through annotation-based programming, Rational Developer can generate EJB and J2EE deployment information needed at runtime, so that developers need only to create and maintain a single artifact. By specifying deployment information through Xdoclet metadata tags in the Java classes, they can enable the automatic installation of applications and modules onto a running WebSphere Server and deployment to a staging server rather than a unit test server. With such tight integration between the development and runtime environments, developers do not need to waste time reconfiguring the server when components change. Through incremental updating, Rational Developer redeploys only those parts of the application that have changed, making the test cycle much more efficient. Developers can spend less time restarting the server and more time focused on program quality.

Back to top

Enables rapid development and deployment of portal applications

In addition to supporting all aspects of development and deployment for both Web and complex enterprise applications, Rational Developer provides a full complement of features for developers working on portals. A portal provides a mechanism for aggregating information and accessing enterprise services via a single, consolidated view. A portlet provides access to a specific application or function that is available via the portal.

The IBM Portal Toolkit is now fully integrated into Rational Application Developer, to help developers create, edit, and test portals and portlets just as they would any other type of programming artifact. They can use the portal tools in combination with JSF and Struts elements, EJBs, and even Web services.

Rational Application Developer supports development of projects targeted to WebSphere Portal Server 5.0. For example, developers can visually create and edit portal applications and visually edit the themes and skins that control their appearance. They can also manage complex portlet projects that render portlet JSPs, locate and use Web services, and manage data. Rational Application Developer also includes a Portal Test environment for unit testing both portal and portlet behaviors and system testing for interactions with other programming artifacts.

A typical portal application might provide a managerial dashboard for enterprise applications, such as SAP and Siebel. Rational Developer now provides portal-based mediators that make it easy to connect to these back-end systems. Developers can drag and drop connectors onto the portlets and fill in simple wizards. Rational Developer will then generate the code needed to access data stored in these systems.

Portlet generation with wizards

Developers can use Rational Developer wizards to generate a portlet project structure that conforms to J2EE standards and create a complete portlet. Rational Developer also automates the creation of the portal deployment descriptors and EAR files. The wizards create two main types of portlets: those that comply with the IBM Portlet application programming interface (API) and those that comply with the JSR 168 architecture. JSR 168 is a Java specification from the Java Community Process that addresses the requirements of aggregation, personalization, presentation, and security for portlets running in a portal environment. The IBM Portlet API extends the basic features of JSR 168.

Visual portlet creation

Developers can lay out interfaces for portlets using Page Designer and create portlets using the Struts framework and the Web Diagram Editor to visualize the structure. In addition, they can use JavaServer Faces UI components to visually develop highly interactive portlets. The IBM Portlet API takes a brokered approach to inter-portlet communication, with click-to-action messaging that speeds up portal application development. Portlets need not be aware of each other to send information back and forth. Rational Developer provides a drag-and-drop component for implementing the click-to-action feature without programming, and it uses an icon to visually indicate portlets with click-to-action enabled.

Visual portal creation

The new Portal Designer tool lets developers lay out a portal interface visually, without writing any code. They simply select a visual design for the portal (controlled by themes and skins), import the portlets to be used, and then drag and drop them on the portal page. A special palette of portal controls and a thumbnail view of themes and skins make it easy to control the page design. Rational Developer ships with several predefined themes and skins that allow developers to quickly create a new portal. Figure 5 shows the Portal Designer.

Figure 5: The Portal Designer helps developers lay out a portal interface without writing code.

Rational Developer also saves development time by allowing you to visually edit themes and skins with the familiar Page Designer tool and quickly tailor the design of the portal and portlets. The Style Editor provides fast access to properties that control the visual page elements, And finally, the portal test environment lets developers quickly deploy their entire portal project and test the functionality of portals and portlets on an instance of WebSphere Portal Server running within Rational Developer.

Back to top

Enables rapid development and discovery of Web services

Web services are modular, standards-based applications that developers can dynamically mix and match to perform complex transactions with minimal programming. Web services let buyers and sellers discover each other, connect via the Web, and execute transactions in real time, with minimal human interaction. Web services are currently the most common service-oriented architecture; with J2EE 1.4 they became core J2EE components.

Rational Developer makes it easy to discover and use existing Web services or create new ones without writing any code. Its Web services tools are based upon the open, cross-platform standards of the Universal Description, Discovery, and Integration (UDDI), Simple Object Access Protocol (SOAP), and Web Services Description Language protocols. These protocols ensure the interoperability of Web services with other programs, while Rational Developer handles all the programming details. Developers do not have to learn any new languages or protocols to create Web services with Rational Developer. They can use existing artifacts -- JavaBeans, stored procedures, EJB components, or SQL queries -- and let Rational Developer package them as Web services.

For greenfield Web services development projects, Rational Developer also supports a top-down approach that offers a higher degree of interoperability (see below).

Easy ways to discover and use Web services

Rational Developer makes it very easy to find existing Web services and use them in Web applications without additional programming. The UDDI Explorer tool makes it easy to browse UDDI registries -- online listings of Web services that provide technical specifications and company descriptions and import Web services into a project. As we noted earlier, Web designers can use Page Designer to drag and drop Web services from the page data view. Any Rational Developer artifact (for example, Faces applications, Struts applications, portlets, servlets, and EJB components) can call a Web service as if it were a local entity. Rational Developer even renders the controls on the JSP pages that are needed to invoke the Web service operations and display the information returned by the Web service. It also supports authentication protocols to let developers sign on to protected remote servers to access Web services.

For application testing, Rational Developer automatically deploys the link to the remote server, configures a Web service proxy, and compiles the Web service with the application. You can automatically generate tests based on the Web service's description and use them for regression testing. When you deploy the application to WebSphere Application Server, the application package contains everything needed to run the Web service.

Top-down Web services development

The top-down approach consists of first developing a WSDL file that contains an XML schema to describe the Web service and then generating a skeleton JavaBean or EJB files. Rational Developer provides a modifiable skeleton WSDL and a graphical editor that lays out WSDL file elements hierarchically, so the file is easy to edit. The editor automatically renames all associated sub-objects when an object is renamed and contains an XML schema definition (XSD) editor for specifying message format. Figure 6 shows the WSDL Editor.

Figure 6: WSDL Editor for Web services development

When the WSDL file is complete, Rational Developer generates a skeleton for either a JavaBean or EJB component. The developer then writes the business logic code as for any other JavaBean or EJB component and debugs it in the Web Services Explorer. Finally, Rational Developer provides a Web services client wizard that generates a complete, JSP-based sample with proxy code to test the Web service.

Rational Developer ships with a UDDI Version 2-compliant registry for Web services. This Unit Test UDDI helps developers test UDDI-related aspects of the development cycle, such as publishing their Web service to a registry. They can even test for Web Services Interoperability Organization (WS-I) conformance and automatically configure a TCP/IP monitor session to monitor execution of the Web services over the network.

Bottom-up Web services development

To turn an existing Java class or EJB component into a Web service, developers can use a simple wizard to specify information about the component. Rational Developer generates the WSDL files describing the Web service, a SOAP deployment descriptor, and the proxy a client can use to access the Web service. Rational Developer also provides wizards that automate the creation and deployment of handlers -- programs that sit between the Web service and client machine that can transform data into special formats.

Web services are deployed to the WebSphere test environment, where testing is performed using the same interface as for any other program. The environment even creates a sample client for testing the Web service's functions. The WebSphere Rapid Deploy feature shortens the test cycle, eliminating the need to restart WebSphere Application Server to deploy changes to the Web service.

When it is time to publish the Web service, Rational Developer makes it easy to add it to a public UDDI registry for other users to find and use; it can also automatically generate a private registry to publish the Web service to a select group of users.

Back to top

Additional productivity features

Rational Developer provides numerous additional features to enhance developer productivity. This section covers just a few of them.

Performance analysis

When developers wait until an application is complete before doing performance testing, they have to re-architect the system in order to address performance issues. With Rational Developer, you can do performance testing early in the development cycle, so you have time to re-architect the design before proceeding too far down the implementation path.

The profiling view provides tools that collect data about a program's runtime behavior and presents the information in graphical and statistical form that allows for easy analysis. This data exposes memory leaks and helps illustrate patterns in an application's design. Developers can also launch remote applications and concurrently monitor multiple live processes that might reside on several other machines. The profiling view can gather information on either a stand-alone Java application or an application running within a J2EE-based application server, such as WebSphere Application Server. In either case, profiling can be performed either locally or remotely relative to the application's target host. Furthermore, profiling can occur across multiple Java Virtual Machines.

For Web projects, developers can also analyze performance using the TCP/IP Monitoring Server, which displays requests and responses as they occur. Especially useful for monitoring the performance of Web services, this tool lets you view the interactions with the service running on a remote machine.

Team programming

Rational Developer now provides a fully integrated version of Rational ClearCase LT, a reliable, entry-level version control tool designed for small project workgroups. Part of the IBM Rational ClearCase product family, this tool can scale up to distributed, global enterprises as well, providing support for parallel development with automatic branching and snapshot views. Multiple developers can efficiently design, code, test and enhance software from a common code base. Snapshot views support a disconnected use model for working away from the office and automatically update all changes made since the last snapshot. Developers can disconnect from the client without restarting Rational Developer and configure workspace check-in/check-out on reconnect. They can also create their own local views to configure Rational ClearCase LT to meet their individual requirements.

The diff/merge technology in Rational ClearCase LT makes it practical to merge source code, HTML, and XML. It automatically accepts uncontested changes and highlights conflicting ones for fast resolution without manual intervention. Rational Developer also provides the Eclipse diff/merge patterns, which enable structural comparison of files stored in Rational ClearClase LT.

Teams that require enterprise-level functions (such as distributed servers, database replication, or advanced build management) can seamlessly upgrade to the standard version of Rational ClearCase without retraining or changing their process, data, or tools.

Externally available toolkits

To help enable integration with server environments from IBM and other vendors, IBM provides several free toolkits to download and install for use with Rational Developer, including:

• Everyplace Toolkit for WebSphere Studio -- extends the development environment to help enable developers to design, develop, and implement portlet applications on mobile devices. This toolkit provides templates, plus additional remote facilities for testing applications before deployment. In addition, it contains a preview of the Multi-Device Authoring Technology (MDAT) tool set, designed for developing Web and portlet applications for multiple devices with different characteristics. Available at: www.ibm.com/software/pervasive/everyplace_toolkit/
  
  
• Lotus Domino Toolkit for WebSphere Studio -- lets developers easily program applications that connect to Domino® applications and work with Domino data. This toolkit provides Domino Version 6 custom JSPs. From within Rational Developer, you can view a Domino application residing on your server and use its forms, views, and data -- either in a new JSP or in existing transactional applications. Available at: www.lotus.com/products/product4.nsf/wdocs/toolkitwsstudio
  
  
• IBM Rational Deployment Toolkit for WebLogic Server -- provides tools for working with BEA WebLogic Servers and files in Rational Developer. It supports WebLogic Server Version 6.1, 7.0, and 8.1, and lets developers develop, test, and deploy J2EE applications using the BEA WebLogic Server with Rational Developer. The WebLogic Server can be installed either on the same machine as Rational Developer or on a remote machine, and developers can launch the WebLogic Server console from within Rational Developer as an embedded Web application. Available at: www.ibm.com/software/info1/websphere/index.jsp?tab=products/logictoolkits
  
  
• Eclipse plug-ins -- includes hundreds of additional plug-ins for Eclipse-based IDEs, available through the Eclipse open source community. Open source and commercial tools are available through several online registries. Check out Eclipse Plug-in Central (www.eclipseplugincentral.com) for a comprehensive list and the eclipse.org community page for other online registries. The IBM developerWorks® site also provides a listing of IBM-validated plug-ins at WebSphere Studio Plug-in Central: www.ibm.com/developerworks/websphere/downloads/plugin/index.html
  
  

Back to top

Building Rational Developer skills

IBM offers a variety of methods, ranging from online self-help and education to on-site consulting services and education, to help your developers quickly get up to speed on Rational Developer. We will describe these options below.

Integrated learning tools

Rational Developer comes with a variety of skill-building tools that are integrated into the development environment. Tutorial and sample "galleries" provide detailed training on using product features and let you customize complete programs for your individual needs. Product tours and mini-videos introduce the interface to new users, and the context-sensitive help, show-me guides, and cheat sheets help developers navigate the user interface.

Rational Developer also provides context-sensitive access to IBM Rational Unified Process,® or RUP,® a configurable, iterative software development process platform based on proven best practices and knowledge gleaned from thousands of projects worldwide. RUP helps teams address risk early and continuously throughout the development lifecycle, and provides practical process guidance at every stage of development.

IBM developerWorks

Online support for Rational tools is available through the IBM developerWorks Rational site (http://www.ibm.com/developerworks/rational/). A new Rational Developer Zone will soon provide migration help, technical articles, tutorials on Rational Developer features, and scenarios about how to use Rational Developer with other tools. It will also have online forums to trade tips and techniques with other Rational users and find a local Rational User Group in your area. The developerWorks Rational site also offers IBM Rational distance learning classes with voiceover and animation, and information on classroom courses in your area. For training on the J2EE programming model and other new technologies, visit the developerWorks technology areas, such as the Java and Web Services Zones.

Consulting services

If you have a critical application that you need to deploy very quickly, you might consider calling in the big guns -- the IBM Software Services for WebSphere team. They offer a wide range of consulting packages ranging from on-site education to intense mentoring programs. For more information, visit the WebSphere Services page.

Back to top

Conclusion

Rational Developer can greatly decrease time-to-market for your Web, portal, and J2EE applications. Its easy-to-use tools, combined with its customized, task-oriented perspectives, provide a development experience that makes it easy for novice developers, procedural developers, and expert J2EE developers alike to quickly create and deploy e-business applications.

Downloadable trials of Rational Web Developer and Rational Application Developer are available at:
ibm.com/developerworks/websphere/downloads/WSsupport.html

Back to top

Resources

A starter-level subscription to IBM developerWorks gives you low-cost access to Rational Web Developer and other IBM software: ibm.com/developerworks/subscription/

Rational Developer trial program: ibm.com/developerworks/websphere/downloads/WSsupport.html

Eclipse open source site: www.eclipse.org

developerWorks WebSphere: ibm.com/developerworks/websphere/

WebSphere Studio Plug-in Central: ibm.com/developerworks/websphere/downloads/plugin/index.html

Back to top

IBM technical articles

"J2EE application profiling in WebSphere Studio": http://www.ibm.com/developerworks/websphere/library/techarticles/0311_manji/manji1.htm

"Designing service-oriented architecture frameworks with J2EE technology": http://www.ibm.com/developerworks/webservices/library/ws-designsoa/

"Developing JSF Applications using WebSphere Studio". IBM WebSphere Developer Technical Journal, V5.1.1: http://www.ibm.com/developerworks/websphere/techjournal/0401_barcia/barcia.html

"Web services development and deployment with WebSphere V5 Tools and Technologies": http://www.ibm.com/developerworks/websphere/library/techarticles/0302_flurry/flurry1.html

"Writing a Simple Struts Application using WebSphere Studio V5". IBM WebSphere Developer Technical Journal: http://www.ibm.com/developerworks/websphere/techjournal/0302_fung/fung.html

"Using EGL and Struts with WebSphere Studio Enterprise Developer Version 5". IBM WebSphere Developer Technical Journal: http://www.ibm.com/developerworks/websphere/techjournal/0304_barosa/barosa.html

About the author

Stephanie Parkin currently works as an information architect on the IBM developerWorks WebSphere Web site. She has co-authored two books on visual programming: Building Applications with WebSphere Studio and JavaBeans and VisualAge for Java for Non-Programmers. She is currently writing a book on developing Web services with WebSphere Studio.

Comments (Undergoing maintenance)

Back to top

Trademarks  |  My developerWorks terms and conditions

Table of contents

• IBM Rational Developer: A versatile solution for all Java developers
• Part of the IBM Software Development Platform
• Based on the Eclipse platform
• Provides a complete family of tools
• Increases developer productivity
• Streamlines all aspects of Web application development and maintenance
• Enables rapid development of complex Java and J2EE applications
• Enables rapid development and deployment of portal applications
• Enables rapid development and discovery of Web services
• Additional productivity features
• Building Rational Developer skills
• Conclusion
• Resources
• IBM technical articles
• About the author
• Comments

Next steps from IBM

• Try: Rational Application Developer for WebSphere Software
• Demo: Build, test and deploy JAX-WS Web services
• Webcast: Webcast: Develop innovative applications efficiently using the right application foundation in today's economy
• Briefing: Software development conference
• Buy: Rational Application Developer for WebSphere Software

My developerWorks community

Dig deeper into Rational on developerWorks

Rate a product. Write a review.

Write a review for Rational products today!

Special offers