 | Level: Introductory Joseph Noonan (dwinfo@us.ibm.com), RRD Development Programmer Manager, IBM
15 Aug 2003 
from The Rational Edge: The author discusses the major attributes of IBM Rational Rapid Developer that enable architectural and construction control, thereby ensuring high-quality business applications.
From The Rational Edge.
Application development has never been easy. As software has increased
in importance, so has its complexity. In an effort to reduce this complexity
and increase ease of use, software tool providers have endeavored for
many years to create rapid application development (RAD) tools that allow
developers to quickly create applications. The first iterations were not
actually tools, but rather libraries that provided developers with key
functionality, mostly focused on generating user interfaces. These offerings
eventually expanded to encompass sophisticated libraries for communications
and key functions. However, although they accelerated development, these
libraries were proprietary and still required significant skill to use
correctly.
In order to make RAD more practical, and open programming to a broader
base of programmers, tool vendors developed products such as Microsoft®
Visual Basic and Sybase® PowerBuilder, which provided an
entire environment for the developer. The supporting languages were simple
to learn, and the tools themselves provided accelerators such as GUI designers
that allowed the user to "draw" the user interface by dragging and dropping
controls onto a virtual canvas and then attaching actions in the form
of code functions to the controls. These environments quickly generated
converts, and many millions of lines of code were created using their
tools.
But problems persisted. Although these tools were used to create many
critical applications, they did little to control the methods developers
used. For the most part, applications were neither model-based nor founded
on strong architectures. Therefore, developers could (and did) design
their applications however they saw fit. The resulting applications were
usually unstructured, poorly designed, and naturally difficult to maintain.
A general lack of code-sharing practices meant that applications often
delivered the same basic function sets in several different (and sometimes
conflicting) ways. In addition, when organizations wanted to expand the
scope of an unstructured application beyond a single department, the application
was difficult to scale, given the tool set used to create it. Also, the
underlying technologies of these tools sets were proprietary, so they
were difficult to integrate with other technologies.
To combat this chaos, Rational Software Corporation, now IBM Rational,
part of IBM Software Group, has provided the software development industry
with a much more standards-based approach to the application development
lifecycle. This approach includes languages (UML), tools (IBM®
Rational Rose,® IBM® Rational ClearCase,®
IBM® Rational ClearQuest,® and IBM®
Rational XDE,™ to name a few), and industry leading best practices
(via Rational Unified Process,® or RUP®).
In May of 2003, IBM® Rational® Rapid Developer
joined this distinguished list of Rational resources and technologies.
Years in the making, Rational Rapid Developer provides an architected
approach to RAD, based on standards such as J2EE. The new approach is
called "architected RAD," and it provides a variety of accelerators and
controls over development of applications. With Rational Rapid Developer,
less experienced developers can join forces with highly skilled architects
and senior developers to create solidly designed applications.
The Gartner Group recognizes tools of this nature as Architected RAD
or "ARAD" tools. Some characteristics of these tools include:
-
Support for industry standards such as J2EE, UML, XML, SOAP, and
MDA.
-
Use of industry standard design and construction patterns, such
as MVC2.
-
Engineered quality in constructed code.
-
Architectural consistency across teams of developers.
According to Gartner,
There's no better way to improve productivity, reduce cost, and
ensure scalability and performance of applications, while still putting
methods in place that are "minimally invasive."
For most enterprises and applications, ARAD should prove to be a
near-ideal approach to balancing speed and cost with "just enough"application
quality and performance.
1
This article will introduce the major attributes of IBM Rational Rapid
Developer that enable architectural and construction control, thereby
ensuring high-quality business applications while giving development teams
great flexibility in technology, construction, and deployment.
Architected RAD: Importing a UML base model
The heart of every application is the base model that describes it --
a domain model, class model, logical model, entity model, or the like.
In all instances, this base model provides a view of the key classes and
their relationships, and IBM Rational Rapid Developer supports this view
graphically with its UML-based Class Architect (see Figure 1).
Figure 1: UML class model in IBM Rational Rapid Developer
Click to enlarge
You can develop this model in several ways. You can simply use the friendly
drawing tools to drag, drop, and connect classes and packages on the canvas
of the "Class Architect" feature within Rational Rapid Developer. More
often than not, however, the development team will want to leverage existing
assets. The architect and senior developers can import these assets into
the application project in Rational Rapid Developer from a couple of sources,
the first being an existing database. Using the database import wizard
from the Tools menu, the architect can connect to the database and then
import the table and relationship definitions by selecting from the list
of tables and views. This can be done as many times as needed over the
development cycle. In addition, changes the architect makes to the model
in Rational Rapid Developer can be propagated to the database or into
DDL scripts that the database administrator can run. Rational Rapid Developer
also provides facilities to import definitions of legacy assets, such
as IMS or VSAM database definitions.
An architect can also create a class or information model by using the
model synchronization feature in IBM Rational Rapid Developer (see Figure
2). This feature connects to existing models created in either the IBM
Rational Rose or IBM Rational XDE modeling tools, which are mainly geared
for senior developers and architects; they provide a very rich modeling
environment based on the Unified Modeling Language (UML) standard. Using
the connectivity feature to access these existing models in Rational Rapid
Developer, an architect can push a fully developed class model down to
users and give them a jumpstart on development. Once the initial model
is imported, these users can also initiate incremental updates; as the
architect modifies the model, they will receive the changes without having
to re-import the entire model.
Figure 2: IBM Rational Rapid Developer offers access to UML class models in
IBM Rational Rose or IBM Rational XDE
In addition, the architect can easily filter out elements that are not
ready for use or that are not relevant to the application his team wants
to develop.
Architected RAD: Maintaining design and branding consistency
IBM Rational Rapid Developer supports a very rich user interface design
environment. Developers and graphic designers can lay out an application's
user interface using drag-and-drop controls and special nestable grids
to manage and display complex content.
Rational Rapid Developer also supports the creation of a style repository
that can help ensure uniform page layouts and consistent branding if multiple
contributors will be creating applications and adding content to a Web
site. A style repository contains details of color schemes, font styles,
themes (explained below), editing and navigation controls, and page styles.
A graphic designer can create a series of templates offering variations
in style, color, design elements, and so forth, that still maintain branding
consistency for the site.
In Figure 3, the graphic designer has created a style repository with
specifications for buttons, tabs, grids, and labels, as well as some document
templates. Another development team can import this style repository into
another application they are creating with Rational Rapid Developer, and
it will determine what controls and styles that development team may use.
In addition, the designer can create themes, using the Theme Architect,
for the style repository. Themes consist of color sets, image sets, and
font sets that can be named and then used either specifically for a given
page or loaded dynamically as a user option.
Figure 3: With IBM Rational Rapid Developer, a graphic designer can create a style repository that enables multiple contributors to maintain design and branding consistency on Web site pages.
Click to enlarge
Architected RAD: Maintaining control over code
IBM Rational Rapid Developer has many features that provide greater control
and consistency for code while making coding easier for developers.
Code generation for multiple technologies
Through its combination of base, interaction, and user interface models,
IBM Rational Rapid Developer can generate the bulk of the code for all
n-tiers of a J2EE application. Currently, it can generate applications
for a wide variety of deployment technologies, which the architect/developer
can select from a dropdown menu. Moving an application from one vendor
technology to another -- or from an older version of a technology to the
latest version -- is as easy as selecting another menu option and clicking
the Construct button. This means that developers can have one development
environment on their desktop (e.g., Tomcat with SQL Server), and a completely
different environment for production (e.g., IBM WebSphere with IBM DB2),
without worrying about the differences between those technologies.
From an application maintenance perspective, this capability ensures
that development teams can spend the vast majority of their time solving
business problems by adding new features and capabilities to applications,
rather than on porting code from one technology to another.
Code construction patterns
A unique feature of IBM Rational Rapid Developer is that it allows architects
and senior developers to define design patterns for constructing the application.
Rational Rapid Developer has a specific set of default patterns for classes,
pages, messages, and components (Web services) that are loaded with each
application (see Figure 4). For each category, architects and designers
can either choose one of these default patterns or mix and match to achieve
a specific result.
Figure 4: Default construction patterns in IBM Rational Rapid Developer
Click to enlarge
Each pattern has a named descriptor that can be assigned to a page, message,
or component. Patterns can be transactional or non-transactional, and
they can support dynamic SQL or stored procedures. They can also support
entity beans, JSPs (JSP Model II), or servlets. This allows the architect
to select the patterns that are best for the application and enforce their
use by developers.
Code templates
Rational Rapid Developer includes a coding environment called Logic
Architect. This is where the programmer actually writes the business logic.
In order to streamline this process and provide consistency among the
coding done by different developers, Logic Architect provides a series
of code templates that perform common business application processing
tasks. The developer picks a template and responds to the wizard's questions
for that template, and then Logic Architect populates the template with
appropriate code (see Figures 5 and 6).
Figure 5: Code templates for Logic Architect
Figure 6: Logic Architect populates code templates automatically.
Click to enlarge
For example, if the developer selects a template for calling a stored
procedure, he or she enters the database descriptor name and the name
of the stored procedure; then, Logic Architect inserts the code automatically.
This is an open system that allows the architect to both modify existing
code templates and add new ones. The bottom line is that the architect
or senior developer can maintain control over the code developers use
across the project.
Security control
IBM Rational Rapid Developer also provides advanced features for more
sophisticated developers that extend access to custom security providers
and components. It supports role-based security as well as data encryption
and permits the addition of customized security mechanisms that comply
with the J2EE JCE (Java Cryptography Extender) standard. This allows architects
to either create their own security mechanisms in the form of a JCE provider
or leverage existing third-party JCE implementations.
Control via custom components
Another way that architects can control development is by employing
components in the form of Java packages, or EJBs. These services-oriented
components can represent common business logic that Rational Rapid Developer
users can call from their custom methods.
Architected RAD: Deployment control
Most development tools provide a local environment in which developers
can deploy their applications for testing. However, the actual target
production environment is usually significantly more complex, and you
need specialized skills to determine how to partition the application
for deployment. IBM Rational Rapid Developer provides architects and senior
developers with an advanced tool, the Partition Architect, to create partition
and deployment definitions for the application. Rational Rapid Developer
provides a "local" model that defaults to Apache Tomcat, which is an open
source servlet/JSP engine. Rational Rapid Developer also supports deployment
onto a variety of J2EE platforms, such as IBM WebSphere (versions 3.5,
4.0, and 5.0). Partition Architect allows segmentation of the application
into different tiers (presentation, business, and data) as well as along
functional lines (buyer, seller, administrator, etc.OK). See Figure 7.
Figure 7: IBM Rational Rapid Developer has Partition Architect, which provides advanced deployment control.
Click to enlarge
Conclusion
Unlike RAD approaches of the past, IBM Rational Rapid Developer provides
architects and senior developers with a great deal of control over application
development. Architects can ensure architectural consistency by controlling
the code generation process, ensure layout and branding consistency through
the style repository and templates, and ensure deployment success through
advanced partitioning controls. They can also provide less experienced
developers with templates and tools that make their work faster and more
efficient. The end result is a quality application that is built using
the best practices for the target platform, and a team that works well
together and has a head start on the next project.
Notes
1 M. Blechar and M. Light, Gartner Group,
"ARAD Brings Architectural Compliance and Productive Power,"
in Research Note Commentary, January 17, 2003.
Resources - A new forum has been created specifically for Rational Edge articles, so now you can share your thoughts about this or other articles in the current issue or our archives. Read what your colleagues the world over have to say, generate your own discussion, or join discussions in progress. Begin by clicking HERE.
-
Global Rational User Group Community
About the author | | | Joseph Noonan is an article contributor. |
Rate this page
| |
