Main Page

   
Executable UML: A Foundation for Model-Driven Architecture
By Stephen J. Mellor, Marc J. Balcer
   
Publisher : Addison Wesley
Pub Date : May 14, 2002
ISBN : 0-201-74804-5
Pages : 416


Executable UML is a major innovation in the field of software development. It is designed to produce a comprehensive and understandable model of a solution independent of the organization of the software implementation. It is a highly abstract thinking tool that aids in the formalization of knowledge, and is also a way of describing the concepts that make up abstract solutions to software development problems.

This timely new book, Executable UML: A Foundation for Model-Driven Architecture, thoroughly introduces, documents, and explains this important new technology. The authors show how UML can formalize requirements and use cases into a rich set of verifiable diagrams, how it can be used to produce executable and testable models, and how these models can be translated directly into code. In addition, the book explains how individual system domains are woven together by an executable UML model compiler.

The book is full of tips and techniques to help you:

  • Partition a system into subject matters based on individual aspects

  • Pick the right level for use case modeling to speed subject matter comprehension

  • Model classes and focus on relationships to capture subject matter semantics precisely

  • Express behavior using the newly adopted UML action semantics and action languages

  • Specify constraints using tags specified in OCL (Object Constraint Language)

In addition, this book tackles topics of particular importance in execution, such as how to:

  • Synchronize objects by building lifecycles using statechart diagrams

  • Model relationships and contention safely

  • Distribute dynamics to avoid unmaintainable controller objects

  • Verify the models by executing test cases against the statechart diagrams and constraints


   
•  Table of Contents
•  Index
Executable UML: A Foundation for Model-Driven Architecture
By Stephen J. Mellor, Marc J. Balcer
   
Publisher : Addison Wesley
Pub Date : May 14, 2002
ISBN : 0-201-74804-5
Pages : 416
Copyright
    List of Figures
    Foreword
    Preface
      Frequently Asked Questions
   
    Acknowledgments
    Chapter 1.  Introduction
      Section 1.1.  Raising the Level of Abstraction
      Section 1.2.  Executable UML
      Section 1.3.  Making UML Executable
      Section 1.4.  Model Compilers
      Section 1.5.  Model-Driven Architecture
      Section 1.6.  References
   
    Chapter 2.  Using Executable UML
      Section 2.1.  The System Model
      Section 2.2.  Modeling a Single Domain
      Section 2.3.  Verification and Execution
      Section 2.4.  The Big Picture
      Section 2.5.  References
   
    Chapter 3.  Domains and Bridges
      Section 3.1.  Domains
      Section 3.2.  Domains and Requirements
      Section 3.3.  Bridges
      Section 3.4.  Aspects and Join Points
      Section 3.5.  Domains and Aspects
      Section 3.6.  References
   
    Chapter 4.  Use Cases
      Section 4.1.  Basics of Use Cases
      Section 4.2.  Working with Use Cases
      Section 4.3.  Activity Diagrams
      Section 4.4.  Formalizing Use Cases
      Section 4.5.  Scenarios and Testing
      Section 4.6.  System Modeling
      Section 4.7.  References
   
    Chapter 5.  Classes and Attributes
      Section 5.1.  Classes
      Section 5.2.  Attributes
      Section 5.3.  Attribute Data Types
      Section 5.4.  Documenting Classes and Attributes
      Section 5.5.  Checking Classes and Attributes
      Section 5.6.  Rules, Rules, Rules
      Section 5.7.  References
   
    Chapter 6.  Relationships and Associations
      Section 6.1.  Associations
      Section 6.2.  Association Descriptions
      Section 6.3.  Checking Associations
      Section 6.4.  Association Classes
      Section 6.5.  Generalization and Specialization
      Section 6.6.  Reflexive Associations
      Section 6.7.  The Class Model
      Section 6.8.  References
   
    Chapter 7.  Class Actions
      Section 7.1.  Object and Attribute Actions
      Section 7.2.  Selection Expressions
      Section 7.3.  Link Actions
      Section 7.4.  Link Object Actions
      Section 7.5.  Generalization Hierarchies
      Section 7.6.  Other Action Languages
      Section 7.7.  References
   
    Chapter 8.  Constraints
      Section 8.1.  Unique Instance Constraints
      Section 8.2.  Derived Attributes
      Section 8.3.  Referential Constraints
      Section 8.4.  Association Loops
      Section 8.5.  Constraints Capture Semantics
      Section 8.6.  References
   
    Chapter 9.  Lifecycles
      Section 9.1.  Concept of a Lifecycle
      Section 9.2.  State Machine
      Section 9.3.  State Transition Table
      Section 9.4.  Creating and Deleting Objects
      Section 9.5.  Forming Lifecycles
      Section 9.6.  Lifecycles for Classes
      Section 9.7.  References
   
    Chapter 10.  Communicating Objects
      Section 10.1.  Signals
      Section 10.2.  Creating and Deleting Objects
      Section 10.3.  Visualizing Domain Dynamics
      Section 10.4.  Domain Dynamics
   
    Chapter 11.  Synchronizing Objects
      Section 11.1.  How to Think about Time
      Section 11.2.  Rules about Signals
      Section 11.3.  Rules about Procedures
      Section 11.4.  Rules about Data Access
      Section 11.5.  Delayed Signals and Time Events
      Section 11.6.  Rules, Rules, Rules
      Section 11.7.  References
   
    Chapter 12.  Using Lifecycles
      Section 12.1.  Statechart Diagram Construction Techniques
      Section 12.2.  Reworking the Class Diagram
      Section 12.3.  References
   
    Chapter 13.  Relationship Dynamics
      Section 13.1.  Dynamically Simple Associations
      Section 13.2.  Associations Involving Competition
      Section 13.3.  Dynamics in Generalization Hierarchies
      Section 13.4.  Polymorphic Events and Polymorphic Signals
      Section 13.5.  Reclassification
      Section 13.6.  References
   
    Chapter 14.  Domain Dynamics
      Section 14.1.  Partitioning Control
      Section 14.2.  Control Strategies
      Section 14.3.  Delegation of Control
      Section 14.4.  Input Conditioning
      Section 14.5.  Distributed Dynamics
      Section 14.6.  References
   
    Chapter 15.  Domain Verification
      Section 15.1.  Finding Unit Tests for a Single Use Case
      Section 15.2.  Test Execution
      Section 15.3.  System Tests
      Section 15.4.  Finding Test Cases from the Models
      Section 15.5.  The Verification Gap
      Section 15.6.  References
   
    Chapter 16.  Model Management
      Section 16.1.  Dividing Large Domains
      Section 16.2.  Subsystems and the Class Diagram
      Section 16.3.  Collaborations between Subsystems
      Section 16.4.  Adjusting Subsystem Partitioning
      Section 16.5.  Model Management
   
    Chapter 17.  Joining Multiple Domains
      Section 17.1.  Kinds of Domains
      Section 17.2.  Anonymous Explicit Bridges
      Section 17.3.  Implicit Bridging with Join Points
      Section 17.4.  Bridging to the Model Compiler
   
    Chapter 18.  Model Compilers
      Section 18.1.  Compiling the Models: The Bookstore
      Section 18.2.  Model Compilers and the Software Platform
      Section 18.3.  Fit
      Section 18.4.  Buying, Modifying, and Building a Model Compiler
      Section 18.5.  Modeling the Model Compiler as a Domain
      Section 18.6.  References
   
    Appendix A.  Glossary
    Appendix B.  Case Study
      Section B.1.  Subsystem ProductSpecification
      Section B.2.  Subsystem Ordering
      Section B.3.  Subsystem Shipping
      Section B.4.  Domain Data Types
      Section B.5.  Object Collaboration Diagram
   
    Index