You are previewing UML Pattern Language, A.
O'Reilly logo
UML Pattern Language, A

Book Description

A UML Pattern Language pairs the software design pattern concept with the Unified Modeling Language (UML) to offer a tool set for software professionals practicing both system modeling and software development. This book provides: a collection of patterns in the domain of system modeling, including those that are useful to management, operations, and deployment teams, as well as to software developers; a survey of the development of patterns and the UML; a discussion of the underlying theory of the patterns and instructions for using the language; a thorough exploration of the design process and model-driven development. A UML Pattern Language recognizes that design and modeling have become equal partners with programming and coding in the enterprise of software development. Providing both an understanding of the work of design and the way patterns and the UML combine to facilitate design.

Table of Contents

  1. Copyright
    1. Dedications
  2. About the Author
    1. About the Technical Reviewers
  3. Acknowledgments
  4. Introduction
    1. Patterns and the UML
    2. Levels and Shared Idioms
    3. Using This Book
    4. Resources, Sources, and References
  5. I. Getting Started
    1. 1. Pattern Essentials
      1. 1.1. Patterns and Paradigms
        1. 1.1.1. The Idea of a Pattern
      2. 1.2. Elements of Patterns
        1. 1.2.1. A Simple Example
      3. 1.3. Interpreting the Patterns in This Book
        1. 1.3.1. This Book's Pattern Format
    2. 2. The Unified Modeling Language
      1. 2.1. The UML, Briefly Put
      2. 2.2. Roots
        1. 2.2.1. Key Players
      3. 2.3. Understanding the UML
      4. 2.4. Unification: The Methods Wars Are Over
        1. 2.4.1. Best Practices: In the Eye of the Beholder
        2. 2.4.2. An Independent-Minded Modeling Language
    3. 3. UML Essentials, Elements, and Artifacts
      1. 3.1. Elements, Viewpoints, and Views
        1. 3.1.1. Models and Model Elements
        2. 3.1.2. Diagrams
      2. 3.2. Packages
        1. 3.2.1. Models: Packages of Views
        2. 3.2.2. Subsystems: Packages of Behavior and Operations
        3. 3.2.3. Frameworks: Packages of Patterns
      3. 3.3. Extensions
        1. 3.3.1. Tagged Values
        2. 3.3.2. Constraints
        3. 3.3.3. Stereotypes
        4. 3.3.4. Profiles
      4. 3.4. Symbols
        1. 3.4.1. Actor
        2. 3.4.2. Use Case/Collaboration
        3. 3.4.3. Class/Object/Type/Active Class
        4. 3.4.4. Interface
        5. 3.4.5. Component
        6. 3.4.6. Node
        7. 3.4.7. Package
        8. 3.4.8. State
        9. 3.4.9. Note
      5. 3.5. Lines
        1. 3.5.1. Messages
        2. 3.5.2. Relationships in General
        3. 3.5.3. Relationships: Some Types of Associations
        4. 3.5.4. Relationships: Some Uses of Dependency
        5. 3.5.5. Abstraction: Other Uses of Dependency
      6. 3.6. Diagrams
        1. 3.6.1. Class Diagram
        2. 3.6.2. Use Case Diagram
        3. 3.6.3. Interaction Diagrams
          1. Sequence Diagram
          2. Collaboration Diagram
        4. 3.6.4. State Diagrams
        5. 3.6.5. Activity Diagrams
        6. 3.6.6. Implementation Diagrams
          1. Component Diagrams
          2. Deployment Diagrams
      7. 3.7. Further Reading
  6. II. The Pattern Language
    1. 4. Patterns of Style
      1. Context
      2. Common Forces
      3. Discussion
        1. 4.1. Attributes as Compositions to Types
        2. 4.2. Providing Focus
        3. 4.3. Explicit Elision
        4. 4.4. Tree Routing
        5. 4.5. Tombstone Packages
        6. 4.6. Inheritance Goes Up
        7. 4.7. Rotated Text
        8. 4.8. Dual Associations
        9. 4.9. Billboard Packages
        10. 4.10. Text Workarounds
        11. 4.11. Seven Plus or Minus Two
      4. Summary
    2. 5. Patterns of Substance
      1. Context
      2. Common Forces
      3. Discussion
        1. 5.1. STANDARD DIAGRAMS
        2. 5.2. IMPLEMENTATION OR REPRESENTATION
        3. 5.3. DIGESTIBLE CHUNKS
        4. 5.4. ATTACH THE ACTOR
        5. 5.5. BUSINESS RULES INVARIABLY CONSTRAIN
        6. 5.6. DYNAMIC OBJECT TYPES
        7. 5.7. MANY-TO-MANY CLASS TRIO
        8. 5.8. MODEL THE SEAMS
        9. 5.9. PACKAGING PARTITIONS
        10. 5.10. LET THE TOOLS DO THE WORK
        11. 5.11. OPAQUE PACKAGES
      4. Summary
    3. 6. Domain Patterns
      1. Context
      2. Common Forces
      3. Discussion
        1. 6.1. DOMAIN MODEL IS ESSENTIAL
        2. 6.2. ACTORS PLAY ESSENTIAL ROLES
        3. 6.3. FACTOR THE ACTOR
        4. 6.4. ESSENTIAL ACTIONS
        5. 6.5. ESSENTIAL VOCABULARY
        6. 6.6. OBJECTIFY INTERNAL ROLES
        7. 6.7. TOBE MODEL
        8. 6.8. ASIS MODEL
      4. Summary
    4. 7. Product Patterns
      1. Context
      2. Forces
      3. Discussion
        1. 7.1. MANAGABLE PRODUCT
        2. 7.2. PRODUCT STAKEHOLDERS ARE MODEL CLIENTS
        3. 7.3. PRODUCT EVENTS IN CONTEXT
        4. 7.4. USE CASES REPRESENT REQUIREMENTS
        5. 7.5. BOUNDARY-CONTROL-ENTITY (BCE)
        6. 7.6. PRODUCT CHUNKS DIGEST EASILY
        7. 7.7. PRODUCT TRACES SUPPORT ROBUSTNESS
        8. 7.8. USE CASES: WORK AS PACKAGES
        9. 7.9. TESTS NEED MODELS
        10. 7.10. CONFIGURATION MANAGEMENT MODEL
        11. Summary
    5. 8. Component Patterns
      1. Context
      2. Discussion
        1. 8.1. SEPARATION OF CONCERNS
        2. 8.2. WHOLE COMPONENTS
        3. 8.3. ICONS CLARIFY COMPONENTS
        4. 8.4. PICTURES DEPICT NODES
        5. 8.5. SPECIFICATION BACKPLANE
        6. 8.6. COMPONENTS MANAGE CHANGE
        7. 8.7. CONFIGURED AND RELEASED PACKAGES
        8. 8.8. MODEL FOR MAINTENANCE
      3. Summary
  7. III. Another Starting Point
    1. 9. Patterns in Context
      1. 9.1. A Little Starting Context
        1. 9.1.1. Force 1: Structuring Abstraction, Abstracting Structure
        2. 9.1.2. Force 2: Guiding Creativity, Creative Guidance
        3. 9.1.3. Force 3: The Search for Quality and Reuse
        4. 9.1.4. Broader Cultural and Professional Forces
      2. 9.2. The Pattern Idea
        1. 9.2.1. First Hints
        2. 9.2.2. The Early Years
        3. 9.2.3. The Idea Emerges
        4. 9.2.4. The Beginnings of PLoP
        5. 9.2.5. The Gang of Four and After
      3. 9.3. Patterns as Literature
      4. 9.4. Types of Software Patterns
        1. 9.4.1. CoplienForm
        2. 9.4.2. GammaForm
      5. 9.5. The Roots: Alexander on Patterns and Pattern Languages
      6. 9.6. A Note on This Language
      7. 9.7. The Importance of Patterns
      8. 9.8. Where Is It All Going?
    2. 10. The UML in Context
      1. 10.1. Why Make System Models?
        1. 10.1.1. What Use Is a Model?
      2. 10.2. Every Picture Tells a Story: The UML as a Modeling Language
      3. 10.3. The UML Specification and Metamodel
      4. 10.4. What Do We Model?
        1. 10.4.1. Architecture
        2. 10.4.2. Domains
        3. 10.4.3. Products
        4. 10.4.4. Solutions
      5. 10.5. Abstraction and Architecture Made Simple
        1. 10.5.1. Abstraction
        2. 10.5.2. Architecture
      6. 10.6. Perspectives: A Generic Modeling Framework
    3. 11. Putting It All Together: Reflecting on the Work of Design
      1. 11.1. The Work of Design
        1. 11.1.1. What Is Design?
        2. 11.1.2. Beyond Patterns and Paradigms
      2. 11.2. Elements of Reflective Design
        1. 11.2.1. Problem Setting
        2. 11.2.2. A Language of Design
        3. 11.2.3. A Language about Designing
        4. 11.2.4. Performance
          1. Moves
          2. Consequences
          3. Implications
        5. 11.2.5. Closure
        6. 11.2.6. Reflective Design and Systems Modeling
      3. 11.3. To Be Continued…
  8. References