Objects, Components, and Frameworks with UML: The Catalysis Approach
Desmond Francis D'Souza, Alan Cameron Wills
$299Microsoft Visual Basic .NET Step by Step
This book teaches the student how to use objects, frameworks, and UML notation to design, build, and reuse component-based software. Catalysis is a rapidly emerging UML-based method for object- and component-based development. It provides a clear meaning of and systematic uses for the UML notation. "The Catalysis Approach" explains how patterns can be characterized as model frameworks. Through the application of frameworks in requirements, specifications, architectures, and designs, students will find that all models contain recurring patterns of structure, behavior, and refinement. This opens the way to building models and designs rapidly by adapting and composing both generic and domain-specific modeling frameworks.
- Shows how to build clear shared business models.
- Defines essential shared vocabulary in a precise way.
- Points out critical requirements and design decisions early while abstracting detail.
- Uses UML as a powerful, unambiguous communication tool between analysts and designers.
- Makes families of adaptable systems from coherent kits of pluggable components.
- Assigns interface-centric design and composition to components.
- Creates robust components, using techniques of precise specification and design.
- Applies and extracts reusable frameworks for designs, specifications, and architectures.
I. OVERVIEW.1. A Tour of Catalysis.
Refinement: Objects and Actions at Different Scales.
Model Frameworks as Templates.
Zooming In on the Software: System Context.
Requirements Specification Models.
The Development Process.
Three Constructs Plus Frameworks.
Three Levels of Modeling.
II. MODELING WITH OBJECTS.
2. Static Models: Object Attributes and Invariants.
Object State: Objects and Attributes.
Implementations of Object State.
Modeling Object State: Types, Attributes, and Associations.
Models of Business; Models of Components.
Static Models: Summary.
3. Behavior Models: Object Types and Operations.
More Precise Action Specifications.
Two Java Implementations of a Calendar.
Type Specification of Calendar.
Actions with Invariants.
Interpreting an Action Specification.
Subtypes and Type Extension.
Factoring Action Specifications.
Outputs of Actions.
Subjective Model: The Meaning of Containment.
Type Specifications: Summary.
Programming Language: Classes and Types.
4. Interaction Models: Use Cases, Actions, and Collaborations.
Actions (Use Cases) Abstract Complex Interactions.
Use Cases Are Joint Actions.
Actions and Effects.
Uses of Collaborations.
5. Effective Documentation.
Documentation Is Easy and Fun, and It Speeds Design.
Reaching the Documentation Audience.
The Main Documents: Specification and Implementation.
Documenting Business Models.
Documenting Component Specifications.
Documenting Component Implementations.
III. FACTORING MODELS AND DESIGNS.
6. Abstraction, Refinement, and Testing.
Documenting Refinement and Conformance.
Spreadsheet: A Refinement Example.
Spreadsheet: Model Refinement.
Spreadsheet: Action Refinement.
Spreadsheet: Object Refinement.
Spreadsheet: Operation Refinement.
Refinement of State Charts.
Process Patterns for Refinement.
Pattern 6.2 The Golden Rule versus Other Optimizations.
Pattern 6.3 Orthogonal Abstractions and Refinement.
Pattern 6.4 Refinement Is a Relation, Not a Sequence.
Pattern 6.5 Recursive Refinement.
7. Using Packages.
How to Use Packages and Imports.
Decoupling with Packages.
Encapsulation with Packages.
Multiple Imports and Name Conflicts.
Publication, Version Control, and Builds.
Programming Language Packages.
8. Composing Models and Specifications.
Joining and Subtyping.
Combining Packages and Their Definitions.
Action Exceptions and Composing Specs.
9. Model Frameworks and Template Packages.
Model Frameworks of Types and Attributes.
Templates as Packages of Properties.
Templates for Equality and Copying.
Down to Basics with Templates.
Summary of Model Framework Concepts.
IV. IMPLEMENTATION BY ASSEMBLY.
10. Components and Connectors.
The Evolution of Components.
Building Components with Java.
Components with COM+.
Components with CORBA.
Component Kit: Pluggable Components Library.
Defining Cat One-A Component Architecture.
Specifying Cat One Components.
Connecting Cat One Components.
Pattern 10.2 Componentware Management.
Pattern 10.3 Build Models from Frameworks.
Pattern 10.4 Plug Conformance.
Pattern 10.5 Using Legacy or Third-Party Components.
11. Reuse and Pluggable Design Frameworks in Code.
Generic Components and Plug-Points.
The Framework Approach to Code Reuse.
Frameworks: Specs to Code.
Basic Plug Technology.
Pattern 11.2 Pluggable Roles.
Architecture Evaluation with Scenarios.
Architecture Builds on Defined Elements.
Architecture Uses Consistent Patterns.
Application versus Technical Architecture.
Typical Four-Tier Business Architecture.
Objects and Databases.
V. HOW TO APPLY CATALYSIS.
13. Process Overview.
General Notes on the Process.
Typical Project Evolution.
Typical Package Structure.
Main Process Patterns.
Pattern 13.2 Reengineering.
Pattern 13.3 Short-Cycle Development.
Pattern 13.4 Parallel Work.
14. How to Build a Business Model.
Pattern 14.2 Make a Business Model.
Pattern 14.3 Represent Business Vocabulary and Rules.
Pattern 14.4 Involve Business Experts.
Pattern 14.5 Creating a Common Business Model.
Pattern 14.6 Choose a Level of Abstraction.
Pattern 14.8 Separation of Concepts: Normalization.
Pattern 14.9 Items and Descriptors.
Pattern 14.10 Generalize and Specialize.
Pattern 14.11 Recursive Composite.
Pattern 14.12 Invariants from Association Loops.
Video Case Study: Abstract Business Model.
Video Business: Use Case Refinement.
15. How to Specify a Component.
Pattern 15.2 Bridge Requirements and Specifications.
Pattern 15.3 Use-Case-Led System Specification.
Pattern 15.4 Recursive Decomposition: Divide and Conquer.
Pattern 15.5 Make a Context Model with Use Cases.
Pattern 15.6 Storyboards.
Pattern 15.7 Construct a System Behavior Spec.
Pattern 15.8 Specifying a System Action.
Pattern 15.9 Using State Charts in System Type Models.
Pattern 15.10 Specify Component Views.
Pattern 15.11 Compose Component Views.
Pattern 15.12 Avoid Miracles, Refine the Spec.
Pattern 15.13 Interpreting Models for Clients.
Video Case Study: System Specifications.
System Context Diagram.
Using Model Frameworks.
16. How to Implement a Component.
Pattern 16.2 High-Level Component Design.
Pattern 16.3 Reifying Major Concurrent Use Cases.
Pattern 16.4 Separating Facades.
Pattern 16.5 Platform Independence.
Pattern 16.6 Separate Middleware from Business Components.
Pattern 16.7 Implement Technical Architecture.
Pattern 16.8 Basic Design.
Pattern 16.9 Generalize after Basic Design.
Pattern 16.10 Collaborations and Responsibilities.
Pattern 16.11 Link and Attribute Ownership.
Pattern 16.12 Object Locality and Link Implementation.
Pattern 16.13 Optimization.
Detailed Design Patterns.
Pattern 16.15 Role Decoupling.
Pattern 16.16 Factories.
Pattern 16.17 Observer.
Pattern 16.18 Plug-Points and Plug-Ins.
Video Case Study: Component-Based Design.
Appendix A: Object Constraint Language.
Appendix B: UML Perspective.
Appendix C: Catalysis Support Tools, Services, and Experiences.