Introduction to The Unified Modeling Language (UML)
The Unified Modeling Language (UML) is the standard visual modeling language used
for modeling businesses, software applications, and system architectures. It is officially
defined at the Object Management Group (OMG—http://www.omg.org/). It is a graphical
language that was designed to be very flexible and customizable. It allows software
developers to concentrate more on design and architecture. However, The UML can be
translated into a coding language, so can a coding language be translated into UML. This
process is known as “reverse engineering.
There are different people developed many object-oriented modeling techniques that were
being developed to model software approaches using different visual modeling techniques
and notations, the application modeling was becoming divided and different. However,
there was the wisdom and intuition of a few people in understanding that a standard and
organized way for people to communicate when designing systems can only be
beneficial.
In the 1980’s and early 90’s there were many of design methodologies. Three of these
methodologies began to lead models for software engineering. All were quite good in certain
areas, but seem to not cover the whole design process, and each had somewhat different
methodology. In other words each methodology had its own type of notation which is
hard for someone knowledgeable to understand another designer’s work and the
associated notation. At this time, developers adapted their own method and other design
methodology. Finally, around 1995 three design developers, Jim Rumbaugh, Grady
Booch and Ivar Jacobson worked and joined a company specializing in design tools
called Rational (IBM). However, there was disagreement between them but this was
overcome when the Object Management Group (OMG), decided to adapt UML as a
standard design modeling language. As a result, the UML is an open modeling standard
designed and supported by software companies.
The UML is designed to work with the object-oriented software development methods.
It was originally built to satisfy model object-oriented systems and to enable ComponentBased Development (CBD). In an OO system, generally several components are related
together using what are called "interfaces." To understand how those different
components interact, it is quite useful to build a model.
In addition, developers can model anything that they want in the UML by using its
customization capabilities. The UML used for modeling businesses, data, ,hardware, nonobject-oriented application modeling, and many other modeling tasks.
UML Modeling:
A model is using specific graphical representations to describe the software. It helps
developers to ensure that the designs close to reality before the implementation. This can
save developers and their organization a lot of time and money, In addition, it enables
member teams to work together effectively and ensure that they are working toward the
same common goals. Moreover, modeling is useful to understand what modifies will
change the design. When designers add a component to a system, they need to make sure
the system won't come crashing down as a result. However, model is a way to understand
business and its processes. Developers model their business processes not only to
understand how their business works and how it functions but also that developers can
identify how changes will affect the business. Modeling the software helps developers to
identify strengths and weaknesses, identify areas that need to be changed or optimized.
The Building Blocks of UML Modeling:
The three major building blocks of UML are:
1.
The Elements of the model
2.
The Associations between the elements of the model
3.
The UML Diagrams
The basic elements of an UML model are the classes, the interfaces and the components.
A class may be defined as a self contained unit that encapsulates a collection of data and
methods that operate on the data resulting on an isolation of the contents of this
encapsulated from any external interface. An interface is a contract which can be used to
define a protocol of behavior. It can be implemented by any class anywhere in the class
hierarchy.
UML Modeling Tools:

Rational Rose: supports UML 1.x

JUDE: JUDE is a unique UML modeling tool which supports object-oriented
software design in Java combined with Mind Map.

GDpro 5.0
UML Diagrams:
A diagram shows the static structure of the system of different modeling focusing on the
elements of a system as described within the UML. Each UML visualizes a certain aspect
of the system. Each diagram uses specific UML symbols to achieve its purpose. The
UML contains three various basic diagram types: structure diagrams, behavior diagrams
and Interaction diagrams.
Structure diagrams describe the static structure of the software's elements. These
diagrams are fundamental to the UML modeling of a system and portray the static
structure of the system as a whole. The structure diagrams contain Class diagrams
Component diagrams ,Object diagrams,... etc.
Behavior diagrams describe the dynamic behavior of the elements in the system and how
the system functions. The various behavior diagrams are Activity diagrams, Collaboration
diagrams, Use case diagram, and ..etc.
Interaction diagrams represent how flow of data and control takes place in the system
that is being modeled. They are a subset of the Behavioral Diagrams. These include:
Sequence diagrams, UML Timing Diagram, Interaction Overview Diagram,.. and etc.
Conclusion:
The Unified Modeling Language is an internationally accepted standard that is used for Object
Oriented Modeling and can be used to represent a model that adopts the best software
engineering practices.
Bibliography
UML Tutorial, from sparx systems's company, 2 pages.
http://www.sparxsystems.com.au/UML_Tutorial.htm
Unified Modeling Language (UML) Tutorial, Braun, D, et al, 2001
"Object Oriented Analysis and Design Team", Kennesaw State University, 5 pages
estimated.
http://atlas.kennesaw.edu/~dbraun/csis4650/A&D/UML_tutorial/index.htm
Why Model With UML? Kris Richards & Cindy Castillo.(2007): NetBeans. 1 page.
http://www.netbeans.org/kb/55/uml-why-model.html
An introduction to structure diagrams in UML 2, Donald Bell(2004), IT Specialist, IBM ,
1 page
/http://www.ibm.com/developerworks/rational/library/content/RationalEdge/sep04/bell