One of the most important recent developments in software engineering is the Unified Modeling Language (UML) standard for documenting software designs. Written by UML's inventors (the so-called Three Amigos of software engineering), The Unified Modeling Language User Guide provides a very appealing guide to all the fundamentals of using UML effectively. The book opens with a basic tour of the essential concepts and modeling diagrams used in UML, including class diagrams, use case diagrams, and basic modeling principles. The authors pay close attention to modeling classes (and documenting the relationships between classes) as well as use case diagrams (which show how software will be used by various actors in a system). This book mixes in a little software-engineering theory, too, but it makes use of clear examples and actual UML diagrams to illustrate key concepts.

Later in the book, the authors discuss more difficult notational diagrams (such as state diagrams and activity diagrams, which can be used to model behavior in a system). Whatever your background in software engineering, you'll no doubt appreciate the author's clear explanations of basic (and advanced) modeling concepts, as well as the nuts-and-bolts details of today's powerful UML. With its combination of expert modeling advice and excellent detail on the specifics of UML, this book will be absolutely essential reading for anyone who wants to use UML for real-world software design. --Richard Dragan


From Book News, Inc.
A tutorial to the core aspects of the UML by the language's original developers. Begins with a conceptual model of the UML and then progressively applies the UML to a series of increasingly complex modeling problems across a variety of application domains. Covers structural modeling, behavioral modeling, and architectural modeling. Also includes a learning track focused on applying the UML to advanced modeling systems for more advanced developers. Appends information on UML notation, standard elements, and rational unified processes. Book News, Inc.®, Portland, OR


Book Info
Provides anyone involved in the production, deployment, & maintenance of software with a standard notation for expressing a system's blueprint. Provides a tutorial to the core aspects of the language in a 2-color format designed to facilitate learning. DLC: Computer software Development.


Card catalog description
In The Unified Modeling Language User Guide, the original developers of the UML - Grady Booch, James Rumbaugh, and Ivar Jacobson - provide a tutorial to the core aspects of the language in a two-color format designed to facilitate learning. Starting with a conceptual model of the UML, the book progressively applies the UML to a series of increasingly complex modeling problems across a variety of application domains. This example-driven approach helps readers quickly understand and apply the UML. For more advanced developers, the book includes a learning track focused on applying the UML to advanced modeling problems.


From the Inside Flap
The Unified Modeling Language (UML) is a graphical language for visualizing, specifying, constructing, and documenting the artifacts of a software-intensive system. The UML gives you a standard way to write a system's blueprints, covering conceptual things, such as business processes and system functions, as well as concrete things, such as classes written in a specific programming language, database schemas, and reusable software components. This book teaches you how to use the UML effectively. Goals In this book, you willLearn what the UML is, what it is not, and why the UML is relevant to the process of developing software-intensive systems Master the vocabulary, rules, and idioms of the UML and, in general, learn how to "speak" the language effectively Understand how to apply the UML to solve a number of common modeling problems The user guide provides a reference to the use of specific UML features. However, it is not intended to be a comprehensive reference manual for the UML; that is the focus of another book, The Unified Modeling Language Reference Manual (Rumbaugh, Jacobson, Booch, Addison-Wesley, 1999). The user guide describes a development process for use with the UML. However, it is not intended to provide a complete reference to that process; that is the focus of yet another book, The Unified Software Development Process (Jacobson, Booch, Rumbaugh, Addison-Wesley, 1999). Finally, this book provides hints and tips for using the UML to solve a number of common modeling problems, but it does not teach you how to model. This is similar to a user guide for a programming language that teaches you how to use the language but does not teach you how to program. Audience The UML is applicable to anyone involved in the production, deployment, and maintenance of software. The user guide is primarily directed to members of the development team who create UML models. However, it is also suitable to those who read them, working together to understand, build, test, and release a software-intensive system. Although this encompasses almost every role in a software development organization, the user guide is especially relevant to analysts and end users (who specify the required structure and behavior of a system), architects (who design systems that satisfy those requirements), developers (who turn those architectures into executable code), quality assurance personnel (who verify and validate the system's structure and behavior), librarians (who create and catalogue components), and project and program managers (who generally wrestle with chaos, provide leadership and direction, and orchestrate the resources necessary to deliver a successful system). The user guide assumes a basic knowledge of object-oriented concepts. Experience in an object-oriented programming language or method is helpful but not required. How to Use This Book For the developer approaching the UML for the first time, the user guide is best read linearly. You should pay particular attention to Chapter 2, which presents a conceptual model of the UML. All chapters are structured so that each builds upon the content of the previous one, thus lending itself to a linear progression. For the experienced developer seeking answers to common modeling problems using the UML, this book can be read in any order. You should pay particular attention to the common modeling problems presented in each chapter. Organization and Special Features The user guide is organized into seven major sections:Section 1 Getting Started Section 2 Basic Structural Modeling Section 3 Advanced Structural Modeling Section 4 Basic Behavioral Modeling Section 5 Advanced Behavioral Modeling Section 6 Architectural Modeling Section 7 Wrapping Up The user guide contains three appendices: a summary of the UML notation, a list of standard UML elements, and a summary of the Rational Unified Process. A glossary of common terms is also provided. Each chapter addresses the use of a specific UML feature, and most are organized into the following four sections:Getting Started Terms and Concepts Common Modeling Techniques Hints and Tips The third section introduces and then solves a set of common modeling problems. To make it easy for you to browse the guide in search of these use cases for the UML, each problem is identified by a distinct heading. Each chapter begins with a summary of the features it covers, as in the following example. In this chapterActive objects, processes, and threads Modeling multiple flows of control Modeling interprocess communication Building thread-safe abstractions Similarly, parenthetical comments and general guidance are set apart as notes, as in the following example. Note: You can specify more complex multiplicities by using a list, such as 0..1, 3..4, 6..*, which would mean "any number of objects other than 2 or 5." The UML is semantically rich. Therefore, a presentation about one feature may naturally involve another. In such cases, cross references are provided in the left margin. Blue highlights are used in figures to distinguish text that explains a model from text that is part of the model itself. Code is distinguished by displaying it in a monospace font, as in this example. A Brief History of the UML Object-oriented modeling languages appeared sometime between the mid 1970s and the late 1980s as methodologists, faced with a new genre of object-oriented programming languages and increasingly complex applications, began to experiment with alternative approaches to analysis and design. The number of object-oriented methods increased from fewer than 10 to more than 50 during the period between 1989 and 1994. Many users of these methods had trouble finding a modeling language that met their needs completely, thus fueling the so-called method wars. Learning from experience, new generations of these methods began to appear, with a few clearly prominent methods emerging, most notably Booch, Jacobson's OOSE (Object-Oriented Software Engineering), and Rumbaugh's OMT (Object Modeling Technique). Other important methods included Fusion, Shlaer-Mellor, and Coad-Yourdon. Each of these was a complete method, although each was recognized as having strengths and weaknesses. In simple terms, the Booch method was particularly expressive during the design and construction phases of projects, OOSE provided excellent support for use cases as a way to drive requirements capture, analysis, and high-level design, and OMT-2 was most useful for analysis and data-intensive information systems. A critical mass of ideas started to form by the mid 1990s, when Grady Booch (Rational Software Corporation), Ivar Jacobson (Objectory), and James Rumbaugh (General Electric) began to adopt ideas from each other's methods, which collectively were becoming recognized as the leading object-oriented methods worldwide. As the primary authors of the Booch, OOSE, and OMT methods, we were motivated to create a unified modeling language for three reasons. First, our methods were already evolving toward each other independently. It made sense to continue that evolution together rather than apart, eliminating the potential for any unnecessary and gratuitous differences that would further confuse users. Second, by unifying our methods, we could bring some stability to the object-oriented marketplace, allowing projects to settle on one mature modeling language and letting tool builders focus on delivering more useful features. Third, we expected that our collaboration would yield improvements for all three earlier methods, helping us to capture lessons learned and to address problems that none of our methods previously handled well. As we began our unification, we established three goals for our work:To model systems, from concept to executable artifact, using object- oriented techniques To address the issues of scale inherent in complex, mission-critical systems To create a modeling language usable by both humans and machines Devising a language for use in object-oriented analysis and design is not unlike designing a programming language. First, we had to constrain the problem: Should the language encompass requirements specification? Should the language be sufficient to permit visual programming? Second, we had to strike a balance between expressiveness and simplicity. Too simple a language would limit the breadth of problems that could be solved; too complex a language would overwhelm the mortal developer. In the case of unifying existing methods, we also had to be sensitive to the installed base. Make too many changes, and we would confuse existing users; resist advancing the language, and we would miss the opportunity of engaging a much broader set of users and of making the language simpler. The UML definition strives to make the best trade-offs in each of these areas. The UML effort started officially in October 1994, when Rumbaugh joined Booch at Rational. Our project's initial focus was the unification of the Booch and OMT methods. The version 0.8 draft of the Uni


From the Back Cover
Introduced in 1997, the Unified Modeling Language (UML) has rapidly been accepted throughout the software industry as the standard graphical language for specifying, constructing, visualizing, and documenting software-intensive systems. The UML provides anyone involved in the production, deployment, and maintenance of software with a standard notation for expressing a system's blueprint. The UML covers conceptual things, such as business processes and system functions, as well as concrete things, such as programming-language classes, database schemas, and reusable software components. In The Unified Modeling Language User Guide, the original developers of the UML--Grady Booch, James Rumbaugh, and Ivar Jacobson--provide a tutorial to the core aspects of the language in a two-color format designed to facilitate learning. Starting with a conceptual model of the UML, the book progressively applies the UML to a series of increasingly complex modeling problems across a variety of application domains. This example-driven approach helps readers quickly understand and apply the UML. For more advanced developers, the book includes a learning track focused on applying the UML to advanced modeling problems. With The Unified Modeling Language User Guide, readers will: understand what the UML is, what it is not, and why it is relevant to the development of software-intensive systems master the vocabulary, rules, and idioms of the UML in order to "speak" the language effectively learn how to apply the UML to a number of common modeling problems see illustrations of the UML's use interspersed with use cases for specific UML features gain insight into the UML from the original creators of the UML

0201571684B04062001


About the Author
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.

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.


Excerpt. © Reprinted by permission. All rights reserved.
The Unified Modeling Language (UML) is a graphical language for visualizing, specifying, constructing, and documenting the artifacts of a software-intensive system. The UML gives you a standard way to write a system's blueprints, covering conceptual things, such as business processes and system functions, as well as concrete things, such as classes written in a specific programming language, database schemas, and reusable software components. This book teaches you how to use the UML effectively. Goals In this book, you will Learn what the UML is, what it is not, and why the UML is relevant to the process of developing software-intensive systems Master the vocabulary, rules, and idioms of the UML and, in general, learn how to "speak" the language effectively Understand how to apply the UML to solve a number of common modeling problems The user guide provides a reference to the use of specific UML features. However, it is not intended to be a comprehensive reference manual for the UML; that is the focus of another book, The Unified Modeling Language Reference Manual (Rumbaugh, Jacobson, Booch, Addison-Wesley, 1999). The user guide describes a development process for use with the UML. However, it is not intended to provide a complete reference to that process; that is the focus of yet another book, The Unified Software Development Process (Jacobson, Booch, Rumbaugh, Addison-Wesley, 1999). Finally, this book provides hints and tips for using the UML to solve a number of common modeling problems, but it does not teach you how to model. This is similar to a user guide for a programming language that teaches you how to use the language but does not teach you how to program. Audience The UML is applicable to anyone involved in the production, deployment, and maintenance of software. The user guide is primarily directed to members of the development team who create UML models. However, it is also suitable to those who read them, working together to understand, build, test, and release a software-intensive system. Although this encompasses almost every role in a software development organization, the user guide is especially relevant to analysts and end users (who specify the required structure and behavior of a system), architects (who design systems that satisfy those requirements), developers (who turn those architectures into executable code), quality assurance personnel (who verify and validate the system's structure and behavior), librarians (who create and catalogue components), and project and program managers (who generally wrestle with chaos, provide leadership and direction, and orchestrate the resources necessary to deliver a successful system). The user guide assumes a basic knowledge of object-oriented concepts. Experience in an object-oriented programming language or method is helpful but not required. How to Use This Book For the developer approaching the UML for the first time, the user guide is best read linearly. You should pay particular attention to Chapter 2, which presents a conceptual model of the UML. All chapters are structured so that each builds upon the content of the previous one, thus lending itself to a linear progression. For the experienced developer seeking answers to common modeling problems using the UML, this book can be read in any order. You should pay particular attention to the common modeling problems presented in each chapter. Organization and Special Features The user guide is organized into seven major sections: Section 1 Getting Started Section 2 Basic Structural Modeling Section 3 Advanced Structural Modeling Section 4 Basic Behavioral Modeling Section 5 Advanced Behavioral Modeling Section 6 Architectural Modeling Section 7 Wrapping Up The user guide contains three appendices: a summary of the UML notation, a list of standard UML elements, and a summary of the Rational Unified Process. A glossary of common terms is also provided. Each chapter addresses the use of a specific UML feature, and most are organized into the following four sections: Getting Started Terms and Concepts Common Modeling Techniques Hints and Tips The third section introduces and then solves a set of common modeling problems. To make it easy for you to browse the guide in search of these use cases for the UML, each problem is identified by a distinct heading. Each chapter begins with a summary of the features it covers, as in the following example. In this chapter Active objects, processes, and threads Modeling multiple flows of control Modeling interprocess communication Building thread-safe abstractions Similarly, parenthetical comments and general guidance are set apart as notes, as in the following example. Note: You can specify more complex multiplicities by using a list, such as 0..1, 3..4, 6..*, which would mean "any number of objects other than 2 or 5." The UML is semantically rich. Therefore, a presentation about one feature may naturally involve another. In such cases, cross references are provided in the left margin. Blue highlights are used in figures to distinguish text that explains a model from text that is part of the model itself. Code is distinguished by displaying it in a monospace font, as in this example. A Brief History of the UML Object-oriented modeling languages appeared sometime between the mid 1970s and the late 1980s as methodologists, faced with a new genre of object-oriented programming languages and increasingly complex applications, began to experiment with alternative approaches to analysis and design. The number of object-oriented methods increased from fewer than 10 to more than 50 during the period between 1989 and 1994. Many users of these methods had trouble finding a modeling language that met their needs completely, thus fueling the so-called method wars. Learning from experience, new generations of these methods began to appear, with a few clearly prominent methods emerging, most notably Booch, Jacobson's OOSE (Object-Oriented Software Engineering), and Rumbaugh's OMT (Object Modeling Technique). Other important methods included Fusion, Shlaer-Mellor, and Coad-Yourdon. Each of these was a complete method, although each was recognized as having strengths and weaknesses. In simple terms, the Booch method was particularly expressive during the design and construction phases of projects, OOSE provided excellent support for use cases as a way to drive requirements capture, analysis, and high-level design, and OMT-2 was most useful for analysis and data-intensive information systems. A critical mass of ideas started to form by the mid 1990s, when Grady Booch (Rational Software Corporation), Ivar Jacobson (Objectory), and James Rumbaugh (General Electric) began to adopt ideas from each other's methods, which collectively were becoming recognized as the leading object-oriented methods worldwide. As the primary authors of the Booch, OOSE, and OMT methods, we were motivated to create a unified modeling language for three reasons. First, our methods were already evolving toward each other independently. It made sense to continue that evolution together rather than apart, eliminating the potential for any unnecessary and gratuitous differences that would further confuse users. Second, by unifying our methods, we could bring some stability to the object-oriented marketplace, allowing projects to settle on one mature modeling language and letting tool builders focus on delivering more useful features. Third, we expected that our collaboration would yield improvements for all three earlier methods, helping us to capture lessons learned and to address problems that none of our methods previously handled well. As we began our unification, we established three goals for our work: To model systems, from concept to executable artifact, using object- oriented techniques To address the issues of scale inherent in complex, mission-critical systems To create a modeling language usable by both humans and machines Devising a language for use in object-oriented analysis and design is not unlike designing a programming language. First, we had to constrain the problem: Should the language encompass requirements specification? Should the language be sufficient to permit visual programming? Second, we had to strike a balance between expressiveness and simplicity. Too simple a language would limit the breadth of problems that could be solved; too complex a language would overwhelm the mortal developer. In the case of unifying existing methods, we also had to be sensitive to the installed base. Make too many changes, and we would confuse existing users; resist advancing the language, and we would miss the opportunity of engaging a much broader set of users and of making the language simpler. The UML definition strives to make the best trade-offs in each of these areas. The UML effort started officially in October 1994, when Rumbaugh joined Booch at Rational. Our project's initial focus was the unification of the Booch and OMT methods. The version 0.8 draft of the Unified Method (as it was then called) was released in October 1995. Around the same time, Jacobson joined Rational and the scope of the UML project was expanded to incorporate OOSE. Our efforts resulted in the release of the UML version 0.9 documents in June 1996. Throughout 1996, we invited and received feedback from the general software engineering community. During this time, it also became clear that many software organizations saw the UML as strategic to their business. We established a UML consortium, with several organizations willing to dedicate resources to work toward a strong and complete UML definition. Those partners contributing to the UML 1.0 definition included Digital Equipment Corporation, Hewlett-Packard, I-Logix, Intellicorp, IBM, ICON Computing, MCI Systemhouse, Microsoft, Oracle, Rational, Texas Instruments, and Unisys. This collaboration resulted in the UML 1.0, a modeling language that was well-defined, expressive, powerful, and applicable to a wide spectrum of problem domains. UML 1.0 was offered for standardization to the Object Management Group (OMG) in January 1997, in response to their request for proposal for a standard modeling language. Between January 1997 and July 1997, the original group of partners was expanded to include virtually all of the other submitters and contributors of the original OMG response, including Andersen Consulting, Ericsson, ObjecTime Limited, Platinum Technology, PTech, Reich Technologies, Softeam, Sterling Software, and Taskon. A semantics task force was formed, led by Cris Kobryn of MCI Systemhouse and administered by Ed Eykholt of Rational, to formalize the UML specification and to integrate the UML with other standardization efforts. A revised version of the UML (version 1.1) was offered to the OMG for standardization in July 1997. In September 1997, this version was accepted by the OMG Analysis and Design Task Force (ADTF) and the OMG Architecture Board and then put up for vote by the entire OMG membership. UML 1.1 was adopted by the OMG on November 14, 1997. Maintenance of the UML was then taken over by the OMG Revision Task Force (RTF), led by Cris Kobryn. The RTF released an editorial revision, UML 1.2, in June 1998. In fall 1998, the RTF released UML 1.3, which this user guide describes, providing some technical cleanup. Acknowledgments Grady Booch, Ivar Jacobson, and James Rumbaugh began the UML effort and throughout the project were its original designers, but the final product was a team effort among all the UML partners. Although all partners came with their own perspectives, areas of concern, and areas of interest, the overall result has benefited from the contributions of each of them and from the diversity of their experience and viewpoints. The core UML team included Hewlett-Packard: Martin Griss I-Logix: Eran Gery, David Harel IBM: Steve Cook, Jos Warmer ICON Computing: Desmond D'Souza Intellicorp and James Martin and Company: James Odell MCI Systemhouse: Cris Kobryn, Joaquin Miller ObjecTime: John Hogg, Bran Selic Oracle: Guus Ramackers Platinum Technology: Dilhar DeSilva Rational Software: Grady Booch, Ed Eykholt, Ivar Jacobson, Gunnar Overgaard, Karin Palmkvist, James Rumbaugh Taskon: Trygve Reenskaugh Texas Instruments/Sterling Software: John Cheesman, Keith Short Unisys: Sridhar Iyengar, G.K. Khalsa Cris Kobryn deserves a special acknowledgment for his leadership in directing the UML technical team during the development of UML 1.1, 1.2, and 1.3. We also acknowledge the contributions, influence, and support of the following individuals. In some cases, individuals mentioned here have not formally endorsed the UML but are nonetheless appreciated for their influence: Jim Amsden, Hernan Astudillo, Colin Atkinson, Dave Bernstein, Philip Bernstein, Michael Blaha, Conrad Bock, Mike Bradley, Ray Buhr, Gary Cernosek, James Cerrato, Michael Jesse Chonoles, Magnus Christerson, Dai Clegg, Geoff Clemm, Peter Coad, Derek Coleman, Ward Cunningham, Raj Datta, Philippe Desfray, Mike Devlin, Bruce Douglass, Staffan Ehnebom, Maria Ericsson, Johannes Ernst, Don Firesmith, Martin Fowler, Adam Frankl, Eric Gamma, Dipayan Gangopadhyay, Garth Gullekson, Rick Hargrove, Tim Harrison, Richard Helm, Brian Hendersen-Sellers, Michael Hirsch, Bob Hodges, Yves Holvoet, Jon Hopkins, John Hsia, Glenn Hughes, Ralph Johnson, Anneke Kleppe, Philippe Kruchten, Paul Kyzivat, Martin Lang, Grant Larsen, Reed Letsinger, Mary Loomis, Jeff MacKay, Joe Marasco, Robert Martin, Terri McDaniel, Jim McGee, Mike Meier, Randy Messer, Bertrand Meyer, Greg Meyers, Fred Mol, Luis Montero, Paul Moskowitz, Andy Moss, Jan Pachl, Paul Patrick, Woody Pidcock, Bill Premerlani, Jeff Price, Jerri Pries, Terry Quatrani, Mats Rahm, Rudolf Riess, Rich Reitman, Erick Rivas, Kenny Rubin, Jim Rye, Danny Sabbahr, Tom Schultz, Colin Scott, Ed Seidewitz, Keith Short, Gregson Sui, Jeff Sutherland, Dan Tasker, Andy Trice, Dave Tropeano, Dan Uhlar, John Vlissides, Larry Wall, Paul Ward, Alan Willis, Rebecca Wirfs-Brock, Bryan Wood, Ed Yourdon, and Steve Zeigler. The development of the UML was an open process, and via the OTUG (Object Technology User's Group) we received thousands of e-mail messages from all over the world. Although we cannot mention every submitter by name, we do thank all of them for their comments and suggestions. We really did read each message, and the UML is better because of this broad international feedback. A special acknowledgment also goes to a small band of lab rats (Loud and Boisterous RATional Students) who participated in a user guide course led by Booch in early 1997, during which they offered excellent ideas and gave much constructive criticism that helped fine-tune the contents of this book: Hernan Astudillo, Robin Brown, Robert Bundy, Magnus Christerson, Adam Frankl, Nookiah Kolluru, Ron Krubek, Grant Larsen, Dean Leffingwell, Robert Martin, Mills Ripley, Hugo Sanchez, Geri Schneider, Tom Schultz, Andy Trice, Dan Uhlar, and Lloyd Williams. Thanks go to the madmen at Number Six Software and to the folks who provided a technical review of this book: Jack Carter, Tim Budd, Bruce Douglass, Martin Fowler, Cris Kobryn, Philippe Kruchten, Ron Lusk, Terry Quatrani, and David Rine. For More Information The most current information about the UML, including its formal specification, may be found on the Internet at www.rational.com and www.omg.org. The work of the revision task force may be found at uml.shl.com. There are several electronic forums that are appropriate for general discussion about the UML, including the Internet news groups comp.software-eng and comp.object and the public mailing lists otug@rational.com and uml-rtf@omg.org. Grady Booch Lakewood, Colorado September 1998 egb@rational.com

0201571684P04062001

ANNOTATION

From the developers of UML, this tutorial reviews the core aspects of the language used to specify construct, visualize and document software-intensive systems. The authors begin with a conceptual model and progressively apply UML to increasingly complex models for a variety of applications. To derive the most benefit from this publication, you should be familiar with software engineering concepts and object-oriented modeling. After all, the author's intent is to teach you how to use UML effectively, not to go through the entire development process, or provide a reference for UML. Other publications listed below address those important issues.

FROM THE PUBLISHER

Introduced in 1997, the Unified Modeling Language (UML) has rapidly been accepted throughout the software industry as the standard graphical language for specifying, constructing, visualizing, and documenting software-intensive systems. The UML provides anyone involved in the production, deployment, and maintenance of software with a standard notation for expressing a system's blueprint. The UML covers conceptual things, such as business processes and system functions, as well as concrete things, such as programming-language classes, database schemas, and reusable software components. In The Unified Modeling Language User Guide, the original developers of the UML-Grady Booch, James Rumbaugh, and Ivar Jacobson-provide a tutorial to the core aspects of the language in a two-color format designed to facilitate learning. Starting with a conceptual model of the UML, the book progressively applies the UML to a series of increasingly complex modeling problems across a variety of application domains. This example-driven approach helps readers quickly understand and apply the UML. For more advanced developers, the book includes a learning track focused on applying the UML to advanced modeling problems.

With The Unified Modeling Language User Guide, readers will: understand what the UML is, what it is not, and why it is relevant to the development of software-intensive systems master the vocabulary, rules, and idioms of the UML in order to "speak" the language effectively learn how to apply the UML to a number of common modeling problems see illustrations of the UML's use interspersed with use cases for specific UML features gain insight into the UML from the original creators of the UML

SYNOPSIS

The Unitied Modeling Language User Guide, is the first of two UML works written by the creators of UML. This book will introduce the core 80 percent of UML, approaching it in a layered fashion and providing numerous examples of it s application. The title is suitable for developers unfamiliar with UML or with modeling in general.

FROM THE CRITICS

Booknews

A tutorial to the core aspects of the UML by the language's original developers. Begins with a conceptual model of the UML and then progressively applies the UML to a series of increasingly complex modeling problems across a variety of application domains. Covers structural modeling, behavioral modeling, and architectural modeling. Also includes a learning track focused on applying the UML to advanced modeling systems for more advanced developers. Appends information on UML notation, standard elements, and rational unified processes. Annotation c. by Book News, Inc., Portland, Or.

Eduardo Fernandez

More UML Books

Until now, object-oriented projects in the computer industry have emphasized languages over models; many people believe that object-oriented programming means using C++ or Java. This is clearly a misunderstanding. Object-oriented programming is a method of problem solving, not a language issue; one can write object-oriented programs in Assembly language and write nonobject-oriented programs in C++. The key to object-oriented programming is modeling. Hopefully, the emergence of UML (Unified Modeling Language), as the OMG (Object Management Group) standard, will help change that situation. The standardization of modeling notations ends the confusion produced by a myriad of competing notations, which although they all had similar semantics, made claims to be unique or better than the others. While UML may not be perfect, its use as a standard will make modeling more uniform and better understood.

UML: The Unified Modeling Language User Guide, and The UML Reference Manual, both by Grady Booch, Jim Rumbaugh, and Ivor Jacobson, are long-awaited books from the main designers of UML. They will not disappoint those who waited. These books are excellent descriptions of what users need to know in order to use UML for practical applications.

The User Guide is divided into six main sections: "Getting Started" (three chapters), "Basic Structural Modeling" (five chapters), "Advanced Structural Modeling" (six chapters ), "Basic Behavioral Modeling" (five chapters), "Advanced Behavioral Modeling" (five chapters), and "Architectural Modeling" (seven chapters). The chapters include every aspect of UML, with examples and detailed discussions. The material is well organized and each chapter includes a general description of the concepts and some practical advice on their use. The examples are carefully chosen and I could not find any errors. Each chapter also includes a section on reverse engineering, which should be very valuable for practitioners. Thirty-three pages of appendices summarize UML and the Rational process (the authors all work for Rational, Inc.). It also includes a superfluous glossary (it even has a definition of UML in case you still didn't understand what it is).

The Reference Manual complements the User Guide by alphabetically describing in detail each language concept. For each concept, its notation and semantics are described; in many cases there is also a discussion section and an example. The coverage is quite complete (the reference section covers about 400 pages), in clear and precise language. The book also includes 12 chapters (90 pages) with general aspects of UML. Three appendices describe the UML metamodel, a notation summary, and process extensions. I'd have liked to see the explanation of concepts in terms of the metamodel; the examples are good for understanding, but not very precise.

Overall, these books fulfill their mission very well--they are authoritative sources of notation, definitions, usage, style, and general insight into UML. However, don't get any ideas about learning object-oriented concepts from them because this is not their purpose, and the books assume you already know this. For some ideas of where to look for basic concepts see my "Programmer's Bookshelf," DDJ, December 1998. The style of both books is clear, although at times perhaps too simple in an attempt to reach a wide audience, and at times verbose. There are also repetitions because of the organization of each chapter or section.

For a method that is the result of many suggestions and somewhat controversial as a standard, it is surprising that no references are given in the User Guide and only a few (mostly books) in the Reference Manual. A more complete set of references would have helped the reader to see how some of their ideas originated, what alternatives exist, what is missing, and in general, to provide a deeper understanding of the language.

I have used books by Rumbaugh and Booch in my classes, and the high level of their writing shines through these books. Jacobson is the originator of the concept of Use Cases and his style also shows here. The authors have incorporated ideas and suggestions from many sources, but they have been able to keep the core philosophy of their early work.

The Object Constraint Language: Precise Modeling With UML, by J. Warner and A. Kloppe, describes the OCL (Object Constraint Language), a language intended to complement UML and similar languages with a notation to express constraints precisely. A constraint is a restriction in some of the values of the model. OCL originated in IBM and one of the authors works for that company.

In contrast to similar approaches (such as Syntropy, see "Let's Get Formal," by S. Cook and J. Daniels, Journal of Object-Oriented Programming, July-August 1994), that use Z or a known formal language to make UML constraints more precise, OCL is a language expressly designed for this purpose, attempting to be both formal and simple. Its supposed simplicity comes from making the notation more verbose and less symbolic. I have my doubts that this really provides simplicity: If I know the meaning of "element x belongs to set A" written symbolically as in Z , seeing it written as "x belongs to A" doesn't make it simpler; if I don't know its meaning, the words don't help.

The book illustrates most of the concepts with a small, clear example. I'd have liked to see a more complex example, similar to the ones described by Cook and Daniels, to appreciate whether it is really simpler than Z. This is a slim book, 86 pages of material, and the rest includes two appendices, a concise reference manual for OCL, and a description of its formal grammar. A short but well chosen set of references ends this book. In spite of my doubts, I like the attempt to make software more rigorous. We need that for the complex software systems of the future.

In summary, UML: The Unified Modeling Language User Guide and The UML Reference Manual are must-have books for any development group and each developer should at least have the User Guide. The Object Constraint Language: Precise Modeling With UML is highly recommended. I'd like to see programmers increasing the precision of their analysis models.