
Guide to the Unified Process featuring UML, Java and Design Patterns
By: John Hunt
Hardcover | 2 September 2003 | Edition Number 2
At a Glance
448 Pages
Revised
23.5 x 18.42 x 2.54
Hardcover
$169.00
or 4 interest-free payments of $42.25 with
orShips in 5 to 7 business days
| The Unified Process | |
| Introduction | p. 3 |
| Introduction | p. 3 |
| Why UML and the Unified Process? | p. 5 |
| Why This Book? | p. 6 |
| Where to Get More Information | p. 6 |
| Where to Go Online | p. 7 |
| Object-Oriented Analysis and Design | p. 9 |
| Introduction | p. 9 |
| Object-Oriented Design Methods | p. 9 |
| Object-Oriented Analysis | p. 10 |
| Class Responsibility Collaborator (CRC) | p. 10 |
| The Booch Method | p. 12 |
| The Steps in the Booch Method | p. 12 |
| Strengths and Weaknesses | p. 13 |
| The Object Modeling Technique | p. 13 |
| The Analysis Phase | p. 14 |
| The Design Phase | p. 14 |
| The Implementation Phase | p. 15 |
| Strengths and Weaknesses | p. 15 |
| The Objectory Method | p. 15 |
| The Requirements Phase | p. 15 |
| The Analysis Phase | p. 16 |
| The Construction Phase | p. 16 |
| Strengths and Weaknesses | p. 16 |
| The Fusion Method | p. 16 |
| The Unified Modeling Language | p. 17 |
| Summary | p. 18 |
| References | p. 18 |
| An Introduction to the UML and the Unified Process | p. 21 |
| Introduction | p. 21 |
| Unified Modeling Language | p. 21 |
| History of the UML | p. 22 |
| Introduction to the UML | p. 24 |
| Models and Diagrams | p. 25 |
| Analysis of the UML | p. 26 |
| The Unified Process | p. 26 |
| Overview of the Unified Process | p. 27 |
| Life Cycle Phases | p. 31 |
| Phases, Iterations and Disciplines | p. 32 |
| Disciplines and Activities | p. 35 |
| Applying the Unified Process | p. 35 |
| The Rational Unified Process | p. 36 |
| Summary | p. 37 |
| References | p. 37 |
| Online References | p. 37 |
| Software Architecture and Object-Oriented Design | p. 39 |
| Software Architecture - the Very Idea | p. 39 |
| Why Have an Architecture? | p. 39 |
| Why We Need an Architecture | p. 41 |
| Architecture Myths | p. 41 |
| Architecture Defined | p. 44 |
| Characteristics of a Good Architecture | p. 45 |
| Layering the Architecture | p. 46 |
| Use Cases and Architecture | p. 46 |
| So What Is an Architecture? | p. 47 |
| Software Patterns | p. 49 |
| What Are Design Patterns? | p. 49 |
| What They Are Not | p. 49 |
| Architectural Patterns | p. 50 |
| Constructing the Architecture | p. 50 |
| Find Architecturally Significant Use Cases | p. 51 |
| Architecturally Significant Use Cases | p. 51 |
| Use Case Description | p. 51 |
| Identify Key Classes | p. 51 |
| Breaking the System into Subsystems | p. 52 |
| Breaking the System into Subsystems | p. 53 |
| Identifying Subsystems | p. 54 |
| Assessing the Subsystems | p. 54 |
| Identify Major System Interfaces | p. 55 |
| Layering the Subsystems | p. 55 |
| Identifying Concurrency and Active Classes | p. 55 |
| Allocating Subsystems to Processors and Tasks | p. 57 |
| Deployment Diagrams | p. 57 |
| Managing Data Stores | p. 58 |
| Handling Access to Global Resources | p. 59 |
| Additional Architectural Concerns | p. 59 |
| Choosing the Implementation of Control in Software | p. 59 |
| Identify Generic Design Mechanisms | p. 60 |
| Handling Boundary Conditions | p. 60 |
| Setting Trade-offs Between Competing Resources | p. 60 |
| Specifying Default Policies for the Object Design | p. 61 |
| Plan Incremental Build of Software | p. 61 |
| The Online ATM Architecture Design | p. 61 |
| Identifying Architecturally Significant Use Cases | p. 62 |
| Organizing the System into Subsystems | p. 62 |
| Identify Key Classes | p. 62 |
| Identifying Concurrency | p. 62 |
| Allocating Subsystems to Processors | p. 62 |
| Managing Data Stores | p. 62 |
| Handling Access to Global Resources | p. 64 |
| Choosing the Implementation of Control | p. 64 |
| Boundary Conditions | p. 64 |
| Default Policies for the Object Design | p. 64 |
| Implement a Skeleton Architecture | p. 65 |
| References | p. 65 |
| Requirements Discipline: Use Case Analysis | p. 67 |
| Introduction | p. 67 |
| Requirements Discipline | p. 67 |
| Use Case Analysis | p. 68 |
| The Use Case Model | p. 68 |
| Use Case Diagrams | p. 69 |
| Actors | p. 70 |
| Steps in Finding Actors | p. 72 |
| Use Cases | p. 72 |
| Identifying Use Cases | p. 74 |
| Identifying Use Case Events | p. 75 |
| Refining Use Case Models | p. 75 |
| Additional Documents | p. 76 |
| Interface Descriptions | p. 76 |
| Online ATM Use Case Analysis | p. 76 |
| Deposit Use Case | p. 78 |
| Withdrawal Use Case | p. 78 |
| Interface Descriptions | p. 78 |
| Structuring the Use Case Model | p. 81 |
| Are Use Case Diagrams Useful? | p. 82 |
| Further Reading | p. 85 |
| References | p. 85 |
| The Analysis Discipline: Finding the Entities | p. 87 |
| Introduction | p. 87 |
| Analysis Discipline Activities | p. 89 |
| The Analysis Model | p. 89 |
| Why Have an Analysis Model? | p. 90 |
| Analysis Model Classes | p. 90 |
| Use Case Realizations | p. 92 |
| Constructing the Analysis Model | p. 94 |
| Generating Analysis Classes | p. 94 |
| Representing Classes | p. 94 |
| Representing Objects | p. 95 |
| Generating Objects and Classes | p. 96 |
| Identifying Classes for the Online ATM System | p. 98 |
| Rationalizing Classes | p. 98 |
| Generating Use Case Realizations | p. 100 |
| Identifying Attributes | p. 100 |
| Identifying Attributes of Objects | p. 101 |
| Identifying Attributes in the Online ATM System | p. 102 |
| Preparing a Data Dictionary | p. 103 |
| The Online ATM Data Dictionary | p. 103 |
| Identifying Associations | p. 103 |
| Representing Associations | p. 103 |
| Identifying Associations Between Objects | p. 104 |
| Identifying Associations in the Online ATM System | p. 105 |
| Identifying Inheritance | p. 106 |
| Representing Inheritance | p. 106 |
| Organizing and Simplifying Analysis Classes Using Inheritance | p. 108 |
| Identifying Inheritance in the Online ATM System | p. 109 |
| Grouping Analysis Classes into Packages | p. 109 |
| Identifying Analysis Packages | p. 110 |
| Representing Packages | p. 111 |
| Analyzing Analysis Packages | p. 112 |
| Iterating and Refining the Model | p. 112 |
| Identify Common Special Requirements | p. 113 |
| The Design Discipline: System and Class Design | p. 115 |
| Introduction | p. 115 |
| Design Discipline Activities | p. 115 |
| Class Design Stage | p. 117 |
| The Design Model | p. 117 |
| Design Classes | p. 119 |
| Design Class Notation | p. 119 |
| Identifying and Refining Design Classes | p. 123 |
| Identifying Classes | p. 123 |
| Refining the Set of Classes | p. 124 |
| Identifying Attributes for Design Classes | p. 125 |
| Refining Attributes for Design Classes | p. 125 |
| Representing Operations | p. 126 |
| Describing Operations | p. 126 |
| Identifying Operations | p. 127 |
| Refining Operations | p. 129 |
| Identifying Operations for the Online ATM System | p. 129 |
| Operations Implied by Events | p. 129 |
| Operations Implied by State Actions and Activities | p. 129 |
| Application or Domain Operations | p. 129 |
| Simplifying Operations | p. 130 |
| The OBA Operations | p. 130 |
| Analyzing Use Cases | p. 131 |
| Generating Design Classes from Use Cases | p. 131 |
| Design Use Case Realizations | p. 132 |
| Identifying Dynamic Behaviour | p. 132 |
| Design Collaboration Diagrams | p. 133 |
| Sequence Diagrams | p. 135 |
| Preparation of Sequence Diagrams | p. 135 |
| Dealing with Complexity in Sequence Diagrams | p. 137 |
| Generating a Sequence Diagram | p. 137 |
| Sequence Diagrams for the Online Bank Account System | p. 138 |
| Describing an Object's Behaviour | p. 139 |
| Statechart Diagrams | p. 139 |
| Start Points | p. 139 |
| Events | p. 140 |
| A Set of Transitions | p. 140 |
| A Set of State Variables | p. 141 |
| A Set of States | p. 141 |
| A Set of Exit Points | p. 142 |
| Building a Statechart Diagram | p. 142 |
| Associations | p. 146 |
| Representing Associations | p. 146 |
| Identifying Associations | p. 148 |
| Refining Associations | p. 149 |
| Identifying Interfaces | p. 150 |
| Identifying Inheritance | p. 151 |
| Remaining Steps | p. 151 |
| Optimizing the Design | p. 151 |
| Testing Access Paths | p. 151 |
| Implementing Control | p. 152 |
| Adjusting Class Structure | p. 152 |
| Designing Associations | p. 152 |
| Object Representation | p. 152 |
| Applying the Remaining Steps to OBA | p. 153 |
| Optimizing the Design | p. 153 |
| Implementing Control | p. 153 |
| Adjusting the Class Structure | p. 153 |
| Designing Associations | p. 153 |
| Determining Object Representation | p. 153 |
| Iterating and Refining the Model | p. 153 |
| References | p. 154 |
| Implementation Phase | p. 155 |
| Introduction | p. 155 |
| Implementation Discipline Artefacts | p. 155 |
| Implementation Discipline Activities | p. 156 |
| Implementing the Skeleton Architecture | p. 156 |
| Define the Implementation Model | p. 157 |
| Implement the System | p. 159 |
| Refining the Implementation Model | p. 160 |
| Integrate the Systems | p. 161 |
| The Test Discipline: How It Relates to Use Cases | p. 163 |
| Introduction | p. 163 |
| The Purpose of the Discipline | p. 163 |
| Aims of Discipline | p. 163 |
| Test Discipline Activities | p. 164 |
| Plan Tests | p. 164 |
| Design Tests | p. 164 |
| Implement Tests | p. 165 |
| Perform Integration Tests | p. 165 |
| Perform System Tests | p. 165 |
| Evaluate Tests | p. 166 |
| Summary | p. 166 |
| Reference | p. 166 |
| The Four Phases | p. 167 |
| Introduction | p. 167 |
| The Unified Process Structure | p. 167 |
| Relationship Between Phases and Iterations | p. 168 |
| The Four Phases | p. 168 |
| Effort Versus Phases | p. 171 |
| Phases and Iterations | p. 172 |
| Phases and Cycles | p. 173 |
| The JDSync Case Study | p. 175 |
| Introduction | p. 175 |
| Problem Statement | p. 175 |
| The Requirements Discipline: Use Case Analysis | p. 175 |
| Actors in JDSync | p. 176 |
| Use Cases | p. 177 |
| The Use Case Diagram | p. 180 |
| Example User Interfaces | p. 181 |
| The Analysis Discipline | p. 181 |
| Identifying the Analysis Classes | p. 182 |
| Generating the Collaboration Diagrams | p. 184 |
| The Design Discipline | p. 188 |
| Initial Identification of Classes | p. 188 |
| Sequence Diagrams | p. 190 |
| Identifying Attributes | p. 196 |
| Identifying Operations | p. 197 |
| Describing the Overall Behaviour of an Object | p. 199 |
| Identifying Associations and Inheritance | p. 200 |
| Identifying Interfaces | p. 201 |
| A Complete Design Model | p. 201 |
| The Implementation Workflow | p. 201 |
| Updating the Class Structure | p. 201 |
| Summary | p. 206 |
| Design Patterns | |
| Software Patterns | p. 209 |
| Introduction | p. 209 |
| The Motivation Behind Patterns | p. 210 |
| Documenting Patterns | p. 211 |
| When to Use Patterns | p. 212 |
| Strengths and Limitations of Design Patterns | p. 212 |
| An Example Pattern: Mediator | p. 213 |
| Summary | p. 218 |
| Further Reading | p. 218 |
| References | p. 218 |
| Patterns Catalogs | p. 221 |
| Introduction | p. 221 |
| GoF Patterns | p. 221 |
| Creational Patterns | p. 222 |
| Factory Method | p. 222 |
| Abstract Factory | p. 223 |
| Builder | p. 223 |
| Prototype | p. 223 |
| Singleton | p. 223 |
| Structural Patterns | p. 225 |
| Adapter | p. 225 |
| Bridge | p. 225 |
| Composite | p. 226 |
| Decorator | p. 226 |
| Façade | p. 226 |
| Flyweight | p. 227 |
| Proxy | p. 228 |
| Behavioural Patterns | p. 228 |
| Chain of Responsibility | p. 228 |
| Command | p. 229 |
| Interpreter | p. 229 |
| Iterator | p. 229 |
| Mediator | p. 229 |
| Memento | p. 231 |
| Observer | p. 231 |
| State | p. 231 |
| Strategy | p. 231 |
| Template Method | p. 232 |
| Visitor | p. 232 |
| Summary | p. 232 |
| References | p. 233 |
| Applying the Model-View-Controller Pattern | p. 235 |
| Introduction | p. 235 |
| What Is the Model-View-Controller Architecture? | p. 235 |
| What Java Facilities Support the MVC | p. 236 |
| The Delegation Event Model | p. 237 |
| The MVC in Java | p. 238 |
| A Simple Calculator Application | p. 240 |
| Swing Component Event Handling | p. 242 |
| Frames, Panels and Layout Managers | p. 243 |
| The Application Code | p. 243 |
| Discussion | p. 243 |
| References | p. 244 |
| Listings | p. 244 |
| The Hierarchical MVC | p. 253 |
| Introduction | p. 253 |
| Why Isn't This Enough? | p. 253 |
| Theh-MVC | p. 254 |
| The h-MVC Details | p. 254 |
| Layered Application | p. 254 |
| Initialization | p. 257 |
| Hierarchical Behaviour | p. 259 |
| The Advantages of the h-MVC | p. 260 |
| The Disadvantages of the h-MVC | p. 260 |
| Summary | p. 261 |
| The Visitor Framework | p. 263 |
| Background | p. 263 |
| The Visitor Pattern | p. 264 |
| The Visitor Framework | p. 266 |
| Using the Visitor Framework | p. 266 |
| A Simple Application | p. 269 |
| Summary | p. 271 |
| References | p. 271 |
| Listings | p. 272 |
| The EventManager | p. 281 |
| Introduction | p. 281 |
| The Use of Patterns | p. 281 |
| The Mediator Pattern | p. 283 |
| The Singleton Pattern | p. 283 |
| The Design of the EventManager | p. 283 |
| The EventManager | p. 284 |
| The ManagedEvent Class | p. 285 |
| The EventManagerListener Interface | p. 285 |
| Using the EventManager | p. 286 |
| The EventManager in a Graphical Client | p. 286 |
| Reference | p. 286 |
| Listings | p. 286 |
| J2EE Patterns | p. 293 |
| Introduction | p. 293 |
| What Are J2EE Design Patterns? | p. 293 |
| A Catalog of J2EE Patterns | p. 294 |
| The FrontController Pattern | p. 295 |
| Context | p. 295 |
| Problem | p. 295 |
| Forces | p. 295 |
| Solution | p. 296 |
| Strategies | p. 297 |
| Consequences | p. 297 |
| Related Patterns | p. 297 |
| The Request-Event-Dispatcher Pattern | p. 298 |
| Context | p. 298 |
| Problem | p. 298 |
| Forces | p. 298 |
| Solution | p. 298 |
| Strategies | p. 300 |
| Consequences | p. 302 |
| Related Patterns | p. 302 |
| J2EE-based Model-View-Controller | p. 303 |
| Context | p. 303 |
| Problem | p. 303 |
| Forces | p. 303 |
| Solution | p. 303 |
| Strategies | p. 305 |
| Consequences | p. 306 |
| Related Patterns | p. 306 |
| Summary | p. 307 |
| Further Reading | p. 307 |
| References | p. 307 |
| The Fault Tracker J2EE Case Study | p. 309 |
| Introduction | p. 309 |
| The Fault Tracker Application | p. 309 |
| Requests for Change | p. 310 |
| Problem Reporting | p. 311 |
| Using the Fault Tracker | p. 313 |
| The Design of the Fault Tracker | p. 317 |
| What Is the Architecture? | p. 317 |
| Summary and Conclusions | p. 324 |
| The Unified Process in the Real World | |
| Are UML Designs Language-Independent? | p. 329 |
| Introduction | p. 329 |
| OOD Is Language-Independent - Right? | p. 329 |
| Making UML Work for You | p. 330 |
| Questions to Consider | p. 331 |
| The Java Platform | p. 331 |
| Classes in the UML | p. 332 |
| Fields in the UML | p. 332 |
| Operations in the UML | p. 333 |
| Constructors | p. 333 |
| Packages in the UML | p. 334 |
| UML Interfaces | p. 336 |
| Templates | p. 336 |
| Associations | p. 337 |
| Multiplicity in the UML | p. 339 |
| Aggregation and Composition | p. 339 |
| Singleton Objects | p. 340 |
| Synchronous and Asynchronous Messages | p. 340 |
| From Code to the UML | p. 341 |
| Conclusions | p. 342 |
| Customizing the Unified Process for Short Time-Scale Projects | p. 343 |
| Introduction | p. 343 |
| Particular Problems of Small Projects | p. 344 |
| The Unified Process as a Framework | p. 345 |
| Experience of Application Domain | p. 346 |
| Experience with Technology | p. 346 |
| Understanding of Requirements | p. 347 |
| The Size of the Task | p. 348 |
| The Nature of the Task | p. 348 |
| Time/Budget/Resources | p. 349 |
| Management Support/Buy-in | p. 350 |
| Adapting the Unified Process for a Small Project | p. 351 |
| A Typical Short-Term Project | p. 351 |
| Short Time-Scale Project Approach | p. 351 |
| The Modified Unified Process | p. 352 |
| Summary | p. 354 |
| Reference | p. 354 |
| Augmenting the Unified Process with Additional Techniques | p. 355 |
| Introduction | p. 355 |
| The Unified Process as a Framework | p. 355 |
| Class Identification | p. 357 |
| CRC: Class-Responsibility-Collaboration | p. 358 |
| What Is CRC? | p. 359 |
| The Basic Idea | p. 359 |
| Identifying Classes | p. 360 |
| Identifying Responsibilities | p. 360 |
| Determining Collaborations | p. 360 |
| Summary | p. 361 |
| References | p. 361 |
| Inheritance Considered Harmful! | p. 363 |
| Introduction | p. 363 |
| Inheritance | p. 364 |
| What Is Inheritance? | p. 364 |
| Aims and Benefits of Inheritance | p. 365 |
| The Role of Inheritance | p. 366 |
| Drawbacks of Inheritance | p. 366 |
| Reduces Comprehensibility of Code | p. 366 |
| Makes Maintenance Harder | p. 369 |
| Makes Further Development Harder | p. 369 |
| Reduces Reliability of Code | p. 371 |
| May Reduce Reuse | p. 372 |
| The Semantically Fragile Base Class Problem | p. 372 |
| Access Modifier Effects on Reuse | p. 372 |
| Balancing Inheritance and Reuse | p. 374 |
| Categories of Extension | p. 374 |
| Implications for Inheritance | p. 375 |
| Compositional Reuse | p. 376 |
| Strengths of Compositional Reuse | p. 376 |
| Weaknesses of Compositional Reuse | p. 377 |
| Promoting Reuse in Object-Oriented Systems | p. 377 |
| Tool Support | p. 379 |
| Conclusions | p. 380 |
| References | p. 380 |
| Incremental Software | p. 383 |
| The Incremental Software Development Process | p. 383 |
| Incremental Software Development | p. 384 |
| Iterative Versus Waterfall | p. 384 |
| A Spiral Development Process | p. 384 |
| Architecture-Centric | p. 385 |
| Getting Control | p. 386 |
| Feature-Centric Development | p. 386 |
| Timeboxing Iterations | p. 387 |
| Being Adaptive but Managed | p. 387 |
| Planning an Iterative Project | p. 388 |
| Planning an Iteration | p. 388 |
| Architecture-Centric | p. 390 |
| Why Have an Architecture? | p. 390 |
| Plan Incremental Building of Software | p. 391 |
| Performance Measurements and Reporting | p. 392 |
| Weekly Progress Meetings | p. 392 |
| Monthly Meetings | p. 392 |
| Progress Reporting | p. 393 |
| Process for Managing Change | p. 393 |
| Sample Timesheets | p. 394 |
| References | p. 394 |
| Agile Modeling | p. 395 |
| Introduction | p. 395 |
| Modelling Misconceptions | p. 396 |
| The Manifesto for Agile Modeling | p. 399 |
| Agile Modeling | p. 401 |
| Agile Modeling and the Unified Process | p. 406 |
| Agile Modelling and Documentation | p. 408 |
| Tool Misconceptions | p. 409 |
| Summary | p. 410 |
| References | p. 410 |
| Online References | p. 410 |
| Appendix A UML Notation | p. 411 |
| Index | p. 419 |
| Table of Contents provided by Publisher. All Rights Reserved. |
ISBN: 9781852337216
ISBN-10: 1852337214
Series: Springer Professional Computing
Published: 2nd September 2003
Format: Hardcover
Language: English
Number of Pages: 448
Audience: Professional and Scholarly
Publisher: Springer Nature B.V.
Country of Publication: GB
Edition Number: 2
Edition Type: Revised
Dimensions (cm): 23.5 x 18.42 x 2.54
Weight (kg): 0.93
Shipping
| Standard Shipping | Express Shipping | |
|---|---|---|
| Metro postcodes: | $9.99 | $14.95 |
| Regional postcodes: | $9.99 | $14.95 |
| Rural postcodes: | $9.99 | $14.95 |
Orders over $79.00 qualify for free shipping.
How to return your order
At Booktopia, we offer hassle-free returns in accordance with our returns policy. If you wish to return an item, please get in touch with Booktopia Customer Care.
Additional postage charges may be applicable.
Defective items
If there is a problem with any of the items received for your order then the Booktopia Customer Care team is ready to assist you.
For more info please visit our Help Centre.
You Can Find This Book In

Apache Iceberg: The Definitive Guide
Data Lakehouse Functionality, Performance, and Scalability on the Data Lake
Paperback
RRP $133.00
$64.75
OFF
This product is categorised by
- Non-FictionComputing & I.T.Computer Programming & Software DevelopmentSoftware EngineeringUnified Modelling Language or UML
- Non-FictionComputing & I.T.Computer Programming & Software DevelopmentObject-Oriented Programming or OOP
- Non-FictionComputing & I.T.Computer Programming & Software DevelopmentWeb Programming
- Non-FictionComputing & I.T.Computer Programming & Software DevelopmentProgramming & Scripting Languages
- Non-FictionComputing & I.T.Computer Programming & Software DevelopmentCompilers & Interpreters























