A software process defines the steps required to create software successfully. Written by the same authors who brought you the Unified Modeling Language (UML), The Unified Software Development Process introduces a new standard for creating today's software that will certainly be useful for any software developer or manager who is acquainted with UML.

Early sections introduce four basic principles of the unified process: that software should stress use cases (which show how it interacts with users), that the process is architecture-centric, and that it is iterative and incremental. The authors then apply these principles to their software process, which involves everything from gathering system requirements to analysis, design, implementation, and testing. The use-case examples are excellent and include concrete examples drawn from such areas as banking and inventory control.

The authors point out the connection between UML document types (like use cases, class diagrams, and state transition diagrams) with various models used throughout the software process. They provide very short, real-world examples that illustrate how their ideas have been successfully applied. The straightforward tour of the new unified software process gets extra elaboration--along with some advice--in later chapters that further describe the author's ideas on design. With the weight of these three expert authors behind it, readers can expect The Unified Software Development Process to be an important book and one that will be valuable to any working designer or manager. --Richard Dragan


Book News, Inc.
This guide overviews the Unified Process for software development, with a focus on modeling using the Unified Modeling Language (UML). It demonstrates how the notation and process complement on another, using UML models to illustrate the new process in action. The authors describe semantics and notation of the different higher-level constructs used on the models. Constructs such as use cases, actors, subsystems, classes, interfaces, active classes, processes, threads, nodes, and most relations are described in the context of a model. ^^^^ -- Copyright © 1999 Book News, Inc., Portland, OR All rights reserved


Book Info
Presents a complete guide to the Unified Process from the original designers. Demonstrates how the notation and process compliment one another, using UML models to illustrate the new process in action. Clearly describes the semantics and notation of the different higher-level constructs used in the models. DLC: Computer software--Development.


From the Back Cover
This landmark book provides a thorough overview of the Unified Process for software development, with a practical focus on modeling using the Unified Modeling Language (UML). The Unified Process goes beyond mere object-oriented analysis and design to spell out a proven family of techniques that supports the complete software development life cycle. The result is a component-based process that is use-case driven, architecture-centric, iterative, and incremental. The Unified Process takes full advantage of the industry-standard Unified Modeling Language. This book demonstrates how the notation and process complement one another, using UML models to illustrate the new process in action. The authors clearly describe the semantics and notation of the different higher-level constructs used in the models. Constructs such as use cases, actors, subsystems, classes, interfaces, active classes, processes, threads, nodes, and most relations are described in the context of a model. Object technology practitioners and software engineers familiar with the authors' past work will appreciate The Unified Software Development Process as a useful means of learning the current best practices in software development.

0201571692B04062001


About the Author

Ivar Jacobson is one of the “fathers” of components and component architecture, use cases, modern business engineering, the Unified Modeling Language, and the Rational Unified Profess. He is the principal author of five best-selling books on these methods and technologies, in addition to being the coauthor of the two leading books on the Unified Modeling Language. Ivar is an executive technical consultant to IBM Rational and founder of Ivar Jacobson International. He is also currently focusing his efforts on his new software company, Jaczone AB, where he and his daughter and cofounder, Agneta Jacobson, develop intelligent agents for software development. Grady Booch, is the Chief Scientist at Rational Software Corporation and developer of the Booch Method of object-oriented analysis and design. He is also co-developer of the Unified Modeling Language (UML). Widely recognized for these and many contributions in the field, he is a popular speaker at technology conferences around the world. Booch has twice received Software Development magazine's coveted Jolt-Cola Product Excellence Award for his seminal text, Object-Oriented Analysis and Design with Applications. Dr. James Rumbaugh is one of the leading object-oriented methodologists. He is the chief developer of the Object Modeling Technique (OMT) and the lead author of the best-selling book Object-Oriented Modeling and Design. Before joining Rational Software Corporation in October 1994, he worked for more than 25 years at General Electric Research and Development Center in Schenectady, New York. He has been working on object-oriented methodology and tools for many years. He developed the DSM object-oriented programming language, the state tree model of control, the OMT object modeling notation, and the Object Modeling Tool graphic editor. The foundations for the OMT notation were developed more than 10 years ago with Mary Loomis and Ashwin Shah of Calma Corporation. The OMT methodology was developed at GE R&D Center with coauthors Mike Blaha, Bill Premerlani, Fred Eddy, and Bill Lorensen. Dr. Rumbaugh received his Ph.D. in computer science from MIT. During his Ph.D. research under Professor Jack Dennis, Dr. Rumbaugh was one of the inventors of data flow computer architecture. His career has dealt with semantics of computation, tools for programming productivity, and applications using complex algorithms and data structures. Dr. Rumbaugh has published journal articles on his work and has spoken at leading object-oriented conferences. He writes a regular column for the Journal of Object-Oriented Programming. Dr. Rumbaugh is the lead author of the recent best-selling book Object-Oriented Modeling and Design, published by Prentice Hall. His latest book, OMT Insights: Perspectives on Modeling from the Journal of Object-Oriented Programming, was released in October 1996. He and his colleagues developed the OMT methodology described in the book based on real-world applications at GE, and they have worked to extend the original methodology. He has taught courses based on the methodology to different audiences around the world, ranging from one-hour seminars to intensive several-day training courses. He has a B.S. in physics from MIT, an M.S. in astronomy from Caltech, and a Ph.D. in computer science from MIT. During his career at GE, he worked on a variety of problems, including the design of one of the first time-sharing operating systems, early work in interactive graphics, algorithms for computed tomography, use of parallel machines for fast image generation, VLSI chip design, and finally, object-oriented technology. Jim developed OMTool, an interactive graphical editor for manipulation of object model diagrams. The editor is commercially available. In addition, he led a five-year programming effort producing production-quality software. In addition, Jim was the manager of the Software Engineering Program at GE, where he led a team of eight to ten Ph.D. and M.S. scientists performing research in software engineering in the areas of algorithm development, programming languages, program proving, and VLSI computer-aided design. In addition, he performed personal research. Jim developed Chipwright, an interactive graphical CAD system for VLSI layout with incremental design rule checking. He also led a team of four programmers in implementation. Jim developed and implemented the object-oriented language DSM, combining object-oriented concepts with database concepts and distributed it within GE for use on production applications. The language was heavily used at Calma Corporation and was extensively extended based on user feedback with a preliminary version. Jim also developed Vista, a hierarchical interactive standard graphics system (similar to the PHIGS system) written in the object-oriented DSM language. He implemented user-interface applications based on this system, including a configuration-management tool and a user-interface generation tool. Jim developed the concept of state trees, a structured extension of finite state machines incorporating a new model of object-oriented control. He applied it to the design of user interfaces, and the technique was used as a main aspect of the CHIDE user-interface system developed by colleagues at GE-CRD. Later, it was used in the OMTool object editor. Jim also developed the Flow Graph System, a generic interactive graphic system for controlling a network of design engineering jobs, including management of multiple versions of data and coordination of information flow among applications. He received a patent on the underlying concepts. In addition, Jim developed algorithms for the reconstruction of images for computerized tomography using fewer input points and with reduced noise in the reconstructed images. He also developed algorithms for display of three-dimensional images in real time using array processors, and he developed Parallax, a language for programming pipelined array processors. Jim has served on various committees, including the OOPSLA Program Committee and the TOOLS Program Committee.


Excerpt. © Reprinted by permission. All rights reserved.


0201571692P04062001

FROM OUR EDITORS

The Barnes & Noble Review

The Unified Modeling Language (UML) offers a powerful, standardized way to visualize, specify, construct, and document software systems, but it's a means, not an end in itself. As its founders observe, UML "must be used within the context of an end-to-end software process." In this widely anticipated book, Jacobson, Booch and Rumbaugh describe their Unified Process in depth for the first time.

In a nutshell, the Unified Process is use-case driven, architecture-centric, iterative and incremental. The authors explain what they mean by each of these elements in considerable detail, discussing why each is equally important, and how they all fit together.

The Unified Software Development Process covers the entire lifecycle, but focuses most on the activities UML itself focuses on: identifying requirements and capturing them as use cases; performing analysis; and building a design that reflects the requirements and analysis. There's detailed coverage of workflow throughout each iteration of the process, including inception, elaboration, construction, and transition.

It may take a little while to get your arms around all the ideas in this book. But once you do, you'll know how to build processes that can systematically achieve the benefits of object modeling, while remaining flexible enough for the chaotic real world we live in. — Review by Bill Camarda (Contributing Editor)

ANNOTATION

Ivar Jacobson, Grady Booch and James Rumbaugh have done it again. Written by the original designers of UML, this book details a unified software development process intended to be used with UML. With charts and examples, it examines use cases, architecture, and iterative and incremental development. The guide targets software developers dealing with lifecycle activities requirements, analysis, design, implementation and testing.

FROM THE PUBLISHER

The Objectory Software Development Process is a new software analysis and design process derived primarily from the three market leading OOA&D methods, Booch, OOSE (Use-Case), and OMT with ideas drawn from many other methods and input from many other parties. It is a component-based, use case driven, architecture centered, iterative and incremental developmental process that uses the Unified Modeling Language (UML) to represent models of the software system to be developed. The Objectory Software Development Process book describes, apart from the unified generic process and the different activities in developing a software system, the different models developed and evolved during the lifecycle of a system. It describes in an easy-to-understand way the different higher-level constructs — notation as well as semantics — used in the models. Thus stereotypes such as use cases and actors, packages, classes, stereotypes, interfaces, active classes, processes and threads, nodes, and most relations will be described in tuitively in the context of a model. The Objectory Software Development Process will go further then most OO A&D methods by describing a family of processes that incorporate the complete life-cycle of software development.

FROM THE CRITICS

Eduardo Fernandez - Electronic Review of Computer Books

Ivar Jacobson is generally considered the "father" of use cases. He appears to have written most of this book, and in a more general sense, he has clearly convinced Rational to build its development process around this concept. In The Unified Software Development Process, Jacobson comes across as a preacher out to convince lost souls about his truth.

For instance, on page 34 he states that "use cases drive the development process." In my experience, this is not necessarily the case. The main value of use cases is during the analysis stage and when developing system test cases. In truth, they don't help much at the design and implementation stages. For example, use cases do not carry information about structural aspects of the system and nonfunctional aspects. Nor, for that matter, do other process approaches (such as those described in Object-Oriented Development at Work: Fusion In the Real World, by R. Malan, R. Letringer, and D. Coleman, Prentice-Hall, 1996, or Use Cases Combined with Booch/OMT/UML: Process and Products, by P.P. Texel and C.B. Williams, Prentice-Hall, 1997), give such prominence to use cases.

The Unified process does not make a clear distinction between analysis and design; its analysis model uses controller and view classes. In my opinion (as well as James Rumbaugh's; see "OMT: The Development Process," JOOP, May 1995 -- why didn't he speak up here?), these classes are software artifacts and don't belong here. In fact, this separation of classes is just an application of an architectural design pattern -- the MVC -- which is not even mentioned in The Unified Software Development Process. No mention of analysis patterns can be found either, even though they will likely become very important to produce correct models of complex systems.

The discussion of architecture (page 83) doesn't consider important aspects such as mapping to hardware, distribution, serious use of architectural patterns, and the like. Design patterns also don't have an important role here.

Components are defined as "physical packaging of model elements;" that is, they are just the resulting implementations of the model classes. How about the use of components in a more modern fashion, JavaBeans, for instance, as done in the Nokia process (see "Extending the Object-Oriented Software Process with Component-Oriented Design," by M. Laitkorpi and A. Jaaksi, JOOP March-April 1999). In fact, components do not even have to be object based.

Although Rational is a well-known producer of tools, the process described in The Unified Development Process surprisingly doesn't make a significant use of tools. Three pages discuss tools in general at the beginning of the book and tools are briefly mentioned later, but there is no clear integration with the proposed process. Likewise, testing is also dealt with rather superficially. The chapter on testing deals mostly with integration testing. There is almost nothing on class testing; for example, the authors of The Unified Development Process don't consider the use of pre- and postconditions and other important issues. What is worse, the concept that testing should be applied at all stages of development is not considered. The references in this section reflect a lack of awareness of progress in this area.

On the upside, at least in terms of practical value, the book provides a clear definition and separation of roles and people involved in the process. This is probably the strongest point of the Unified process described in the book. The running examples are good and help the reader to understand the concepts. They should have been given more importance. Some data on the experience of using this approach would have been useful.

The style is clear, but verbose. More examples, diagrams, and discussion of cases would have been more appropriate than so many philosophical discussions about the value of their approach. Pages 441-480, for instance, are a glossary -- the need for which I cannot understand in an advanced book like this. Do readers need to be told what an "object" or "state" is?

In summary, The Unified Software Development Process should be taken as a user manual for anyone already using or contemplating use of the Rational process. It doesn't provide much insight on how this approach compares to other approaches. Most of the references are to the work of Rational people, the process models of others are ignored. The book doesn't much help somebody looking for a possible process to use. Truly, this is not a scholarly book, but it would have been nice to see how they compare their approach to others.

There is no doubt that the authors have a good deal of knowledge and experience. My objections are to the biased approach and the lack of comparison with other approaches. This book looks too much like a typical vendor book, i.e. "We invented everything." Also, Jacobson has completely smothered Rumbaugh and Booch here; their process philosophies don't shine through. What is worse, the Unified process as described here appears antiquated because of its lack of emphasis on patterns and components.

I am not saying that you cannot learn something from The Unified Software Development Process, but I found it disappointing, especially after seeing the other two volumes by this trio.

Booknews