Foreword 1
Ivar Jacobson is in my opinion one of the foremost methodologists in the field of software engineering. I take great pleasure in writing this, because he is also a close personal friend. He brings a refreshingly pragmatic point of view to a discipline that often seems to be so abstract and arcane as to be hopelessly remote from the real world of "blue collar" programmers. His methodology is based on some really innovative ideas about modeling and the software process, presented within a tried and proven engineering framework. It brings to the task of analyzing, designing and constructing complex software intensive products the same disciplined approach that is to be found in other branches of engineering.
Along with many others I have urged Ivar for some time to publish his methodology in a textbook, so that it would be accessible to a larger audience. I believe that the concepts in Objectory, the first comprehensive object-oriented process for developing large scale industrial systems, are important and should get wider exposure. This book represents over 20 years of experience building real software based products and a great deal of serious thinking about how such systems should be built. If you have any interest at all in software you will enjoy reading it.
Objectory stands out as being a truly object-oriented methodology, in which both the process and the methodology are themselves represented as objects. While some may find this idea of a reflective or "meta" architecture to be rather exotic, it is in fact intensely practical and absolutely essential. It makes Objectory an extensible methodology which can be specialized to both the organization and the application domains. Simply put, Objectory provides a software process for building not just software, but also other more specialized software processes.
Another key innovation in Objectory is the concept of use cases, which has now been proved effective in a number of real-world projects. Use cases provide the needed linkage between requirements, development, testing and final customer acceptance. This idea, which originated in Ivar's work on the AXE switch, has been generalized so that it can be applied in application domains as diverse as command and control and business information systems.
Use cases provide a concrete representation of software requirements, which allow them to be both formally expressed and systematically tested. Changes in requirements map directly onto changes in the set of use cases. In this way Objectory provides a solid methodological foundation for rapid prototyping and other forms of incremental software development. Objectory enables managers to move beyond labour intensive hand assembly of software systems and allows them to transform their organizations into highly automated factories to manufacture software from reusable components.
Many feel that we are in the midst of a software crisis, and I agree. High-quality software has become one of the most sought after commodities in the modern world. We just can't seem to get enough of it, on time and on budget, to meet the demand. This book will help you overcome the software crisis in your own organization, by showing you how to make software construction into a reliable and predictable engineering activity.
One of the more profound insights offered by modern software engineering is that change is inevitable, and that software must be designed to be flexible and adaptable in the face of changing requirements. Objectory, with its reflective architecture, goes one step further, and provides an extensible methodology which can itself adapt to shifts in the business climate or the demands of new technologies. No static text can ever capture all the nuances of such a dynamic software entity but this one comes very close. I strongly recommend it, not only for software managers and designers, but for anyone who wishes to understand how the next generation of software systems should be built.
Dave Thomas
Foreword 2
Ivar
Jacobson has taken the time to create a book that is certain to
become essential reading for software developers and their managers.
In this book, Jacobson establishes a new direction for the future
of software engineering practice. It is a thoughtful and thorough
presentation of ideas and techniques that are both solidly proven
and, simultaneously, at the leading edge of software engineering
methodology. Jacobson is simply a thinker who has been ahead of
his time in creating usable methods for building better, more reliable
and more reusable large software systems.
Despite the title, this is not "another book on object-oriented
analysis and design", nor yet another standard reworking on the
word-of-the-week. Once, of course, the word-of-the-week in software
engineering was "modular", later it was "structured", and now, as
every programmer or software engineer who reads or attends conferences
knows, it is "object-oriented."
When the word-of-the-week was still "structured", and I wrote the
first edition of Structured Design, the very idea
of systematic methods for software development was radical. Software
engineering was in its infancy, and when I introduced data flow
diagrams and structure charts, few recognized either the need for
notation or the benefits of well-conceived modeling tools for analysis
and design.
But things have changed. Now, new methodologies are created over
cocktails, and books spin out of word-processors so fast that revised
or "corrected" editions appear almost before the original has reached
the book- stores. Since nearly everyone now recognizes that a methodology
must be supported by a notation, notations proliferate. A new object-oriented
design notation can be churned out over a weekend so long as the
major objective is simply squiggles and icons with a unique "look
and feel", and issues of use ability and power in modeling are considered
unimportant.
And here we have yet another notation supporting one more methodology?
Not quite.
It is true that the serious reader will have to surmount both new
terminology and new notation to get to the marrow, but this book
is different. It was not conceived and written overnight. The methodology
it describes has been in use for years to design and build numerous
software systems, and its notation has evolved slowly from both
manual and CASE-supported application. It is not the work of a writer
or a consultant with a long booklist, but comes from a practising
software engineer and leader in software engineering who has been
doing large-scale object-oriented development for longer than most
people even knew that objects existed. Throughout this period, the
ideas and methods have been honed by the grindstone of building
software and refined by thoughtful reflection and analysis.
What we have here is an approach to object-oriented analysis and
design that is fundamentally different from most of the highly touted
and more visible methods that clutter the landscape. I believe that
it is an approach of proven power and even greater promise.
The real power of this approach rests not only in the wealth of
experience on which it is based but also in the way in which it
starts from a different point of departure and builds an entirely
different perspective on how to organize software into objects.
Jacobson does not build naive object models derived from simplistic
reinterpretations of data modeling and entity object relationship
models. He starts from an entirely different premise and set of
assumptions uniquely tailored to creating robust, sophisticated
object structures that stand the test of time.
His approach centers on an analysis of the ways in which a system
is actually used, on the sequences of interactions that comprise
the operational realities of the software being engineered. Although
it fully incorporates the conceptual constructs, the application
and enterprise entities that undergird our thinking about software
systems, it does not force the entire design into this rigid pattern.
The result is a more robust model of an application, leading to
software that is fundamentally more pliant, more accommodating to
extensions and alterations and to collections of component parts
that are, by design, more reusable.
At the heart of this method is a brilliantly simple notion: the
use case. A use case, as the reader will learn, is a particular
form or pattern or exemplar of usage, a scenario that begins with
some user of the system initializing some transaction or sequence
of interrelated events. By organizing the analysis and design models
around the user interaction and actual usage scenarios, the methodology
produces systems that are intrinsically more usable and more adaptable
to changing usage. Equally important, this approach analyzes each
use case into its constituent parts and allocates these systematically
to software objects in such a way that external and internal structures
and dynamics are kept apart, such that each may be altered or extended
independently of the other. This approach recognizes not one kind
of object, but three, which separate interface behavior from underlying
entity objects and keeps these independent of the control and coordination
of usage scenarios.
Using this approach, it is possible to construct very large and
complex designs through a series of small and largely independent
analyses of distinct use cases. The overall structure of the problem
and its solution emerges, step-by-step and piece-by-piece, from
this localized analysis. In principle - and in practice - this methodology
is one whose power increases rather than diminishes with the size
of the system being developed.
Use case driven analysis and design is a genuine breakthrough, but
it is also well-grounded in established fundamentals and connected
to proven ideas and traditions in software engineering in general
and object-oriented development in particular. It echoes and extends
the popular model-view-controller paradigm of object-oriented programming.
It is clearly kin to the event-driven analysis and design approches
of Page-Jones and Weiss, as well as to the widely practised event-partioning
methods pioneered by McMenamin and Palmer.
On this ground, Ivar Jacobson has built a work that is nothing short
of revolutionary. Rich with specific guidelines and accessible examples,
with completely detailed case studies based on real-world projects,
this book will give developers of object-oriented software material
that they can put into practise immediately. It will also challenge
the reader and, I am confident, enrich the practise of our profession
for years to come.
Larry
L. Constantine
|
