January 93 - Object-Oriented Software Engineering
Object-Oriented Software Engineering
Addison-Wesley ISBN 0-201-54435-0
Kent Sandvik
Sometimes I feel software methodologies pop up like mushrooms after a rainy day. For
a while the common complaint in the object–oriented field of computing was the lack of
formal analysis methodologies, while the structured programming field had it's
SA/SD, SADTs and RDDs. And lo and behold, one year later we were presented with the
Booch methodology named OOD (Object Oriented Design), Hierarchical Object Oriented
Design (HOOD), Coad and Yourdon's Object Oriented Analysis (OOA), Solution Based
Modeling (SBM) by Goldstein and Alger, and many more.
We will eventually enter a stage in the object–oriented paradigm where a clash of
titans will shake out the winners and the losers. Still, the main problem with many of
the OO-labeled methodologies is the lack of a comprehensive view concerning a
software project. Design is nice, but you also need an overall methodology that spawns
the analysis stage, design itself, implementation and, most importantly, testing as
well.
At this year's OOPSLA Jacobson's Object-Oriented Software Engineering book was a
popular book, so I didn't resist the temptation to pick up a copy. Jacobson's
methodology, OOSE, tries to cover many of the earlier mentioned aspects of a software
project.
What is OOSE?
In general, unless you can understand a methodology within a paragraph or two, my
personal opinion is that we are dealing with snake oil.
In order to understand OOSE as a methodology we have to take a look at industrial
engineering environments that work productively according to Jacobson. One such
example he presents is the building construction industry.
In this engineering environment we have:
a. an architecture, a defined approach selected from a universe of
approaches, such as how to construct a sauna;
b. a method, how to apply the selected architecture concepts (like how to put
together the sauna walls);
c. a process, how to scale up the method to industrial activity (how to mass
produce sauna walls);
d. and finally tools that support the architecture stage, methods and
processes.
Jacobson wants to create an overall methodology that would provide a more engineering
and stage-oriented process to produce software. The methodology tries to keep alive the
creative part of software analysis/design, and at the same time provide an approach
for making software development a rational industrial process. Most importantly, the
bias for this is based on system changes that typical industrial process focuses on
(compare with Japanese car manufacturers). Let's take a look at each of the following
stages of software construction using Jacobson's methodology: architecture, analysis,
design, and implementation.
Architecture
A very important property of a software system is its internal structure-the
architecture. A good architecture makes the system easy to understand, change, test
and maintain. So the properties of the architecture will determine how the system will
behave during its lifetime.
Note, however, that architecture also contains the following elements: the analysis, the
design and the implementation models. A method is a planned procedure by which a
specified goal is achieved (step by step). A basic requirement for a good method is that
it simplifies the development of systems of a particular architecture. This has been
for a long time the sore point in the object oriented computing world. And still today
many OO methodologies treat this requirement quite superficially according to
Jacobson. He states that such methodologies assume that the objects can easily be found
directly from the activity.
Often we do have such cases, but as many of us realize it requires a strong background
in object modeling before 'finding the objects' becomes second nature. I'm afraid I
didn't find a good solution to this problem in the book. Jacobson hints at a high level
construct called a process that is usable for scaling up the design at a later stage.
However, it seems the issue of finding natural objects and object interactions is
something that is hard to easily mechanize, even in OOSE.
Object Oriented Analysis
As with any other analysis stage, the idea is to obtain an understanding of the
application based on functional requirements. Object–oriented analysis can be
characterized as an iteration between analyzing the system's behavior and its
information. Here the methodology should provide help with:
• finding the objects
• organizing the objects
• describing how the objects interact
• defining the operations of the objects
• defining the objects internally
Jacobson states that objects can be found as naturally occurring entities in the
application domain. He's using the noun paradigm where a noun that exists in the
domain is often a good start to learn the terminology for the object domain. When we
learn more about the domain, the real objects will pop up. This is where I do think we
are really dealing with an imperfect scientific methodology; it is questionable whether
this can formalized into an exact procedure due to the classical problems of
categorization.
Jacobson suggests organizing objects based on different criteria (active/passive,
physical/conceptual, temporary/permanent/persistent, part/whole, generic/specific
and so on...) as a means to conceptualize the naturally formed objects. This is just
another method to learn about the domain in order to find the right objects.
The next step is to organize the objects based on various criteria. For instance, the
similarity between objects might resolve into a hierarchy of objects. Another
classification of objects may be based on how objects work together with other objects
(for instance a house is built of doors, windows, walls).
Booch's keynote at this year's OOPSLA was related to the art of classification, and he
said that tomorrow's designers will spend more and more time working with
categorization of objects.
Object interaction is defined from the way objects fit into the system. This is where
the OOSE use case technique comes into picture (more about this later). The object's
interface can be decided from such scenarios.
Operations on objects come naturally when we look at the object's interface. The
operations can be identified directly from the application, when we consider what we
want to do with the items we model. We have primitive operations (Create, Add,
Delete) as well as complex ones such as putting together a report of information
based on various objects.
Finally the object should be defined internally, which includes defining the
information that each object must hold.
OOSE and Object Oriented Analysis
OOSE has the concept of actors and use cases. In order to map a requirement
specification to the model, we have actors that play various use case scenes, and these
use cases will form the operations.
The actors represent interactions with the system, they represent everything that
needs to exchange information with the system. Actors are actually outside the system,
so we don't need to define them explicitly. Note that a user (an end user) could have
various actor roles while using the system. This actor does a number of various
operations which will trigger a sequence of transactions in a dialogue with the system.
A single sequence is called a use case. A transaction is finished when the use case
instance requires input from an actor.
The system model will be use case driven: when we want to change the system
behavior, we remodel the appropriate actor and use case. The whole system
architecture will be determined by what the user wishes to do with the total system.
NOTE: This is one of the core ideas behind OOSE
This modeling view fits very well with prototyping, user interface driven application
work and re-specification of projects. Also, we can talk with the users directly and
find out their requirements and preferences, eliminating the dreadful gap between
specifications and the actual implementation (a sickness that has killed thousands of
software projects).
Now, the use case model will control the formation of all other OOSE models, such as
domain models, analysis, design, implementation and testing. The functionality
specified by the use cases is then structured into a logical, implementation-level
environment and further re-defined in the design model so it is resistant to change.
The use cases will be implemented by the source code and should also give us tools
when testing the system. Also, the use case should give us support when writing
manuals and other operational instructions.
This is closely related to the notion of patterns and pattern languages for
documentation use. For instance Ralph Johnson presented a paper at this year's
OOPSLA-92 concerning how to structure the documentation of a framework by using a
set of patterns that describes the purpose of the framework without having to know in
detail how everything works.
Object Oriented Design and OOSE
During the design stage we create a design model that is a refinement of the analysis
one. The analysis model was based on ideal conditions. Now we deal with reality.
We didn't want to introduce the environment earlier because we didn't want it to affect
the basic structure of the system, Neither did we want the problem blurred by the
complexity usually triggered when looking at the implementation environment.
So the design model is a formalization of the analysis space, where we adapt the
analysis part so it works with the environment. It's a question of refining the model so
that it is straight-forward to write the actual code. However, we still have issues
related to changes in the model (such as future performance requirements, new
features, computer language issues), so we need to develop a new model.
So when does the analysis model work end and the design work starts (a classical
dilemma)? There's not a good answer; it really depends on each specific application.
The goal is to not redo any work at a later phase that has been already done.
OOSE uses the concept of blocks that will describe how the code should be produced (see
Figure 2). These blocks are design objects, and they are drawn as rectangles. One block
normally aims at implementing one analysis object. However, the key issue is that
these blocks are not the same objects as the analysis objects in order to keep the ideal
analysis model intact.
The blocks are abstractions of the actual implementation of the system. We need to
refine how the blocks interact or communicate during execution. The OOSE term is
called stimulation. A stimulus is sent from one block to another to trigger an execution
in that block.
To describe a sequence of stimuli, OOSE uses interaction diagrams. These describe how
several blocks communicate by sending stimuli to each other (see Figure 3 on the next
page). These diagrams describe in detail, for each use case, which stimuli will be sent
how and in what order. A use case becomes a sequence of stimuli sent between the
blocks.
In addition, the methodology uses the concept of subsystems in order to manage the
design. Subsystems can contain several objects, which might be other subsystems. So
we might end up with a hierarchical structuring of the system in order to manage the
complexity.
Object–Oriented Construction
This step implies that the analysis model has been designed and it is time for coding.
The analysis has (we hope) provided us with an ideal structure which we shall now try
to keep intact as long as possible. If everything works well the objects identified
during the analysis should also appear in the design. This is called in OOSE
traceability. OOSE uses the concept of components in order to map the analysis stage
objects into real-life source code based entities.
Note also that this stage actually does not require an object oriented language, even if it
helps in mapping the design to the implementation. If the block design was done
properly, it is very easy to code into objects. And by reusing objects in forms of
components we could achieve more powerful constructs (aggregates).
Systems development
An important message Jacobson states in his book is the issue of systems development
as part of a larger activity. This work does not take place in isolation. For instance in
the banking industry data processing is just one sub-part of a larger activity
providing a certain functionality set.
The output from systems development is a set of descriptions that includes the source
code, diagrams, flow charts, and so on. All of these descriptions must be
self-explanatory to facilitate reusability. Also, the knowledge of how to organize and
manage projects must be documented so it could be made reusable (SBM is also
targeting this interesting new concept of reusable design and project plans).
Using these concepts, we might eventually attain a rational approach of software
development. A software house might create a library of these configuration sets, and
each sub-project will receive a special combination of service packages with relevant
information which has been assembled from the library of descriptions. New releases
could reuse descriptions from previous releases in a controlled manner.
All this demonstrates the need for high level CASE tools and systems.
OK, OOSE made my day, but will it help me?
Well, it depends what you want from a methodology. There are two schools of thought
concerning mix-and-match of various methodologies. The CASE
manufacturers/providers kick and scream and say that one needs to stick to one single
methodology, theirs.
The academic field generally holds that it is better to stick to one methodology in order
to avoid any Byzantine solutions based on convoluted and mixed design methods.
The practical programmer is keen on creating his/her own methodology, by taking (or
stealing) the best parts from various design systems (though sometimes it's darned
hard to plot out all kinds of cloud figures with MacDraw without using the CASE tool
from ACME Inc).
Then large corporations issue decrees that every software department will take a holy
trip to the West/East coast for three days of training, and the defined methodology
should be used till the end of the world.
Me? I've been looking around for a simple, nice, understandable and highly flexible
methodology that could be used for personal computer application development work.
I'm not stating that OOSE is the answer. However, many of the basic OOSE ideas are
valid. For instance, the user is in control of an application, and the use cases based on
actors are highly suitable for analysis of both what the GUI provides and what the
application should achieve for the user. The book provides a lot of good ideas that the
interested designer could try to implement, maybe in a pilot project, and if the end
results are positive then the methodology is suitable for future work.
As is the case of most methodologies, refinement is the key-if you find a working
formula, refine it instead of jumping to the next buzzword in the computing field.
Conclusions
I'm sure that all the other OO CASE and methodology vendors will step up and suggest
that their methodology works where OOSE fails. And they might be right or wrong, I'm
not the judge in this issue. Hey, I'm just a book reviewer. Anyway, would I recommend
reading the book? As there are an unlimited number of OO books today, and time is
precious when you want to ship your product tomorrow, I would suggest that if you are
shopping around for a methodology, read the book for good ideas about the issues
related to selecting a useful methodology. OOSE should also work for small scale
projects easily-without the purchase of expensive UNIX workstation CASE tools.
The other reason I recommend that programmers read the book has to do with the
background of OOSE/Objectory. It has been used in large-scale real-time system
design, and 20+ years of blood, sweat and tears have certainly added a lot of
understanding and insight about issues related to software construction. Admittedly, we
are dealing with experience that sometimes does not map 1:1 to the personal computer
application design. However, as Adele Goldberg lately stated, PC developers are
discovering that the principles of object modeling will make an important difference
because they have 'discovered' the need to design before coding. This is because it's
maybe the first time the PC industry has to build systems instead of smaller
applications.
Finally, the book contains a nice model of actors and use cases that could be used with
smaller application work. I've recently seen many engineering specifications where
use cases have been used to map the issues related to the analysis and design of the
product. 1
References
• Documenting Frameworks using Patterns, Ralph E. Johnson, OOPSLA'92
Conference Proceeedings
• Object-Oriented Software for the Macintosh, Goldstein & Alger
• "Wishful Thinking", Adele Goldberg, Object Magazine, Nov-Dec 1992