Learning UML 2.0


book cover
Learning UML 2.0
By Kim Hamilton, Russell Miles
...............................................
Publisher: O'Reilly
Pub Date: April 2006
Print ISBN-10: 0-596-00982-8
Print ISBN-13: 978-0-59-600982-3
Pages: 286
 



Table of Contents  | Index
overview

"Since its original introduction in 1997, the Unified Modeling Language has revolutionized software development. Every integrated software development environment in the world--open-source, standards-based, and proprietary--now supports UML and, more importantly, the model-driven approach to software development. This makes learning the newest UML standard, UML 2.0, critical for all software developers--and there isn't a better choice than this clear, step-by-step guide to learning the language."
--Richard Mark Soley, Chairman and CEO, OMG

If you're like most software developers, you're building systems that are increasingly complex. Whether you're creating a desktop application or an enterprise system, complexity is the big hairy monster you must manage.



The Unified Modeling Language (UML) helps you manage this complexity. Whether you're looking to use UML as a blueprint language, a sketch tool, or as a programming language, this book will give you the need-to-know information on how to apply UML to your project. While there are plenty of books available that describe UML, Learning UML 2.0 will show you how to use it. Topics covered include:



  • Capturing your system's requirements in your model to help you ensure that your designs meet your users' needs

  • Modeling the parts of your system and their relationships

  • Modeling how the parts of your system work together to meet your system's requirements

  • Modeling how your system moves into the real world, capturing how your system will be deployed



Engaging and accessible, this book shows you how to use UML to craft and communicate your project's design. Russ Miles and Kim Hamilton have written a pragmatic introduction to UML based on hard-earned practice, not theory. Regardless of the software process or methodology you use, this book is the one source you need to get up and running with UML 2.0. Additional information including exercises can be found at www.learninguml2.com.



Russ Miles is a software engineer for General Dynamics UK, where he works with Java and Distributed Systems, although his passion at the moment is Aspect Orientation and, in particular, AspectJ. Kim Hamilton is a senior software engineer at Northrop Grumman, where she's designed and implemented a variety of systems including web applications and distributed systems, with frequent detours into algorithms development.



book cover
Learning UML 2.0
By Kim Hamilton, Russell Miles
...............................................
Publisher: O'Reilly
Pub Date: April 2006
Print ISBN-10: 0-596-00982-8
Print ISBN-13: 978-0-59-600982-3
Pages: 286
 



Table of Contents  | Index

   Copyright
   Preface
        Chapter 1.  Introduction
      Section 1.1.  What's in a Modeling Language?
      Section 1.2.  Why UML 2.0?
      Section 1.3.  Models and Diagrams
      Section 1.4.  "Degrees" of UML
      Section 1.5.  UML and the Software Development Process
      Section 1.6.  Views of Your Model
      Section 1.7.  A First Taste of UML
      Section 1.8.  Want More Information?
        Chapter 2.  Modeling Requirements: Use Cases
      Section 2.1.  Capturing a System Requirement
      Section 2.2.  Use Case Relationships
      Section 2.3.  Use Case Overview Diagrams
      Section 2.4.  What's Next?
        Chapter 3.  Modeling System Workflows: Activity Diagrams
      Section 3.1.  Activity Diagram Essentials
      Section 3.2.  Activities and Actions
      Section 3.3.  Decisions and Merges
      Section 3.4.  Doing Multiple Tasks at the Same Time
      Section 3.5.  Time Events
      Section 3.6.  Calling Other Activities
      Section 3.7.  Objects
      Section 3.8.  Sending and Receiving Signals
      Section 3.9.  Starting an Activity
      Section 3.10.  Ending Activities and Flows
      Section 3.11.  Partitions (or Swimlanes)
      Section 3.12.  Managing Complex Activity Diagrams
      Section 3.13.  What's Next?
        Chapter 4.  Modeling a System's Logical Structure: Introducing Classes and Class Diagrams
      Section 4.1.  What Is a Class?
      Section 4.2.  Getting Started with Classes in UML
      Section 4.3.  Visibility
      Section 4.4.  Class State: Attributes
      Section 4.5.  Class Behavior: Operations
      Section 4.6.  Static Parts of Your Classes
      Section 4.7.  What's Next
        Chapter 5.  Modeling a System's Logical Structure: Advanced Class Diagrams
      Section 5.1.  Class Relationships
      Section 5.2.  Constraints
      Section 5.3.  Abstract Classes
      Section 5.4.  Interfaces
      Section 5.5.  Templates
      Section 5.6.  What's Next
        Chapter 6.  Bringing Your Classes to Life: Object Diagrams
      Section 6.1.  Object Instances
      Section 6.2.  Links
      Section 6.3.  Binding Class Templates
      Section 6.4.  What's Next?
        Chapter 7.  Modeling Ordered Interactions: Sequence Diagrams
      Section 7.1.  Participants in a Sequence Diagram
      Section 7.2.  Time
      Section 7.3.  Events, Signals, and Messages
      Section 7.4.  Activation Bars
      Section 7.5.  Nested Messages
      Section 7.6.  Message Arrows
      Section 7.7.  Bringing a Use Case to Life with a Sequence Diagram
      Section 7.8.  Managing Complex Interactions with Sequence Fragments
      Section 7.9.  What's Next?
        Chapter 8.  Focusing on Interaction Links: Communication Diagrams
      Section 8.1.  Participants, Links, and Messages
      Section 8.2.  Fleshing out an Interaction with a Communication Diagram
      Section 8.3.  Communication Diagrams Versus Sequence Diagrams
      Section 8.4.  What's Next?
        Chapter 9.  Focusing on Interaction Timing: Timing Diagrams
      Section 9.1.  What Do Timing Diagrams Look Like?
      Section 9.2.  Building a Timing Diagram from a Sequence Diagram
      Section 9.3.  Applying Participants to a Timing Diagram
      Section 9.4.  States
      Section 9.5.  Time
      Section 9.6.  A Participant's State-Line
      Section 9.7.  Events and Messages
      Section 9.8.  Timing Constraints
      Section 9.9.  Organizing Participants on a Timing Diagram
      Section 9.10.  An Alternate Notation
      Section 9.11.  What's Next?
        Chapter 10.  Completing the Interaction Picture: Interaction Overview Diagrams
      Section 10.1.  The Parts of an Interaction Overview Diagram
      Section 10.2.  Modeling a Use Case Using an Interaction Overview
      Section 10.3.  What's Next?
        Chapter 11.  Modeling a Class's Internal Structure: Composite Structures
      Section 11.1.  Internal Structure
      Section 11.2.  Showing How a Class Is Used
      Section 11.3.  Showing Patterns with Collaborations
      Section 11.4.  What's Next?
        Chapter 12.  Managing and Reusing Your System's Parts: Component Diagrams
      Section 12.1.  What Is a Component?
      Section 12.2.  A Basic Component in UML
      Section 12.3.  Provided and Required Interfaces of a Component
      Section 12.4.  Showing Components Working Together
      Section 12.5.  Classes That Realize a Component
      Section 12.6.  Ports and Internal Structure
      Section 12.7.  Black-Box and White-Box Component Views
      Section 12.8.  What's Next?
        Chapter 13.  Organizing Your Model: Packages
      Section 13.1.  Packages
      Section 13.2.  Namespaces and Classes Referring to Each Other
      Section 13.3.  Element Visibility
      Section 13.4.  Package Dependency
      Section 13.5.  Importing and Accessing Packages
      Section 13.6.  Managing Package Dependencies
      Section 13.7.  Using Packages to Organize Use Cases
      Section 13.8.  What's Next?
        Chapter 14.  Modeling an Object's State: State Machine Diagrams
      Section 14.1.  Essentials
      Section 14.2.  States
      Section 14.3.  Transitions
      Section 14.4.  States in Software
      Section 14.5.  Advanced State Behavior
      Section 14.6.  Composite States
      Section 14.7.  Advanced Pseudostates
      Section 14.8.  Signals
      Section 14.9.  Protocol State Machines
      Section 14.10.  What's Next?
        Chapter 15.  Modeling Your Deployed System: Deployment Diagrams
      Section 15.1.  Deploying a Simple System
      Section 15.2.  Deployed Software: Artifacts
      Section 15.3.  What Is a Node?
      Section 15.4.  Hardware and Execution Environment Nodes
      Section 15.5.  Communication Between Nodes
      Section 15.6.  Deployment Specifications
      Section 15.7.  When to Use a Deployment Diagram
      Section 15.8.  What's Next?
        Appendix A.  Object Constraint Language
      Section A.1.  Building OCL Expressions
      Section A.2.  Types
      Section A.3.  Operators
      Section A.4.  Pulling It Together
      Section A.5.  Context
      Section A.6.  Types of Constraints
      Section A.7.  OCL Automation
        Appendix B.  Adapting UML: Profiles
      Section B.1.  What Is a Profile?
      Section B.2.  Stereotypes
      Section B.3.  Tagged Values
      Section B.4.  Constraints
      Section B.5.  Creating a Profile
      Section B.6.  Working with the Meta-Model
      Section B.7.  Using a Profile
      Section B.8.  Why Bother with Profiles?
        Appendix C.  A History of UML
      Section C.1.  Take One Part OOAD...
      Section C.2.  ...with a Sprinkling of OOSE...
      Section C.3.  ...Add a Dash of OMT...
      Section C.4.  ...and Bake for 10 to 15 Years
   About the Authors
   Colophon
   Index