Features in UML Tools

This takes us to an important question—what exactly should we look for in a UML tool? Because the
primary use of a UML tool is to enable you to draw diagrams, first and foremost, we need to see
what types of UML diagrams the tool supports. But, is drawing UML diagrams all that you would
expect from a UML tool? For example, wouldn't it be great if the class diagrams that you draw in the
tool can somehow be used to generate the source code for actual Java classes or C++ classes? Let us
take a look at another scenario. Suppose you were given a large set of source code files with lots and
lots of classes. Wouldn't it be a nightmare wading through the code trying to figure out how all the
classes are interconnected? This is where UML tools step in to make things a lot easier by providing
support for such features. Now, let's define these features in technical terms:

• UML diagram support: The UML tool should support all the nine diagrams that make up
UML. You should look for a tool that supports drawing use cases, designing the static view diagrams
such as class diagrams and object diagrams, defining the dynamic view diagrams such as sequence,
activity, state, and collaboration diagrams and the component and deployment diagrams that form
the implementation view of the system.

• Forward engineering: A UML tool should not have its use limited to just a pictorial
depiction of diagrams. Because the structure of the system defined by the diagram is translated by a
developer into actual source code (classes), the UML tool should bridge this step by generating the
source code of the classes with the methods stubbed out. Developers can take up this stub code and
fill in with the actual code. This characteristic of automating the generation of source code is called
forward engineering. Forward engineering support by a UML tool is normally for a specific language
or a set of languages. If you are a Java developer, verify that the UML tool that you want to use has
forward engineering support for Java. Similarly, if you are a C++ developer, the UML tool should
provide you forward engineering support for C++.

• Reverse engineering: Reverse engineering is exactly the opposite of forward engineering. In

reverse engineering, the UML tool loads all the files of the application/system, identifies
dependencies between the various classes, and essentially reconstructs the entire application
structure along with all the relationships between the classes. Reverse engineering is a feature
normally provided by sophisticated and high-end UML tools.

• Round-trip engineering: Another useful feature apart from forward and reverse
engineering is round-trip engineering. Forward and reverse engineering are essentially one-off
activities that take input and generate the required output. Round-trip engineering extends these
features. An important rule in software design is that no design remains unchanged. This is as true
for small systems as it is for large systems. During development, the design structure defined in the
UML model does undergo changes to incorporate physical differences in implementation that may
not have been envisaged during design. It becomes very difficult to keep the design of the system
updated with the changes in the source code. The round-trip engineering feature enables the UML
tool to synchronize the model with the changes in the application code.

• Documentation: Documentation is an integral aspect of a UML tool. Software designing, by

nature, is an abstract process. Apart from a few syntax and semantic ground rules, there are no
other rules. The thought process of a software architect who designs applications using UML can be
lost if the reasons behind certain design decisions are not captured and well documented. This
becomes painfully clear when large systems are maintained and no one has a clue to why a
subsystem was designed in a certain way. Hence, a UML tool must necessarily provide some way for
the designer to document design decisions in the diagrams by using simple things such as
annotations or comments. In addition to this, the UML tool should support the generation of
reports/listings of the different design elements of the diagram. Apart from the above features, you
should also identify a few features that would definitely be useful to have in the UML tool.

• Version control: A very important feature that we want to have in the UML tool is either an
integrated version control mechanism or connectivity to a standard version control system.
Configuration management is an integral part in the building of software systems. Considering that
the design of a system is a very important artifact of the software lifecycle, maintaining versions and
baselines of the system design is a desirable feature to have in UML tools. In the absence of direct
support for version control, it is the responsibility of the designer to maintain versions of the design.
• Collaborative modeling environment: Enterprise systems are huge and their designs
are quite complex. While designing complex systems, there may be different teams involved and
may carry out design work on different subsystems in parallel. This collaborative design effort needs
to be properly synchronized by the UML tool. The UML tool should provide support for a
collaborative modeling environment with capability to compare different versions designs for
differences or even merge different versions of a design. Collaborative modeling is always a nice
feature to have in UML tools.

• Integration with popular Integrated Development Environments (IDE): With

the increasing use of iterative methodologies for building software systems, it becomes very difficult
to keep the design of the system in sync with the developed code. Hence, it would be useful if the
UML tool provides integration with popular IDEs. This feature would enable the UML tool to be
updated with the changes in the source code made in the IDE.

• Test script generation: The system or subsystem designed in a UML tool may represent a
set of functional aspects as well. Hence, it would be really useful if, in addition to generating stub
code, the tool also generates test scripts that can be used for testing how the generated class
functions.

• Model View Controller (MVC) modeling: Enterprise application architectures have

increasingly begun to standardize and are based on the Model View Controller architecture. Hence,
if you design n-tier, Web-enabled enterprise applications, you should look for a UML tool that
supports designing applications based on the MVC architecture. Support for MVC modeling makes it
easier to organize and clearly distinguish the design elements along the lines of the MVC layers. This
will help in the long run in improving the readability of the model.

Popular UML Tools

We will list here a few of the "movers and shakers" of vendors of UML tools. Please note that this
list is by no means exhaustive and is not meant to provide any ranking for any UML tool.

• Rational Rose: No discussion of UML tools is complete without the mention of the Rational
Rose modeling tool from Rational Software Corporation. Rational Rose (the Rose stands for "Rational
Object-oriented Software Engineering") is a visual modeling tool for UML. It comes in different
versions suited to different requirements. Rational Rose provides support for all the standard
features that we discussed in the previous section such as UML diagram support, forward and
reverse engineering support, and documentation and round-trip engineering support. Apart from
this, Rational Rose also provides support for version control, IDE integration, design pattern
modeling, test script generation, and collaborative modeling environment. In addition, Rational Rose
also supports the designing of data models within the same environment. An interesting feature of
Rational Rose is the ability to publish the UML diagrams as a set of Web pages and images. This
enables you to share and distribute your application design where the Rational Rose tool is not
installed

. • Together Control Center: Together Control Center (formerly from Togethersoft) from
Borland is an entire suite of visual modeling tools for UML. Together Control Center supports UML
diagrams, MVC modeling, forward and reverse engineering, and round-trip engineering, as well as
integration with IDEs such as IBM WebSphere Studio. It supports comprehensive documentation and
a powerful collaborative modeling environment. An added feature of Together Control Center is the
pattern repository. The pattern repository (similar to the template-driven modeling concept
discussed above) makes frequently used diagrams and design patterns readily available for reuse in
modeling. Together Control Center supports the Rational Unified Process as well as the Extreme
Programming methodologies.

• Poseidon: Poseidon from Gentle ware has its roots in the Agrium open source project. The
Agrium modeling tool evolved as an open source effort and is a useful, full-featured UML tool freely
available under the Open Publication License. Gentle ware has taken Agrium a step further and
turned it into a good modeling tool. Poseidon comes in different flavors suited to different
requirements. Poseidon supports forward and reverse engineering and documentation generation
by using special-purpose plug-ins. Gentle ware has not forgotten its open source moorings and
offers the Poseidon for UML Community Edition 1.5 free for individual software developers.
StarUML (case study for an old version)
StarUML is an open source project to develop fast, flexible, extensible, featureful, and freely-
available UML/MDA platform running on Win32 platform. StarUML modeling application licensed
under a modified version of GNU GPL. StarUML is based on UML version 1.4 and provides UML
version 2.0 notations and eleven different types of diagram. It actively supports the MDA (Model
Driven Architecture) approach by supporting the UML profile concept. It provides maximize the
productivity and quality because of generating numerous results automatically from it. Use of
StarUML help to easily and quickly design exact software models which is based on UML standard.
The goal of the StarUML project is to build software modeling tool and also platform that is a
compelling replacement of commercial UML tools such as Rational Rose, Together and so on.
starUML boasts a complete set of UML modeling features.

Approach: Approach defines the model of the project and basic organization of the diagrams.

UML Profile & Notation Extension: UML Profile allows extension of expression for the software
model through the extension mechanism of UML.

Model Framework: Model Framework makes software models reusable and allows them to be used
when defining other software models.

Add-In COM Object: Add-In COM allows addition of new functionality to StarUML. Menu Extension:
The StarUML application menu (main menu and pop-up menu) can be added by the user.

Option Extension: The StarUML option items can be added by the user.

Event Subscription: Various events occurring in StarUML can be subscribed to.

External API: The external API from StarUML allows access to various functionalities and
information. Details on API are discussed throughout this developer guide, and the example included
in StarUML installation 'StarUML Application Model. UML provides a good illustration.

KEY FEATURES OF StarUML

UML Tool that Adapts to the User: StarUML provides maximum customization to the user's
environment by offering customizing variables that can be applied in the user's software
development methodology, project platform, and language.

True MDA Support: Software architecture is a critical process that can reach 10 years or more into
the future. The intention of the OMG (Object Management Group) is to use MDA (Model Driven
Architecture) technology to create platform independent models and allow automatic acquisition of
platform dependent models or codes from platform independent models. This maximizes
extensibilityof UML, making modeling of applications possible even in areas like finance, defense, e-
business, insurance, and aeronautics. Truly Platform Independent Models (PIM) can be created, and
Platform Specific Model (PSM) and executable codes can be automatically generated in any way.
Excellent Extensibility and Flexibility:

StarUML provides excellent extensibility and flexibility. It provides Add-In frameworks for extending
the functionality of the tool. It is designed to allow access to all functions of the model/metamodel
and tool through COM (Visual Basic Script, Java Script, VB, Delphi, C++, C#, VB.NET, Python, etc.)
Automation and it provides extension of menu and option items. Also, users can create their own
approaches and frameworks according to their methodologies. The tool can also be integrated with
any external tools.

Accurate UML standard model: StarUML™ strictly adheres to the UML standard specification
specified by the OMG for software modeling. Considering the fact that the results of design
information can reach 10 years or more into the future, dependence on vendor-specific irregular
UML syntax and semantics can be quite risky. StarUML™ maximizes itself to order UML 1.4 standard
and meaning, and it accepts UML 2.0 notation on the basis of robust Meta model.

Open software model format: Unlike many existing products that manage their own legacy format
models inefficiently, StarUML™ manages all files in the standard XML format. Codes written in easy-
to-read structures and their formats can be changed conveniently by using the XML parser. Given
the fact that XML is a world standard, this is certainly a great advantage, ensuring that the software
models remain useful for more than a decade.

Applicability of methodologies and platforms: StarUML manipulates the approach concept, creating
environments that adapt to any methodologies/processes. Not only the application framework
models for platforms like .NET and J2EE, but also basic structures of software models (e.g. 4+1 view-
model, etc.) can be defined easily.

Software model verification function: Users can make many mistakes during software modeling.
Such mistakes can be very costly if left uncorrected until the final coding stage. In order to prevent
this problem, StarUML automatically verifies the software model developed by the user, facilitating
early discovery of errors, and allowing more faultless and complete software development.

Useful Add-Ins: StarUML includes many useful Add-INS with various functionalities: it generates
source codes in programming languages and converts source codes into models, imports Rational
Rose files, exchanges modeling information with other tools using XMI, and supports design
patterns. These Add-Ins offer additional reusability, productivity, flexibility and interoperability for
the modeling information.

Other features

• StarUML is mostly written in Delphi. However, StarUML is multi-lingual project and not tied to
specific programming language, so any programming languages can be used to develop StarUML

. • StarUML supports the following UML diagrams• Use Case Diagram • Class Diagram • Sequence
Diagram • Collaboration Diagram • State chart Diagram • Activity Diagram • Component Diagram •
Deployment Diagram • Composite Structure Diagram (UML 2.0)

• Code generation can be done for Java, C++ and C# as well as Reverse Engineering Documentation
can be generated for all of the Microsoft Office suite programs such as Word, Excel and PowerPoint.
PROS OF StarUML

• Supports most of the diagrams specified in UML 2.0. • Very rich feature set and formatting
options.

• Ability to generate source code from the UML diagram. • Reverse engineer the existing code into
UML diagrams. • Supported languages: C, C# and Java.

• Fast load time/execution time compared with other UML tools. • Familiar Visual Studio like user
interface. • Supports exporting diagrams into JPG / XMI formats.

• Supports plug-ins for both importing and exporting. • Code and documentation plug-ins provided
with package. • Useable. • Free. As basic comparison to other open source UML tool like agroUML
with StarUML have some limitation are as follows

• Not fully supports UML 2.0. • Can’t Undo! Developers of argoUML must be so optimistic that
people (especially Software Developers) never do mistakes. • Written in Java, so run comparatively
slower than starUML. • Lack of formatting option

CONS OF StarUML

• Complex for the beginner. • No longer on a release cycle. • Not cross platform. (only Windows)

Does not support exporting diagrams into SVG format

Problem Statement
As a video game is also a part of software industry. The exponential rise of online multiplayer games