You may think J2EE is powerful, but too complex for you to
use. Well, let's think again.
Times have changed. While enterprise Java development
hasn't quite reached the simplicity of Visual Basic ("J2EE for
Dummies" anyone?), vast improvements in development tools have
opened the door to J2EE for those of us who can't recite the
EJB specification on command.
Can J2EE development actually be considered "easy?" With
the right tools, the answer is now "yes." Just as Visual Basic
once opened Windows client programming to the masses, Rational
Application Developer can do the same for aspiring enterprise
Java developers.
Cutting Through Complexity
Early adopters of
enterprise Java were often overwhelmed by the complexity of
the J2EE specification. Much support code needed to be written
because the available development tools were incapable of
automating common tasks, such as creating and deploying EJBs.
Inadequate tools also made the job of debugging and tuning a
J2EE application challenging.
Fortunately, with the advent of Rational Application
Developer, that chapter of computer history has closed.
Rational Application Developer frees J2EE development from its
ivory tower mentality. Now almost any type of software
developer can construct, test and debug, and tune a J2EE
application without losing his or her hair.
How is this possible, you may ask? Well, it's because
Rational Application Developer—the latest version of what was
previously called WebSphere Studio Application
Developer—provides a robust set of tools that manages and
abstracts away the former overwhelming complexity of J2EE
development.
Ease of Construction
With Rational Application
Developer, the days of writing tons of code is long gone.
Visual construction is the new paradigm. Complete dynamic Web
sites can now be created without writing a single line of
code. Just visually create the site hierarchy, and then
drag-and-drop elements onto the page, including HTML, JSF and
Struts elements, JSP tags, and calls to JavaBeans.
Novice and veteran J2EE developers alike will appreciate
the power that JavaServer Faces technology (JSF) offers. JSF
significantly simplifies the construction of interactive Web
interfaces by automatically handling almost all user
interactions with the application, including input validation,
error checking, and validation and conversion of strings.
Rational Application Developer provides the wizards and
visual UI components necessary to easily utilize JSF. The
wizards do all the set-up work needed by JSF—there is no
coding required. Java language code-behind files, which are
the implementation of your JSF design, are dynamically created
as the JSF design surface is edited—there is no additional
generate step; thus the code and UI design are always in sync.
The Struts framework has taken the J2EE world by storm.
While the framework holds great promise, without the right
tools, Struts is painful to use. Rational Application
Developer lets even novice developers create well-architected
Web applications without having to learn the intricacies of
Struts. Just define a Struts application, and Rational
Application Developer will create reusable JavaBeans that
encapsulate the code for managing data and passing it between
forms.
Visualizing Reality
It is rare a developer that
starts with a clean state. More typically, you're staring at
300,000 lines of code wondering just what the heck is going
on. Rational Application Developer shows the big picture by
"visualizing" class relationships and the interactions between
objects. This visualization presents existing code as a
"model" without requiring you learn everything about modeling.
Rational Application Developer's support for UML sequence
diagrams (which visualize object interactions) places it far
ahead of traditional class browsers. This power is to be
expected of course, since the UML visualization features of
Rational Application Developer were built by the same team
that created the first industrial-strength UML modeling tool,
Rational Rose.
Squash the Bugs
As any experienced developer
knows, writing an application is easy; the hard part is making
it work correctly. Rational Application Developer helps solve
this traditional problem by streamlining the build, deploy,
and test process.
One extremely tedious task for developers is packaging all
the various pieces of an application into a build for
integration testing. Rational Application Developer allows
automation of this task though its support of Ant (the de
facto standard for Java builds). Components can then be easily
deployed, as the product generates EJB deployment code and
automatically configures the test server to access any needed
data sources.
Deployed components can be tested by using Rational
Application Developer's Universal Test Client. Developers
interact with the test client via a browser to set
breakpoints, define parameters to pass to JavaBeans, and
otherwise fully test the functionality of the components.
Without these features, developers would have to manually
create a test client that covers all test cases for an
application and then deploy the test client to a target
server.
Rational Application Developer also provides component test
tools for building, managing, and automatically generating
test cases for unit and system testing. Its built-in support
for the JUnit framework and the open-source Hyades test
management project includes test creation wizards that offer a
set of test patterns that automatically generate tests from
code analysis and user input. Rational Application Developer
provides proven patterns for testing various components,
including testing the life cycle of EJBs.
Runs Faster
One of the biggest headaches of J2EE
application development is figuring out why an application
exhibits inferior performance. Rational Application Developer
provides several tools that let developers test application
performance early on in the development cycle—when it can
still be easily fixed.
Rational Application Developer offers profiling tools to
collect data about a program's runtime behavior and presents
that information in graphical and statistical views for easy
analysis. These views expose memory leaks and help illustrate
problematic patterns in the application design.
Developers can also launch remote applications and
concurrently monitor multiple live processes residing on
several other machines. Information can be gathered on a
stand-alone application or an application running within a
J2EE application server. In either case, profiling can be
performed locally or remotely, relative to the target host.
For Web projects, performance monitoring shows HTTP requests
and responses as they occur.
Tearing Down the Wall
Enterprise Java has become
more powerful, yet also more complex. Rational Application
Developer tears down the wall that has separated J2EE
development from the rest of us. Its ease of use and extensive
automation of complex development tasks allows mere mortals to
construct, test and debug, and tune non-trivial J2EE
applications without the steep learning curve of old-style
enterprise Java development.
Print