Foreword. Preface. I. INTRODUCTION. 1. Object-Oriented Analysis and Design. What Will You Learn? Is it Useful? The Most Important Learning Goal? What is Analysis and Design? What is Object-Oriented Analysis and Design? A Short Example. What is the UML? Visual Modeling is a Good Thing.
History. Recommended Resources. 2. Iterative, Evolutionary, and Agile. What is the UP? Are Other Methods Complementary? What is Iterative and Evolutionary Development? What About the Waterfall Lifecycle? How to do Iterative and Evolutionary Analysis and Design? What is Risk-Driven and Client-Driven Iterative Planning? What are Agile Methods and Attitudes? What is Agile Modeling? What is an Agile UP? Are There Other Critical UP Practices? What are the UP Phases? What are the UP Disciplines? How to Customize the Process? The UP Development Case. You Know You Didn''t Understand Iterative Development or the UP When. History. Recommended Resources.
3. Case Studies. What is and isn''t Covered in the Case Studies? Case Study Strategy: Iterative Development + Iterative Learning. Case One: The NextGen POS System. Case Two: The Monopoly Game System. II. INCEPTION. 4.
Inception is Not the Requirements Phase. What is Inception? How Long is Inception? What Artifacts May Start in Inception? You Know You Didn''t Understand Inception When. How Much UML During Inception? 5. Evolutionary Requirements. Definition: Requirements. Evolutionary vs. Waterfall Requirements. What are Skillful Means to Find Requirements? What are the Types and Categories of Requirements? How are Requirements Organized in UP Artifacts? Does the Book Contain Examples of These Artifacts? Recommended Resources.
6. Use Cases. Example. Definition: What are Actors, Scenarios, and Use Cases? Use Cases and the Use-Case Model. Motivation: Why Use Cases? Definition: Are Use Cases Functional Requirements? Definition: What are Three Kinds of Actors? Notation: What are Three Common Use Case Formats? Example: Process Sale, Fully Dressed Style. What do the Sections Mean? Notation: Are There Other Formats? A Two-Column Variation. Guideline: Write in an Essential UI-Free Style. Guideline: Write Terse Use Cases.
Guideline: Write Black-Box Use Cases. Guideline: Take an Actor and Actor-Goal Perspective. Guideline: How to Find Use Cases. Guideline: What Tests Can Help Find Useful Use Cases? Applying UML: Use Case Diagrams. Applying UML: Activity Diagrams. Motivation: Other Benefits of Use Cases? Requirements in Context. Example: Monopoly Game. Process: How to Work With Use Cases in Iterative Methods? History.
Recommended Resources. 7. Other Requirements. How Complete are these Examples? Guideline: Should We Analyze These Thoroughly During Inception? Guideline: Should These Artifacts be at the Project Website? NextGen Example: (Partial) Supplementary Specification. Commentary: Supplementary Specification. NextGen Example: (Partial) Vision. Commentary: Vision. NextGen Example: A (Partial) Glossary.
Commentary: Glossary (Data Dictionary). NextGen Example: Business Rules (Domain Rules). Commentary: Domain Rules. Process: Evolutionary Requirements in Iterative Methods. Recommended Resources. III. ELABORATION ITERATION 1-BASICS. 8.
Iteration 1-Basics. Iteration 1 Requirements and Emphasis: Core OOA/D Skills. Process: Inception and Elaboration. Process: Planning the Next Iteration. 9. Domain Models. Example. What is a Domain Model? Motivation: Why Create a Domain Model? Guideline: How to Create a Domain Model? Guideline: How to Find Conceptual Classes? Example: Find and Draw Conceptual Classes.
Guideline: Agile Modeling-Sketching a Class Diagram. Guideline: Agile Modeling-Maintain the Model in a Tool? Guideline: Report Objects-Include ''Receipt'' in the Model? Guideline: Think Like a Mapmaker; Use Domain Terms. Guideline: How to Model the Unreal World? Guideline: A Common Mistake with Attributes vs. Classes. Guideline: When to Model with ''Description'' Classes? Associations. Example: Associations in the Domain Models. Attributes. Example: Attributes in the Domain Models.
Conclusion: Is the Domain Model Correct? Process: Iterative and Evolutionary Domain Modeling. Recommended Resources. 10. System Sequence Diagrams. Example: NextGen SSD. What are System Sequence Diagrams? Motivation: Why Draw an SSD? Applying UML: Sequence Diagrams. What is the Relationship Between SSDs and Use Cases? How to Name System Events and Operations? How to Model SSDs Involving Other External Systems? What SSD Information to Place in the Glossary? Example: Monopoly SSD. Process: Iterative and Evolutionary SSDs.
History and Recommended Resources. 11. Operation Contracts. Example. Definition: What are the Sections of a Contract? Definition: What is a System Operation? Definition: Postconditions. Example: enterItem Postconditions. Guideline: Should We Update the Domain Model? Guideline: When Are Contracts Useful? Guideline: How to Create and Write Contracts. Example: NextGen POS Contracts.
Example: Monopoly Contracts. Applying UML: Operations, Contracts, and the OCL. Process: Operation Contracts Within the UP. History. Recommended Resources. 12. Requirements to Design-Iteratively. Iteratively Do the Right Thing, Do the Thing Right.
Provoking Early Change. Didn''t All That Analysis and Modeling Take Weeks To Do? 13. Logical Architecture and UML Package Diagrams. Example. What is the Logical Architecture? And Layers? What Layers are the Focus in the Case Studies? What is Software Architecture? Applying UML: Package Diagrams. Guideline: Design with Layers. Guideline: The Model-View Separation Principle. What''s the Connection Between SSDs, System Operations, and Layers? Example: NextGen Logical Architecture and Package Diagram.
Example: Monopoly Logical Architecture? Recommended Resources. 14. On to Object Design. Agile Modeling and Lightweight UML Drawing. UML CASE Tools. How Much Time Spent Drawing UML Before Coding? Designing Objects: What are Static and Dynamic Modeling? The Importance of Object Design Skill over UML Notation Skill. Other Object Design Techniques: CRC Cards. 15.
UML Interaction Diagrams. Sequence and Communication Diagrams. Novice UML Modelers Don''t Pay Enough Attention to Interaction Diagrams! Common UML Interaction Diagram Notation. Basic Sequence Diagram Notation. Basic Communication Diagram Notation. 16. UML Class Diagrams. Applying UML: Common Class Diagram Notation.
Definition: Design Class Diagram. Definition: Classifier. Ways to Show UML Attributes: Attribute Text and Association Lines. Note Symbols: Notes, Comments, Constraints, and Method Bodies. Operations and Methods. Keywords. Stereotypes, Profiles, and Tags. UML Properties and Property Strings.
Generalization, Abstract Classes, Abstract Operations. Dependency. Interfaces. Composition Over Aggregation. Constraints. Qualified Association. Association Class. Singleton Classes.
Template Classes and Interfaces. User-Defined Compartments. Active Class. What''s the Relationship Between Interaction and Class Diagrams? 17. GRASP: Designing Objects with Responsibilities. UML versus Design Principles. Object Design: Example Inputs, Activities, and Outputs. Responsibilities and Responsibility-Driven Design.
GRASP: A Methodical Approach to Basic OO Design. What''s the Connection Between Responsibilities, GRASP, and UML Diagrams? What are Patterns? Where are We Now? A Short Example of Object Design with GRASP. Applying GRASP to Object Design. Creator. Information Expert (or Expert). Low Coupling. Controller. High Cohesion.
Recommended Resources. 18. Object Design Examples with GRASP. What is a Use Case Realization? Artifact Comments. What''s Next? Use Case Realizations for the NextGen Iteration. Use Case Realizations for the Monopoly Iteration. Process: Iterative and Evolutionary Object Design. Summary.
19. Designing for Visibility. Visibility Between Objects. What is Visibility? 20. Mapping Designs to Code. Programming and Iterative, Evolutionary Development. Mapping Designs to Code. Creating Class Definitions from DCDs.
Creating Methods from Interaction Diagrams. Collection Classes in Code. Exceptions and Error Handling. Defining the Sale.makeLineItem Method. Order of Implementation. Test-Driven or Test-First Development.