Second edition of a proven practical guide to the essentials of both the Unified Modeling Language and the IBM/Rational Unified Process.
° Fully updated for UML 2.0 and highlights the latest features of the IBM/Rational Unified Process
° Emphasizes tips and tricks that help the reader become an expert analyst and designer
° Includes a new section on the OMG's MDA initiative, coverage of RUP stereotypes, and a new appendix relating the book to UML certification
"This book manages to convey the practical use of UML 2 in clear and understandable terms with many examples and guidelines. Even for people not working with the Unified Process, the book is still of great use. UML 2 and the Unified Process, Second Edition is a must-read for every UML 2 beginner and a helpful guide and reference for the experienced practitioner."
--Roland Leibundgut, Technical Director, Zuehlke Engineering Ltd.
"This book is a good starting point for organizations and individuals who are adopting UP and need to understand how to provide visualization of the different aspects needed to satisfy it. "
--Eric Naiburg, Market Manager, Desktop Products, IBM Rational Software
This thoroughly revised edition provides an indispensable and practical guide to the complex process of object-oriented analysis and design using UML 2. It describes how the process of OO analysis and design fits into the software development lifecycle as defined by the Unified Process (UP).
UML 2 and the Unified Process contains a wealth of practical, powerful, and useful techniques that you can apply immediately. As you progress through the text, you will learn OO analysis and design techniques, UML syntax and semantics, and the relevant aspects of the UP. The book provides you with an accurate and succinct summary of both UML and UP from the point of view of the OO analyst and designer.
This book provides
New to this edition:
The accompanying website provides
Download the Sample
Chapter related to this title.
I. INTRODUCING UML AND UP.
1. What is UML?
1.1 Chapter roadmap
1.2 What is UML?
1.3 The birth of UML
1.4 MDA - the future of UML
1.5 Why "unified"?
1.6 Objects and UML
1.7 UML structure
1.8 UML building blocks
1.9 UML common mechanisms
1.11 What we have learned
2. What is the Unified Process?
2.1 Chapter roadmap
2.2 What is UP?
2.3 The birth of UP
2.4 UP and the Rational Unified Process
2.5 Instantiating UP for your project
2.6 UP axioms
2.7 UP is an iterative and incremental process
2.8 UP structure
2.9 UP phases
2.10 What we have learned
3. The requirements workflow.
3.1 Chapter roadmap
3.2 The requirements workflow
3.3 Software requirements - metamodel
3.4 Requirements workflow detail
3.5 The importance of requirements
3.6 Defining requirements
3.7 Finding requirements
3.8 What we have learned
4. Use case modeling.
4.1 Chapter roadmap
4.2 Use case modeling
4.3 UP activity: Find actors and use cases
4.4 UP activity: Detail a use case
4.5 Use case specification
4.6 Requirements tracing
4.7 When to apply use case modeling
4.8 What we have learned
5. Advanced use case modeling.
5.1 Chapter roadmap
5.2 Actor generalization
5.3 Use case generalization
5.6 When to use advanced features
5.7 Hints and tips for writing use cases
5.8 What we have learned
6. The analysis workflow.
6.1 Chapter roadmap
6.2 The analysis workflow
6.3 Analysis artifacts - metamodel
6.4 Analysis workflow detail
6.5 Analysis model - rules of thumb
6.6 What we have learned
7. Objects and classes.
7.1 Chapter roadmap
7.2 What are objects?
7.3 UML object notation
7.4 What are classes?
7.5 UML class notation
7.7 Object construction and destruction
7.8 What we have learned
8. Finding analysis classes.
8.1 Chapter roadmap
8.2 UP activity: Analyze a use case
8.3 What are analysis classes?
8.4 Finding classes
8.5 Creating a first-cut analysis model
8.6 What we have learned
9.1 Chapter roadmap
9.2 What is a relationship?
9.3 What is a link?
9.4 What is an association?
9.5 What is a dependency?
9.6 What we have learned
10. Inheritance and polymorphism.
10.1 Chapter roadmap
10.3 Class inheritance
10.5 Advanced generalization
10.6 What we have learned
11. Analysis packages.
11.1 Chapter roadmap
11.2 What is a package?
11.3 Packages and namespaces
11.4 Nested packages
11.5 Package dependencies
11.6 Package generalization
11.7 Architectural analysis
11.8 What we have learned
12. Use case realization.
12.1 Chapter roadmap
12.2 UP activity: Analyze a use case
12.3 What are use case realizations?
12.4 Use case realization - elements
12.8 Interaction diagrams
12.9 Sequence diagrams
12.10 Combined fragments and operators
12.11 Communication diagrams
12.12 What we have learned
13. Advanced use case realization.
13.1 Chapter roadmap
13.2 Interaction occurrences
13.4 What we have learned
14. Activity diagrams.
14.1 Chapter roadmap
14.2 What are activity diagrams?
14.3 Activity diagrams and the UP
14.5 Activity semantics
14.6 Activity partitions
14.7 Action nodes
14.8 Control nodes
14.9 Object nodes
14.11 What we have learned
15. Advanced activity diagrams.
15.1 Chapter roadmap
15.3 Interruptible activity regions
15.4 Exception handling
15.5 Expansion nodes
15.6 Sending signals and accepting events
15.8 Advanced object flow features
15.9 Multicast and multireceive
15.10 Parameter sets
15.11 "centralBuffer" node
15.12 Interaction overview diagrams
15.13 What we have learned
16. The design workflow.
16.1 Chapter roadmap
16.2 The design workflow
16.3 Design artifacts - metamodel
16.4 Design workflow detail
16.5 UP activity: Architectural design
16.6 What we have learned
17. Design classes.
17.1 Chapter roadmap
17.2 UP activity: Design a class
17.3 What are design classes?
17.4 Anatomy of a design class
17.5 Well-formed design classes
17.8 Nested classes
17.9 What we have learned
18. Refining analysis relationships.
18.1 Chapter roadmap
18.2 Design relationships
18.3 Aggregation and composition
18.4 Aggregation semantics
18.5 Composition semantics
18.6 How to refine analysis relationships
18.7 One-to-one associations
18.8 Many-to-one associations
18.9 One-to-many associations
18.11 Reified relationships
18.12 Exploring composition with structured classes
18.13 What we have learned
19. Interfaces and components.
19.1 Chapter roadmap
19.2 UP activity: Design a subsystem
19.3 What is an interface?
19.4 Provided and required interfaces
19.5 Interface realization vs. inheritance
19.7 Interfaces and component-based development
19.8 What is a component?
19.9 Component stereotypes
19.11 Finding interfaces
19.12 Designing with interfaces
19.13 Advantages and disadvantages of interfaces
19.14 What we have learned
20. Use case realization-design.
20.1 Chapter roadmap
20.2 UP activity: Design a use case
20.3 Use case realization-design
20.4 Interaction diagrams in design
20.5 Modeling concurrency
20.6 Subsystem interactions
20.7 Timing diagrams
20.8 Example of use case realization-design
20.9 What we have learned
21. State machines.
21.1 Chapter roadmap
21.2 State machines
21.3 State machines and the UP
21.4 State machine diagrams
21.8 What we have learned
22. Advanced state machines.
22.1 Chapter roadmap
22.2 Composite states
22.3 Submachine states
22.4 Submachine communication
22.6 What we have learned
23. The implementation workflow.
23.1 Chapter roadmap
23.2 The implementation workflow
23.3 Implementation artifacts - metamodel
23.4 Implementation workflow detail
23.6 What we have learned
24.1 Chapter roadmap
24.2 UP activity: Architectural implementation
24.3 The deployment diagram
24.7 What we have learned
VI. SUPPLEMENTARY MATERIAL.
25. Introduction to OCL.
25.1 Chapter roadmap
25.2 What is the Object Constraint Language (OCL)?
25.3 Why use OCL?
25.4 OCL expression syntax
25.5 Package context and pathnames
25.6 The expression context
25.7 Types of OCL expressions
25.8 The expression body
25.9 OCL navigation
25.10 Types of OCL expression in detail
25.11 OCL in other types of diagrams
25.12 Advanced topics
25.13 What we have learned
Appendix 1: Example use case model.
Appendix 2: XML and use cases.
The aim of this book is to take you through the process of object-oriented (OO) analysis and design using the Unified Modeling Language (UML) and the Unified Process (UP).
UML provides the visual modeling language for OO modeling, and UP provides the software engineering process framework that tells you how to perform OO analysis and design.
There is a lot to UP, and in this book we present only those aspects directly pertinent to the work of the OO analyst/designer. For details on the other aspects of UP, you should refer to [Rumbaugh 1] and the other UP books in the bibliography.
In this book we show you enough UML and associated analysis and design techniques so that you can apply modeling effectively on a real project. According to Stephen J Mellor [Mellor 1], there are three approaches to UML modeling.
Our focus in this book is on UML as a blueprint. The techniques you learn will also apply to using UML as an executable. Having learned UML as a blueprint, you will naturally be able to use UML as a sketch should you need to. We have tried to make our presentation of UML and UP as straightforward and accessible as possible.Conventions
To help you navigate through the book we have provided each chapter with a roadmap in the form of a UML activity diagram. These diagrams indicate reading activities and the order in which sections might be read. We cover activity diagrams in detail in Chapter 14, but Figure 1 should be sufficient to let you understand the roadmaps.
Most of the diagrams in this book are UML diagrams. The annotations, in blue, are not part of UML syntax.
We have provided notes in the margin to highlight important information. We have used the UML note icon for this.Who should read this book
We can think of several possible readers for this book.
Clear View Training provides a four-day UML training course based on this book. This course is given throughout Europe by our partners, Zuehlke Engineering (www.zuhlke.com), and is available for licensing. If you are an academic institution using this book as your course book, you can use our training course for free. See www.clearviewtraining.com for more on commercial and academic licensing.How to read this book
So many books, so little time to read them all! With this in mind we have designed this book so that you can read it in several different ways (as well as cover to cover) according to your needs.
Choose Fast Track if you just want an overview of the whole book or a particular chapter. This is also the "management summary".
Fast Track is a quick and efficient way to read this book. You may be pleasantly surprised at how much you can pick up! Note that Fast Track works best if you can first formulate a clear idea of the information you want to obtain. For example "I want to understand how to do use case modeling."
If you need to know a particular part of UML or learn a particular technique, we have provided a detailed index and table of contents that should help you locate the information you need quickly and efficiently. The text is carefully cross-referenced to help you to do this.
There are two strategies for revision with this text.
If you have a few minutes to spare, you might pick up the book and open it at random. We have tried to ensure that there is something interesting on every page. Even if you already know UML quite well, you may still discover new things to learn.
Download the Index
file related to this title.