Reasons to use IBM Rational Application Developer for WebSphere Software
As you consider delivering Web and service-oriented solutions, there are many questions that you need to answer, including these:
- How can I effectively build scalable Java™ and Java Enterprise Edition (JEE) applications or Web Services?
- How can I control or limit redevelopment of my applications and reduce the number of defects?
- What can I use to make my life easier when maintaining other developer’s code?
- How can we code more effectively within our geographically distributed teams?
- How can I improve application design, quality, and performance?
- How do we work with applications that are more complex than ever, despite the difficulty in finding skilled staff?
- How do I create reusable assets so that I don’t have to reinvent the wheel every time that I build an application?
- How do I deliver interoperable applications based on industry standards?
- How do I coordinate all of this and ensure the integrity of the plan?
You could go on, delving into additional issues such as portability, security, browser inconsistencies, and so forth. This is a daunting list of challenges. As such, how do we succeed?
IBM® Rational® Application Developer for WebSphere Software Version 7.5 provides solutions to these challenges through a comprehensive set of features that expand your capabilities:
- Quickly develop and test Java EE 5 applications with annotation-based programming and integrated WebSphere support
- Discover, generate, deploy and test Web services to integrate business applications
- Design portals and portlets rapidly and visually and then test them with IBM® WebSphere® Portal
- Take advantage of the programming model support for IBM® WebSphere® Application Server Version 7.0 and Java EE 5.0 standards, which includes Enterprise Java™Beans 3.0, Java Persistence API (JPA), Java™Server Faces 1.2 (JSF), Java API for XML (JAX)-WebSphere 2.0, JAX-B 2.0, Java™Server Pages 2.1 (JSP), Servlet 2.5
- Simplify development by using Rich Internet Application (RIA) clients to extend and expose services and feeds
- Work in the integrated test environments for WebSphere Application Server 7.0, WebSphere Application Server 6.1, WebSphere Application Server 6.0, WebSphere feature pack support, and WebSphere Portal Version 6.1 or 6.0
- Integrate easily with IBM® Rational® Team Concert to collaborate with your team
This list is not complete, and there are many more features that are provided, including those provided by the underlying Eclipse platform and Eclipse Web Tools Platform (WTP) project. Even so, it can be overwhelming trying to figure out the best way to get started. Perhaps we need to take a different approach to looking at the ways that you can use Rational Application Developer for WebSphere Software.
Let functions guide which features to use
In evaluatiing how you could use these many features effectively, it can be more useful to consider the common, underlying tasks that you perform, instead. Ask yourself how you might be able to use Rational Application Developer for WebSphere Software to do these core tasks (see Figure 1):
- Design solutions
- Generate solutions
- Identify and resolve issues
Figure 1. Rational Application Developer at the center of your software development
This is not the only order in which you will complete these tasks, of course. Where you start in using these tools will depend on where you are in your software delivery cycle.
Tools that help with design
In designing, Rational Application Developer for WebSphere Software gives you several ways to simplify your tasks, to use graphical languages and editors specific to a domain, and to integrate with supporting tools. Let’s take a more detailed look at some of the features and how you can use these ideas..
You can visualize existing code artifacts as UML diagrams, including class, sequence, topic, and browse diagrams (see Figure 2). The UML representation gives you a simplified view of the code. By using it, you can hide details and aspects that are not relevant so you can focus on those things that matter. Keep in mind that this visualization is only a UML rendering of the code. As such, it is automatically kept in sync with the code and does not require any round-trip code to UML generation.
Figure 2. UML class diagram
This abstraction and visualization theme continues with database models, XML schemas and Web Services Description Language (WSDL) documents (see Figure 3). These tools are not simply read-only views; they can also be edited. In addition, the tools are specific to the domains in which you need to work. They are tailored to working with databases, XML schemas, and Web services, yet they enable you to focus on the important aspects of your work and hide unnecessary details.
Figure 3. WSDL editor
The Web site structure and navigation diagram presents a storyboard for your Web site. You can brainstorm and create a high-level overview of your Web site very easily. The Web site structure and navigation diagram supports page templates, page fragments, styles, and themes. This tool also allows you to create the HTML, JSP, JSF pages.
Editing HTML, JSP, JSF, Dojo, or any other user interface component is simplified by a WYSIWYG editor and a drag-and-drop palette. Designing the layout of pages becomes easier if you do not have to worry about syntax. Creating a page template is very similar to creating a page in that, after a template has been created, it can be applied to all of the pages. There is also an Expert mode where you can access the code at any time. The key is that you can access the level of detail as is necessary for you to accomplish the task at hand.
As discussed, these visualizations hide details that are not relevant. Rather than looking at all of the details associated with an XML schema, it is much easier to look at a visualization that hides all of the unnecessary and irrelevant details. In addition, they have been tailored to the domains in which you are working. But there is another benefit that is worth considering--they make it easier to communicate with others on your team.
Development is now a team effort more than ever, and you need to interact with team members from multiple teams to ensure that everyone is aligned with requirements, aware of defects, and working in unison with other developers. Even when not every team member in every role is using Rational Application Developer, it is important that you can share information with other people in other roles.
For example, tracing developer activities to requirements is a key aspect of design and implementation stages. To support this aspect, Rational Application Developer integrates with IBM® Rational® RequisitePro®. In this way, you can determine why something is being added to the solution. Also, you can use the traceability function to determine the impact of changes on requirements.
Rational Application Developer also integrates with Rational Team Concert. This integration enables real-time, in-context collaboration for distributed project teams, making software development more automated, transparent, and predictive.
Rational Team Concert also provides work items, which can be defects, enhancements, or conversations. Team members can query work items and share the query results with other team members. And to help provide context and improve communication, you can track and comment on each work item.
Team members can also take those work items and assign them to an iteration plan. An iteration plan is a wiki-type interface that allows the team to view project progress for a targeted iteration. This enables a transparent development process with data collected from actual development work, where the developers and project managers are able to keep track of the project and identify risks as early as possible.
By bringing together abstraction, domain-specific tooling, integration, and a focus on communication, Rational Application Developer for WebSphere Software puts you in a position to design solutions despite today’s increasing complexity and challenges.
Tools that help generate solutions
Now let's look at how you can use Rational Application Developer for WebSphere Software to generate solutions.
Rational Application Developer can help you generate solutions (or portions thereof) by using these mechanisms:
- Graphical languages and editors specific to a domain
Computer science has largely evolved by moving away from machine code to higher-level programming languages -- using abstraction and automation. As a result, we have seen significant increases in the productivity of developers. However, there is still room for improvement, because there are still a lot of mundane tasks that a developer has to perform.
Rational Application Developer has many wizards and graphical editors that help developers create various Java EE artifacts without knowing the exact syntax, thereby enabling you to focus more closely on the problem at hand. These wizards include WSDL visualization, Java EE deployment descriptors, manifests, JPA mappings, and others.
Support for Java Enterprise Edition 5 includes a simplified programming model that includes annotations. Annotations are insertions of directives in a plain old Java object (POJO), where a developer enters information without leaving the source editor or uses an annotation editor. Annotations allow a developer to program data that would otherwise be furnished in a related file, such as a separate deployment descriptor. Annotations provide a more intuitive and convenient approach, because the specific information about a class is entered in the code elements that it applies to.
Note: The UML visualizations discussed earlier also recognize and provide support for annotations.
Rational Application Developer also has first class support for automation or generation of code, including Java EE 5 artifact Content Assist, as-you-type validation, and refactoring options for Enterprise JavaBeans 3.0 and JPA.
In addition, Rational Application Developer also provides support for creating your own automations through the use of model-to-text transformations. These transformations leverage your best practices and approaches to generating text-based elements, such as code, deployment descriptors, and so forth. The basic idea in these tools is to identify an exemplar or a pattern that needs to be repeated often. The exemplar represents the best solution to the problem solved by the pattern and will be created by a skilled developer. The other developers then only need to apply the transformation to generate code for fulfilling the pattern; they don’t need to know the details of the implementation. Rational Application Developer has an Exemplar Analysis tool that helps you identify a schema and create a transformation design, an input model, and an associated set of templates.
Figure 4. Exemplar authoring
The key idea is to leverage Rational Application Developer so that it generates aspects of your solution for you, thus enabling you to avoid repetition, low-level details, and mechanical effort. That way, you can focus your coding time and efforts on the areas that require creativity and higher-level value.
Tools that help find and resolve issues
It is inevitable that all human activity is error-prone. Any code that is written is bound to have defects. A defect is not just simply a runtime exception; it could be a blue button where a red button is expected, or it could be code that is unreadable or code that is unreachable.
Rational Application Developer can help you to identify issues in three ways:
- Best practices
Rational Application Developer includes static analysis tools that enable you to identify defects before the code even runs. With such tooling, you can analyze projects to find problems of various types, such as design principles, Java EE, Java best practices, performance issues, and others.
Figure 5. Static analysis rule sets
Static analysis is quick and easy to run. As such, you and the rest of your team can use it as part of your day-to-day development efforts. It can also become an integral part of a focus on quality by being used in combination with code inspections. Static analysis allows you to focus on more creative aspects of issues that may arise in your application, thus making the time spent in code inspections that much more productive. An additional benefit of the static analysis tool is that it enables developers to learn from the best practices. This is possible because the static analysis tool provides examples of each of the issues that it can identify, along with a description of how the issue can be resolved.
Rational Application Developer also provides the capability to profile applications to identify performance and memory problems. In addition to supporting you in setting up and collecting performance and memory data, you get tools and views to interpret the results. Your analysis is supported through various views, such as tables, graphs, and UML timing diagrams (see Figures 6 and 7).
Figure 6. Execution Statistics
Figure 7. UML timing diagram
Figure 8. Java debugger
The Rational Team Concert client also provides support for debug session hand-offs to your team members, whether they are in a cubicle next to you or 10 time zones away. This is a real-time transfer, where the people that you are handing the session off to can pick up right where you left off in your debugging. After they are finished, they can hand the session back to you. This feature is a time saver, because all of the work required to recreate the bug does not have to be replicated.
Rational Application Developer for WebSphere Software also provides support for test management activities, such as those to invoke tests, control test execution, gather test results, and analyze test results. You can run tests on remote machines or import existing JUnit test cases into the Testing and Performance Tools platform (TPTP) test case. You can also use data pools to separate testing data from test logic, search and generate reports from test results, and integrate with IBM® ClearQuest® test management software.
In addition to being able to use automation in finding issues, the automation incorporates best practices to help you in the future. You can use abstraction in several ways, such as when you use visualization in timing diagrams, as a way to get above the code as it is running.
After you have identified issues, Rational Application Developer helps you find a solution in three similar ways: .
- Best practice guidance
Although these are the same concepts, the implementation aspects of Rational Application Developer are different.
For instance, you use static analysis here, too, but the intent here is to look at how it helps you to resolve the issues that you identified. For example, you can apply Quick Fixes with just a simple click of the mouse button to automatically resolve the issue (Figure 9). In cases where multiple fixes are available, you can choose which of the solutions you want to apply.
Figure 9. Quick Fix option
Tip: The Quick Fix option is also available when writing code. This can be as simple as adding an import and as complex as creating a class or implementing an interface.
Sometimes it takes hands-on investigation to figure out how to resolve an issue. In such cases, it is essential to have strong debugging tools. Within Rational Application Developer, developers can fix their code within a debugging session and continue debugging without having to restart from scratch (Figure 10). The debugger also allows developers to change and inspect values of elements (Figure 11).
Figure 10. Variable view
Figure 11. Variable Inspector
Within the development team, there are multiple roles, deliverables, and steps to be taken. How do you ensure not only that you know the best practice approach but that the rest of the team does, as well? One way is by following a software development process. Rational Application Developer provides process guidance with wisdom culled from the IBM® Rational Unified Process® (RUP®).
Tip: If you and your team have created and published your own RUP-based process, you can use that process in place of the version that is included in Rational Application Developer.
Process guidance and user assistance are provided dynamically as you work within Rational Application Developer (see Figure 12). This guidance covers roles, work products, and activities. In addition, Tool Mentors provide specific guidance for how to perform tasks.
Figure 12. Process browser
Rational Team Concert also provides an executable process framework that can control the activities during the various phases of software development, such as how code can be checked in during the last cycles of a release build. These integrations help reduce the risk associated with software development and make application development more predictable.
As you implement changes to the code, you can use UML visualization to understand dependencies between elements. As changes are implemented, you need to document and communicate those changes to the rest of the team. You can use UML visualization to capture and document the changes. Also, when generating Java documentation, you can choose to have UML class diagrams automatically generated.
The life of the code in the solution goes far beyond the first release of the system. As you look for ways to make your code easier to understand and support, you also need to consider the best way to refactor that code (change the structure of the code without changing its functionality). Rational Application Developer can help you do that, too, because it provides support for renaming Java classes, moving classes and packages, creating interfaces from concrete classes, turning nested classes into top-level classes, and extracting a method from sections of code in an old method. The software checks all references to names in JavaDoc and various XML files to ensure that refactoring occurs without any broken links. UML diagrams are also updated automatically as part of the refactoring.
When looking to address the challenges that today’s development efforts face, Rational Application Developer for WebSphere Software is a key tool in your arsenal. As we look to Design, Generate, Identify and Resolve – we use simplification, abstraction, automation, domain specificity, integration, and best practices.
Keep these ideas in mind as you work with Rational Application Developer for WebSphere Software - they will help you to increase your productivity and will also make development a more enjoyable and productive endeavour.
- Understand more about JavaServer Faces tooling in Rational Application Developer Version 7.5 by reading this article What's new in JavaServer Faces tooling in Rational Application Developer Version 7.5?.
- Understand more about JPA and JSF tooling in Rational Application Developer Version 7.5 by reading this article Developing Web applications with the Java Persistence API and JavaServer Faces: How Rational Application Developer Version 7.5 makes it easier to build JPA Web applications.
- Visit the Rational software area on developerWorks for technical resources and best practices for Rational Software Delivery Platform products.
- Subscribe to the IBM developerWorks newsletter, a weekly update on the best of developerWorks tutorials, articles, downloads, community activities, webcasts and events.
- Subscribe to the developerWorks Rational zone newsletter. Keep up with developerWorks Rational content. Every other week, you'll receive updates on the latest technical resources and best practices for the Rational Software Delivery Platform.
- Subscribe to the Rational Edge newsletter for articles on the concepts behind effective software development.
- Browse the technology bookstore for books on these and other technical topics.
- Rational Application Developer for WebSphere Software 7.5 developerWorks page
- Rational Application Developer 7.0 Redbook
- Rational Application Developer 7.0 Courses
Get products and technologies
- Download trial versions of IBM Rational software.
- Download these IBM product evaluation versions and get your hands on application development tools and middleware products from DB2®, Lotus®, Tivoli®, and WebSphere®.
- Join the developerWorks Community in forums, blogs, podcasts, wikis, and more.
- Join the Rational Application Developer forum on developerWorks.