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
Acknowledgments | p. xvii |
Preface | p. xix |
Part 1 Introducing UML and UP | p. 1 |
1 What is UML? | p. 3 |
1.1 Chapter roadmap | p. 3 |
1.2 What is UML? | p. 5 |
1.3 The birth of UML | p. 5 |
1.4 MDA - the future of UML | p. 7 |
1.5 Why "unified"? | p. 9 |
1.6 Objects and UML | p. 10 |
1.7 UML structure | p. 10 |
1.8 UML building blocks | p. 11 |
1.9 UML common mechanisms | p. 15 |
1.10 Architecture | p. 23 |
1.11 What we have learned | p. 24 |
2 What is the Unified Process? | p. 27 |
2.1 Chapter roadmap | p. 27 |
2.2 What is UP? | p. 28 |
2.3 The birth of UP | p. 29 |
2.4 UP and the Rational Unified Process | p. 32 |
2.5 Instantiating UP for your project | p. 34 |
2.6 UP axioms | p. 34 |
2.7 UP is an iterative and incremental process | p. 35 |
2.8 UP structure | p. 37 |
2.9 UP phases | p. 39 |
2.10 What we have learned | p. 44 |
Part 2 Requirements | p. 47 |
3 The requirements workflow | p. 49 |
3.1 Chapter roadmap | p. 49 |
3.2 The requirements workflow | p. 51 |
3.3 Software requirements - metamodel | p. 52 |
3.4 Requirements workflow detail | p. 53 |
3.5 The importance of requirements | p. 55 |
3.6 Defining requirements | p. 55 |
3.7 Finding requirements | p. 61 |
3.8 What we have learned | p. 65 |
4 Use case modeling | p. 67 |
4.1 Chapter readmap | p. 67 |
4.2 Use case modeling | p. 69 |
4.3 UP activity: Find actors and use cases | p. 69 |
4.4 UP activity: Detail a use case | p. 77 |
4.5 Use case specification | p. 78 |
4.6 Requirements tracing | p. 90 |
4.7 When to apply use case modeling | p. 91 |
4.8 What we have learned | p. 92 |
5 Advanced use case modeling | p. 95 |
5.1 Chapter roadmap | p. 95 |
5.2 Actor generalization | p. 97 |
5.3 Use case generalization | p. 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 features | p. 110 |
5.7 Hints and tips for writing use cases | p. 111 |
5.8 What we have learned | p. 113 |
Part 3 Analysis | p. 117 |
6 The analysis workflow | p. 119 |
6.1 Chapter roadmap | p. 119 |
6.2 The analysis workflow | p. 120 |
6.3 Analysis artifacts - metamodel | p. 121 |
6.4 Analysis workflow detail | p. 122 |
6.5 Analysis model - rules of thumb | p. 122 |
6.6 What we have learned | p. 124 |
7 Objects and classes | p. 125 |
7.1 Chapter roadmap | p. 125 |
7.2 What are objects? | p. 127 |
7.3 UML object notation | p. 131 |
7.4 What are classes? | p. 132 |
7.5 UML class notation | p. 136 |
7.6 Scope | p. 147 |
7.7 Object construction and destruction | p. 148 |
7.8 What we have learned | p. 151 |
8 Finding analysis classes | p. 155 |
8.1 Chapter roadmap | p. 155 |
8.2 UP activity: Analyze a use case | p. 157 |
8.3 What are analysis classes? | p. 158 |
8.4 Finding classes | p. 163 |
8.5 Creating a first-cut analysis model | p. 171 |
8.6 What we have learned | p. 172 |
9 Relationships | p. 175 |
9.1 Chapter roadmap | p. 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 learned | p. 201 |
10 Inheritance and polymorphism | p. 205 |
10.1 Chapter roadmap | p. 205 |
10.2 Generalization | p. 206 |
10.3 Class inheritance | p. 208 |
10.4 Polymorphism | p. 211 |
10.5 Advanced generalization | p. 215 |
10.6 What we have learned | p. 221 |
11 Analysis packages | p. 223 |
11.1 Chapter roadmap | p. 223 |
11.2 What is a package? | p. 224 |
11.3 Packages and namespaces | p. 226 |
11.4 Nested packages | p. 227 |
11.5 Package dependencies | p. 228 |
11.6 Package generalization | p. 231 |
11.7 Architectural analysis | p. 231 |
11.8 What we have learned | p. 235 |
12 Use case realization | p. 239 |
12.1 Chapter roadmap | p. 239 |
12.2 UP activity: Analyze a use case | p. 241 |
12.3 What are use case realizations? | p. 242 |
12.4 Use case realization - elements | p. 243 |
12.5 Interactions | p. 244 |
12.6 Lifelines | p. 244 |
12.7 Messages | p. 246 |
12.8 Interaction diagrams | p. 248 |
12.9 Sequence diagrams | p. 249 |
12.10 Combined fragments and operators | p. 256 |
12.11 Communication diagrams | p. 264 |
12.12 What we have learned | p. 268 |
13 Advanced use case realization | p. 273 |
13.1 Chapter roadmap | p. 273 |
13.2 Interaction occurrences | p. 274 |
13.3 Continuations | p. 279 |
13.4 What we have learned | p. 281 |
14 Activity diagrams | p. 283 |
14.1 Chapter roadmap | p. 283 |
14.2 What are activity diagrams? | p. 284 |
14.3 Activity diagrams and the UP | p. 285 |
14.4 Activities | p. 286 |
14.5 Activity semantics | p. 288 |
14.6 Activity partitions | p. 290 |
14.7 Action nodes | p. 293 |
14.8 Control nodes | p. 297 |
14.9 Object nodes | p. 301 |
14.10 Pins | p. 305 |
14.11 What we have learned | p. 307 |
15 Advanced activity diagrams | p. 309 |
15.1 Chapter roadmap | p. 309 |
15.2 Connectors | p. 311 |
15.3 Interruptible activity regions | p. 311 |
15.4 Exception handling | p. 312 |
15.5 Expansion nodes | p. 313 |
15.6 Sending signals and accepting events | p. 314 |
15.7 Streaming | p. 317 |
15.8 Advanced object flow features | p. 318 |
15.9 Multicast and multireceive | p. 320 |
15.10 Parameter sets | p. 321 |
15.11 [double left angle bracket]centralBuffer[double right angle bracket] node | p. 322 |
15.12 Interaction overview diagrams | p. 323 |
15.13 What we have learned | p. 325 |
Part 4 Design | p. 329 |
16 The design workflow | p. 331 |
16.1 Chapter roadmap | p. 331 |
16.2 The design workflow | p. 332 |
16.3 Design artifacts - metamodel | p. 333 |
16.4 Design workflow detail | p. 337 |
16.5 UP activity: Architectural design | p. 338 |
16.6 What we have learned | p. 339 |
17 Design classes | p. 341 |
17.1 Chapter roadmap | p. 341 |
17.2 UP activity: Design a class | p. 342 |
17.3 What are design classes? | p. 344 |
17.4 Anatomy of a design class | p. 345 |
17.5 Well-formed design classes | p. 347 |
17.6 Inheritance | p. 350 |
17.7 Templates | p. 354 |
17.8 Nested classes | p. 357 |
17.9 What we have learned | p. 358 |
18 Refining analysis relationships | p. 361 |
18.1 Chapter roadmap | p. 361 |
18.2 Design relationships | p. 363 |
18.3 Aggregation and composition | p. 363 |
18.4 Aggregation semantics | p. 364 |
18.5 Composition semantics | p. 367 |
18.6 How to refine analysis relationships | p. 368 |
18.7 One-to-one associations | p. 369 |
18.8 Many-to-one associations | p. 370 |
18.9 One-to-many associations | p. 371 |
18.10 Collections | p. 371 |
18.11 Reified relationships | p. 375 |
18.12 Exploring composition with structured classes | p. 378 |
18.13 What we have learned | p. 382 |
19 Interfaces and components | p. 387 |
19.1 Chapter roadmap | p. 387 |
19.2 UP activity: Design a subsystem | p. 389 |
19.3 What is an interface? | p. 389 |
19.4 Provided and required interfaces | p. 391 |
19.5 Interface realization vs. inheritance | p. 394 |
19.6 Ports | p. 398 |
19.7 Interfaces and component-based development | p. 399 |
19.8 What is a component? | p. 399 |
19.9 Component stereotypes | p. 402 |
19.10 Subsystems | p. 403 |
19.11 Finding interfaces | p. 404 |
19.12 Designing with interfaces | p. 404 |
19.13 Advantages and disadvantages of interfaces | p. 408 |
19.14 What we have learned | p. 408 |
20 Use case realization-design | p. 413 |
20.1 Chapter roadmap | p. 413 |
20.2 UP activity: Design a use case | p. 415 |
20.3 Use case realization-design | p. 416 |
20.4 Interaction diagrams in design | p. 417 |
20.5 Modeling concurrency | p. 419 |
20.6 Subsystem interactions | p. 426 |
20.7 Timing diagrams | p. 427 |
20.8 Example of use case realization-design | p. 430 |
20.9 What we have learned | p. 436 |
21 State machines | p. 437 |
21.1 Chapter roadmap | p. 437 |
21.2 State machines | p. 439 |
21.3 State machines and the UP | p. 441 |
21.4 State machine diagrams | p. 442 |
21.5 States | p. 443 |
21.6 Transitions | p. 445 |
21.7 Events | p. 448 |
21.8 What we have learned | p. 453 |
22 Advanced state machines | p. 457 |
22.1 Chapter roadmap | p. 457 |
22.2 Composite states | p. 458 |
22.3 Submachine states | p. 465 |
22.4 Submachine communication | p. 466 |
22.5 History | p. 468 |
22.6 What we have learned | p. 470 |
Part 5 Implementation | p. 473 |
23 The implementation workflow | p. 475 |
23.1 Chapter roadmap | p. 475 |
23.2 The implementation workflow | p. 476 |
23.3 Implementation artifacts - metamodel | p. 477 |
23.4 Implementation workflow detail | p. 478 |
23.5 Artifacts | p. 479 |
23.6 What we have learned | p. 480 |
24 Deployment | p. 481 |
24.1 Chapter roadmap | p. 481 |
24.2 UP activity: Architectural implementation | p. 482 |
24.3 The deployment diagram | p. 483 |
24.4 Nodes | p. 484 |
24.5 Artifacts | p. 486 |
24.6 Deployment | p. 490 |
24.7 What we have learned | p. 491 |
Part 6 Supplementary material | p. 493 |
25 Introduction to OCL | p. 495 |
25.1 Chapter roadmap | p. 495 |
25.2 What is the Object Constraint Language (OCL)? | p. 497 |
25.3 Why use OCL? | p. 497 |
25.4 OCL expression syntax | p. 498 |
25.5 Package context and pathnames | p. 500 |
25.6 The expression context | p. 501 |
25.7 Types of OCL expressions | p. 502 |
25.8 The expression body | p. 504 |
25.9 OCL navigation | p. 522 |
25.10 Types of OCL expression in detail | p. 526 |
25.11 OCL in other types of diagrams | p. 535 |
25.12 Advanced topics | p. 540 |
25.13 What we have learned | p. 546 |
Appendix 1 Example use case model | p. 551 |
Appendix 2 XML and use cases | p. 559 |
Bibliography | p. 567 |
Index | p. 569 |