Tackling challenges of software development with Rational Application Developer for WebSphere Software

This article shows how IBM® Rational® Application Developer for WebSphere® Software V7.5 provides solutions to the many challenges that software teams face when tasked to deliver Web and service-oriented applications.

Lee Ackerman (ackerman@ca.ibm.com), Marketing Manager - SOA Marketing, IBM

Lee Ackerman is a marketing manager with the Rational software SOA marketing team. Over the years, he has helped others develop software through articles, IBM RedBooks, workshops, training, and mentoring.



S Mahate, Senior Project Manager, WSO2 Inc

S. Mahate is a senior product manager for IBM Rational software and has more than 20 years of software development experience.



26 September 2008

Also available in Chinese

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
  • Extend service-oriented architecture (SOA) and Java EE assets with dynamic, rich Asynchronous JavaScript and XML (AJAX or Ajax) applications (Web 2.0)
  • 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
diagram with concentric circles

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
diagram view

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
diagram with Claim, Person, Address, and Receipt

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:

  • Abstraction
  • Graphical languages and editors specific to a domain
  • Automation

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
exemplar left, transformation right, tabs bottom

The area of rich Internet applications (RIAs) that use Web 2.0 collaborative principles and responsive technologies is also a hot area for practitioners. Rational Application Developer for WebSphere Software helps with the client-side development of RIAs with support for the Dojo toolkit for AJAX, including a full-featured JavaScript source editor with Content Assist, validation, refactoring, and outline views. You can build Web pages visually by using the included Dojo palette to create drag-and-drop pages and modify Dojo entity properties visually. Java object methods can be exposed through the Web Remoting framework, including Representational State Transfer (REST) services. Use of the AJAX proxy enables the building of mashups from a variety of Web 2.0 service providers.

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:

  • Automation
  • Abstraction
  • 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
Analysis Domains and Rules in explorer view

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
columns for base time, calls, and so on
Figure 7. UML timing diagram
diagram with four lifelines

Rational Application Developer also helps you to identify defects in your code by providing exhaustive debugging support for your Java code, JSP, XSLT, JavaScript, Python WebSphere Application Server administrative scripts, and DB2 stored procedures. The Java and mixed language debugger (Figure 8) provides seamless integration with various programming languages.

Figure 8. Java debugger
Java debugger integration

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: .

  • Automation
  • Best practice guidance
  • Abstraction

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
code and fix on top, tree view on bottom

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
Name and Value comments
Figure 11. Variable Inspector
pop-up details about resultString

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
tree view on left, diagram on right

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.


Summary

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.

Resources

Learn

Get products and technologies

Discuss

Comments

developerWorks: Sign in

Required fields are indicated with an asterisk (*).


Need an IBM ID?
Forgot your IBM ID?


Forgot your password?
Change your password

By clicking Submit, you agree to the developerWorks terms of use.

 


The first time you sign into developerWorks, a profile is created for you. Information in your profile (your name, country/region, and company name) is displayed to the public and will accompany any content you post, unless you opt to hide your company name. You may update your IBM account at any time.

All information submitted is secure.

Choose your display name



The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerWorks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

Required fields are indicated with an asterisk (*).

(Must be between 3 – 31 characters.)

By clicking Submit, you agree to the developerWorks terms of use.

 


All information submitted is secure.

Dig deeper into Rational software on developerWorks


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=1
Zone=Rational
ArticleID=341326
ArticleTitle=Tackling challenges of software development with Rational Application Developer for WebSphere Software
publish-date=09262008