Cover image for UML 2 and the unified process : practical object-oriented analysis and design
Title:
UML 2 and the unified process : practical object-oriented analysis and design
Personal Author:
Edition:
2nd ed.
Publication Information:
Upper Saddle River, NJ : Addison-Wesley, 2005
ISBN:
9780321321275
Added Author:

Available:*

Library
Item Barcode
Call Number
Material Type
Item Category 1
Status
Searching...
30000010191268 QA76.9.O35 A74 2005 Open Access Book Book
Searching...

On Order

Summary

Summary

This 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 Chapter roadmaps, detailed diagrams, and margin notes allowing you to focus on your needs Outline summaries for each chapter, making it ideal for revision, and a comprehensive index that can be used as a reference


Author Notes

Jim Arlow has been programming and designing object-oriented software systems since 1990. He has created object models for blue chip companies such as British Airways and M&G. He is a respected OO consultant in Europe and has written and delivered many training courses on object technology and Java. Jim is a regular speaker at conferences such as Object World, and has been an invited speaker at University College London, City University, and the British Computer Society.

Ila Neustadt has worked in IT for British Airways for more than twenty years and has experience of all parts within the IT development life cycle. She worked in the strategy department modeling the architecture process and developing architecture training, and acted as program head for the graduate business analyst program. Ila now coordinates skills development for BAs IT staff.




Excerpts

Excerpts

About this book 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. UML as a sketch - this is an informal approach to UML where diagrams are sketched out to help visualize a software system. It's a bit like sketching an idea for something on the back of a napkin. The sketches have little value beyond their initial use, are not maintained, and are finally discarded. You typically use whiteboards or drawing tools such as Visio and PowerPoint (www.microsoft.com) to create the informal sketches. UML as a blueprint - this is a more formal and precise approach whereby UML is used to specify a software system in detail. This is like a set of architect's plans or a blueprint for a machine. The UML model is actively maintained and becomes an important deliverable of the project. This approach demands the use of a real modeling tool such as Rational Rose (www.rational.com) or MagicDraw UML (www.magicdraw.com). UML as executable - using Model Driven Architecture (MDA), UML models may be used as a programming language. You add enough detail to UML models so that the system can be compiled from the model. This is the most formal and precise use of UML, and, in our view, it is the future of software development. In this approach, you need an MDA-enabled UML tool such as ArcStyler (www.arcstyler.com). MDA is beyond the scope of this book, although we discuss it briefly in Section 1.4. 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. You are an analyst/designer who needs to learn how to perform OO analysis and design. You are an analyst/designer who needs to learn how to perform OO analysis and design within the framework of the Unified Process. You are a student taking a UML course at a university. You are a software engineer who needs a UML reference. You are a software engineer taking a UML training course, and this is your course 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. Fast track Choose Fast Track if you just want an overview of the whole book or a particular chapter. This is also the "management summary". Choose a chapter. Read the chapter roadmap so that you know where you're going. Go through the chapter looking at the figures and reading the margin notes. Read the "What we have learned" section. Go back to any section that takes your interest and read it. 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." Reference 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. Revision There are two strategies for revision with this text. If you need to refresh your knowledge of UML as quickly and efficiently as possible, read the outline summaries of each chapter in the "What we have learned" section. When you don't understand something, go back and read the appropriate section. If you have more time, you can also browse through each chapter studying the diagrams and reading the margin notes. Dipping 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. 0321321278P06172005 Excerpted from UML 2 and the Unified Process: Practical Object-Oriented Analysis and Design by Jim Arlow, Ila Neustadt All rights reserved by the original copyright owners. Excerpts are provided for display purposes only and may not be reproduced, reprinted or distributed without the written permission of the publisher.

Table of Contents

Acknowledgmentsp. xvii
Prefacep. xix
Part 1 Introducing UML and UPp. 1
1 What is UML?p. 3
1.1 Chapter roadmapp. 3
1.2 What is UML?p. 5
1.3 The birth of UMLp. 5
1.4 MDA - the future of UMLp. 7
1.5 Why "unified"?p. 9
1.6 Objects and UMLp. 10
1.7 UML structurep. 10
1.8 UML building blocksp. 11
1.9 UML common mechanismsp. 15
1.10 Architecturep. 23
1.11 What we have learnedp. 24
2 What is the Unified Process?p. 27
2.1 Chapter roadmapp. 27
2.2 What is UP?p. 28
2.3 The birth of UPp. 29
2.4 UP and the Rational Unified Processp. 32
2.5 Instantiating UP for your projectp. 34
2.6 UP axiomsp. 34
2.7 UP is an iterative and incremental processp. 35
2.8 UP structurep. 37
2.9 UP phasesp. 39
2.10 What we have learnedp. 44
Part 2 Requirementsp. 47
3 The requirements workflowp. 49
3.1 Chapter roadmapp. 49
3.2 The requirements workflowp. 51
3.3 Software requirements - metamodelp. 52
3.4 Requirements workflow detailp. 53
3.5 The importance of requirementsp. 55
3.6 Defining requirementsp. 55
3.7 Finding requirementsp. 61
3.8 What we have learnedp. 65
4 Use case modelingp. 67
4.1 Chapter readmapp. 67
4.2 Use case modelingp. 69
4.3 UP activity: Find actors and use casesp. 69
4.4 UP activity: Detail a use casep. 77
4.5 Use case specificationp. 78
4.6 Requirements tracingp. 90
4.7 When to apply use case modelingp. 91
4.8 What we have learnedp. 92
5 Advanced use case modelingp. 95
5.1 Chapter roadmapp. 95
5.2 Actor generalizationp. 97
5.3 Use case generalizationp. 99
5.4 [double left angle bracket]include[double right angle bracket]p. 102
5.5 [double left angle bracket]extend[double right angle bracket]p. 105
5.6 When to use advanced featuresp. 110
5.7 Hints and tips for writing use casesp. 111
5.8 What we have learnedp. 113
Part 3 Analysisp. 117
6 The analysis workflowp. 119
6.1 Chapter roadmapp. 119
6.2 The analysis workflowp. 120
6.3 Analysis artifacts - metamodelp. 121
6.4 Analysis workflow detailp. 122
6.5 Analysis model - rules of thumbp. 122
6.6 What we have learnedp. 124
7 Objects and classesp. 125
7.1 Chapter roadmapp. 125
7.2 What are objects?p. 127
7.3 UML object notationp. 131
7.4 What are classes?p. 132
7.5 UML class notationp. 136
7.6 Scopep. 147
7.7 Object construction and destructionp. 148
7.8 What we have learnedp. 151
8 Finding analysis classesp. 155
8.1 Chapter roadmapp. 155
8.2 UP activity: Analyze a use casep. 157
8.3 What are analysis classes?p. 158
8.4 Finding classesp. 163
8.5 Creating a first-cut analysis modelp. 171
8.6 What we have learnedp. 172
9 Relationshipsp. 175
9.1 Chapter roadmapp. 175
9.2 What is a relationship?p. 177
9.3 What is a link?p. 177
9.4 What is an association?p. 180
9.5 What is a dependency?p. 195
9.6 What we have learnedp. 201
10 Inheritance and polymorphismp. 205
10.1 Chapter roadmapp. 205
10.2 Generalizationp. 206
10.3 Class inheritancep. 208
10.4 Polymorphismp. 211
10.5 Advanced generalizationp. 215
10.6 What we have learnedp. 221
11 Analysis packagesp. 223
11.1 Chapter roadmapp. 223
11.2 What is a package?p. 224
11.3 Packages and namespacesp. 226
11.4 Nested packagesp. 227
11.5 Package dependenciesp. 228
11.6 Package generalizationp. 231
11.7 Architectural analysisp. 231
11.8 What we have learnedp. 235
12 Use case realizationp. 239
12.1 Chapter roadmapp. 239
12.2 UP activity: Analyze a use casep. 241
12.3 What are use case realizations?p. 242
12.4 Use case realization - elementsp. 243
12.5 Interactionsp. 244
12.6 Lifelinesp. 244
12.7 Messagesp. 246
12.8 Interaction diagramsp. 248
12.9 Sequence diagramsp. 249
12.10 Combined fragments and operatorsp. 256
12.11 Communication diagramsp. 264
12.12 What we have learnedp. 268
13 Advanced use case realizationp. 273
13.1 Chapter roadmapp. 273
13.2 Interaction occurrencesp. 274
13.3 Continuationsp. 279
13.4 What we have learnedp. 281
14 Activity diagramsp. 283
14.1 Chapter roadmapp. 283
14.2 What are activity diagrams?p. 284
14.3 Activity diagrams and the UPp. 285
14.4 Activitiesp. 286
14.5 Activity semanticsp. 288
14.6 Activity partitionsp. 290
14.7 Action nodesp. 293
14.8 Control nodesp. 297
14.9 Object nodesp. 301
14.10 Pinsp. 305
14.11 What we have learnedp. 307
15 Advanced activity diagramsp. 309
15.1 Chapter roadmapp. 309
15.2 Connectorsp. 311
15.3 Interruptible activity regionsp. 311
15.4 Exception handlingp. 312
15.5 Expansion nodesp. 313
15.6 Sending signals and accepting eventsp. 314
15.7 Streamingp. 317
15.8 Advanced object flow featuresp. 318
15.9 Multicast and multireceivep. 320
15.10 Parameter setsp. 321
15.11 [double left angle bracket]centralBuffer[double right angle bracket] nodep. 322
15.12 Interaction overview diagramsp. 323
15.13 What we have learnedp. 325
Part 4 Designp. 329
16 The design workflowp. 331
16.1 Chapter roadmapp. 331
16.2 The design workflowp. 332
16.3 Design artifacts - metamodelp. 333
16.4 Design workflow detailp. 337
16.5 UP activity: Architectural designp. 338
16.6 What we have learnedp. 339
17 Design classesp. 341
17.1 Chapter roadmapp. 341
17.2 UP activity: Design a classp. 342
17.3 What are design classes?p. 344
17.4 Anatomy of a design classp. 345
17.5 Well-formed design classesp. 347
17.6 Inheritancep. 350
17.7 Templatesp. 354
17.8 Nested classesp. 357
17.9 What we have learnedp. 358
18 Refining analysis relationshipsp. 361
18.1 Chapter roadmapp. 361
18.2 Design relationshipsp. 363
18.3 Aggregation and compositionp. 363
18.4 Aggregation semanticsp. 364
18.5 Composition semanticsp. 367
18.6 How to refine analysis relationshipsp. 368
18.7 One-to-one associationsp. 369
18.8 Many-to-one associationsp. 370
18.9 One-to-many associationsp. 371
18.10 Collectionsp. 371
18.11 Reified relationshipsp. 375
18.12 Exploring composition with structured classesp. 378
18.13 What we have learnedp. 382
19 Interfaces and componentsp. 387
19.1 Chapter roadmapp. 387
19.2 UP activity: Design a subsystemp. 389
19.3 What is an interface?p. 389
19.4 Provided and required interfacesp. 391
19.5 Interface realization vs. inheritancep. 394
19.6 Portsp. 398
19.7 Interfaces and component-based developmentp. 399
19.8 What is a component?p. 399
19.9 Component stereotypesp. 402
19.10 Subsystemsp. 403
19.11 Finding interfacesp. 404
19.12 Designing with interfacesp. 404
19.13 Advantages and disadvantages of interfacesp. 408
19.14 What we have learnedp. 408
20 Use case realization-designp. 413
20.1 Chapter roadmapp. 413
20.2 UP activity: Design a use casep. 415
20.3 Use case realization-designp. 416
20.4 Interaction diagrams in designp. 417
20.5 Modeling concurrencyp. 419
20.6 Subsystem interactionsp. 426
20.7 Timing diagramsp. 427
20.8 Example of use case realization-designp. 430
20.9 What we have learnedp. 436
21 State machinesp. 437
21.1 Chapter roadmapp. 437
21.2 State machinesp. 439
21.3 State machines and the UPp. 441
21.4 State machine diagramsp. 442
21.5 Statesp. 443
21.6 Transitionsp. 445
21.7 Eventsp. 448
21.8 What we have learnedp. 453
22 Advanced state machinesp. 457
22.1 Chapter roadmapp. 457
22.2 Composite statesp. 458
22.3 Submachine statesp. 465
22.4 Submachine communicationp. 466
22.5 Historyp. 468
22.6 What we have learnedp. 470
Part 5 Implementationp. 473
23 The implementation workflowp. 475
23.1 Chapter roadmapp. 475
23.2 The implementation workflowp. 476
23.3 Implementation artifacts - metamodelp. 477
23.4 Implementation workflow detailp. 478
23.5 Artifactsp. 479
23.6 What we have learnedp. 480
24 Deploymentp. 481
24.1 Chapter roadmapp. 481
24.2 UP activity: Architectural implementationp. 482
24.3 The deployment diagramp. 483
24.4 Nodesp. 484
24.5 Artifactsp. 486
24.6 Deploymentp. 490
24.7 What we have learnedp. 491
Part 6 Supplementary materialp. 493
25 Introduction to OCLp. 495
25.1 Chapter roadmapp. 495
25.2 What is the Object Constraint Language (OCL)?p. 497
25.3 Why use OCL?p. 497
25.4 OCL expression syntaxp. 498
25.5 Package context and pathnamesp. 500
25.6 The expression contextp. 501
25.7 Types of OCL expressionsp. 502
25.8 The expression bodyp. 504
25.9 OCL navigationp. 522
25.10 Types of OCL expression in detailp. 526
25.11 OCL in other types of diagramsp. 535
25.12 Advanced topicsp. 540
25.13 What we have learnedp. 546
Appendix 1 Example use case modelp. 551
Appendix 2 XML and use casesp. 559
Bibliographyp. 567
Indexp. 569