|Other Retailer||Price Checked Time||Their Price in AUD||Our Price|
|Amazon UK||2 days ago||126.01||$79.97||You save $46.04|
|Amazon US||2 days ago||114.84||$79.97||You save $34.87|
"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
Acknowledgments.Preface.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.10 Architecture 1.11 What we have learned2. 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 learnedII. REQUIREMENTS.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 learned4. 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 learned5. Advanced use case modeling. 5.1 Chapter roadmap 5.2 Actor generalization 5.3 Use case generalization 5.4 "include" 5.5 "extend" 5.6 When to use advanced features 5.7 Hints and tips for writing use cases 5.8 What we have learnedIII. ANALYSIS.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 learned7. 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.6 Scope 7.7 Object construction and destruction 7.8 What we have learned8. 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 learned9. Relationships. 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 learned10. Inheritance and polymorphism. 10.1 Chapter roadmap 10.2 Generalization 10.3 Class inheritance 10.4 Polymorphism 10.5 Advanced generalization 10.6 What we have learned11. 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 learned12. 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.5 Interactions 12.6 Lifelines 12.7 Messages 12.8 Interaction diagrams 12.9 Sequence diagrams 12.10 Combined fragments and operators 12.11 Communication diagrams 12.12 What we have learned13. Advanced use case realization. 13.1 Chapter roadmap 13.2 Interaction occurrences 13.3 Continuations 13.4 What we have learned14. Activity diagrams. 14.1 Chapter roadmap 14.2 What are activity diagrams? 14.3 Activity diagrams and the UP 14.4 Activities 14.5 Activity semantics 14.6 Activity partitions 14.7 Action nodes 14.8 Control nodes 14.9 Object nodes 14.10 Pins 14.11 What we have learned15. Advanced activity diagrams. 15.1 Chapter roadmap 15.2 Connectors 15.3 Interruptible activity regions 15.4 Exception handling 15.5 Expansion nodes 15.6 Sending signals and accepting events 15.7 Streaming 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 learnedIV. DESIGN.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 learned17. 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.6 Inheritance 17.7 Templates 17.8 Nested classes 17.9 What we have learned18. 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.10 Collections 18.11 Reified relationships 18.12 Exploring composition with structured classes 18.13 What we have learned19. 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.6 Ports 19.7 Interfaces and component-based development 19.8 What is a component? 19.9 Component stereotypes 19.10 Subsystems 19.11 Finding interfaces 19.12 Designing with interfaces 19.13 Advantages and disadvantages of interfaces 19.14 What we have learned20. 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 learned21. State machines. 21.1 Chapter roadmap 21.2 State machines 21.3 State machines and the UP 21.4 State machine diagrams 21.5 States 21.6 Transitions 21.7 Events 21.8 What we have learned22. Advanced state machines. 22.1 Chapter roadmap 22.2 Composite states 22.3 Submachine states 22.4 Submachine communication 22.5 History 22.6 What we have learnedV. IMPLEMENTATION.23. The implementation workflow. 23.1 Chapter roadmap 23.2 The implementation workflow 23.3 Implementation artifacts - metamodel 23.4 Implementation workflow detail 23.5 Artifacts 23.6 What we have learned24. Deployment. 24.1 Chapter roadmap 24.2 UP activity: Architectural implementation 24.3 The deployment diagram 24.4 Nodes 24.5 Artifacts 24.6 Deployment 24.7 What we have learnedVI. 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 learnedAppendix 1: Example use case model.Appendix 2: XML and use cases.Bibliography.Index.
"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 SoftwareThis 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 providesChapter roadmaps, detailed diagrams, and margin notes allowing you to focus on your needsOutline summaries for each chapter, making it ideal for revision, and a comprehensive index that can be used as a referenceNew to this edition:Completely revised and updated for UML 2 syntaxEasy to understand explanations of the new UML 2 semanticsMore real-world examplesA new section on the Object Constraint Language (OCL)Introductory material on the OMG's Model Driven Architecture (MDA)The accompanying website providesA complete example of a simple e-commerce systemOpen source tools for requirements engineering and use case modelingIndustrial-strength UML course materials based on the book
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.