Welcome to Scribd, the world's digital library. Read, publish, and share books and documents. See more
Standard view
Full view
of .
Save to My Library
Look up keyword or section
Like this

Table Of Contents

Rational University Curriculum
Where Are We?
The Purpose of the Requirements Discipline
Requirements in Context
Relevant Requirements Artifacts
Case Study: Course Registration Problem
What Is System Behavior?
ajor Concepts in Use-Case Modeling
Review: What Is a Use-Case Model?
Review: What Are the Benefits of Use-Case
Useful Questions in Finding Actors
Focus on the Roles
A User May Have Different Roles
System Surroundings and Actors
Name and Describe Each Actor
Practice: Find the Actors
Practice: Solution
Finding Use Cases: Focus on the Actor
Useful Questions in Finding Use Cases
Naming the Use Case
Practice: Finding Use Cases
Use-Case Specifications
Use Case Flow of Events
What Are Scenarios ?
Supplementary Specification
Example: Glossary And Supplementary
Checkpoints: Use-Case Model
Checkpoints: Actors
Checkpoints: Use Cases
Checkpoints: Glossary
Exercise: System Behavior
Exercise: Review
Analysis and Design in Context
Analysis and Design Overview
Analysis and Design Discipline
Role: Software Architect
Role: Designer
Analysis and Design Activity Overview
Analysis vs. Design
Analysis and Design Is Not Top-Down or Bottom-
Review: Analysis and Design Is Architecture-
Concept: Architecture
Architecture Constrains
Software Architecture: The ³4+1 View´ Model
Review: Analysis and Design Is Use-Case Driven
Concept: Use-Case Realization
The Value of Use-Case Realizations
Review: Analysis and Design Is Iterative
Analysis and Design in an Iterative Process
Architectural Analysis in Context
Architectural Analysis Overview
Review: What Is Architecture: The ³4+1 View´
Define the High-Level Organization of
Patterns and Frameworks
Concept: Design Patterns
What Is an Architectural Pattern?
Architectural Pattern: Layers
Typical Layering Approach
Layering Considerations
Review: What Is a Package?
Modeling Architectural Layers
Package Relationships: Dependency
Avoiding Circular Dependencies
Example: Upper Level Layers
Architectural Pattern: M-V-C
Typical Approach for M-V-C
Concept: Architectural Mechanisms
Architectural Mechanisms: Three Categories
Why Use Analysis Mechanisms?
Sample Analysis Mechanisms
Examples of Analysis Mechanism Characteristics
Describing Analysis Mechanisms
Example: Course Registration Analysis
So«How Do I Discover Analysis Mechanisms?
What Are Key Abstractions?
Purpose of Identifying Key Abstractions
Defining Key Abstractions
Example: Key Abstractions
Checkpoints (cont.)
Exercise: Architectural Analysis
Use-Case Analysis in Context
Use-Case Analysis Overview
Purpose of Use-Case Analysis
Overview: Use-Case Analysis Steps
Supplement the Use-Case Description
Do the Requirements Change?
Find Classes from Use-Case Behavior
Review: Class
Guidelines for Class Discovery
Example: Stereotype
What Are Analysis Classes?
Analysis Classes: A First Step Toward
What Is a Boundary Class?
Practice: Finding Boundary Classes
Practice Solution: Boundary Classes
What Is a Control Class?
The Role of a Control Class
Guidelines: Control Class
Finding Control Classes
Practice: Finding Control Classes
What Is an Entity Class?
The Role of an Entity Class
Guidelines: Entity Class
Finding Entity Classes
How Do You Filter Nouns?
Pitfalls when Filtering Nouns
Practice: Finding Entity Classes
Practice: Solution
Analysis Classes and the MVC Architectural
Distribute Use-Case Behavior to Classes
Objects Need to Collaborate
Concept: Messages
Review: Encapsulation
Example: Object Interaction
What Is Class Responsibility?
How Does an Object ³Advertise´
Review: The Anatomy of Sequence Diagrams
Review: The Anatomy of Collaboration Diagrams
Concept: Link
Guidelines: Allocating Responsibilities to
Why Collaboration Diagrams?
How Are You Doing?
How Are You Doing? (cont.)
Example: Collaboration Diagram
One Collaboration Diagram Is Not Good Enough
Exercise: Use-Case Analysis
Exercise: Distribute Behavior to Classes
Exercise: Distribute Behavior to Classes
Purpose of Describe Responsibilities
Maintaining Consistency: What to Look For
Describe Attributes and Associations Purpose
Review: What Is an Attribute?
Attribute Usage
Finding Attributes
Concept: Association
The Relationship Between Links and
How Do You Find an Association?
Practice: What Associations Can You Find?
What Is an Association Name?
What Is a Role?
Reflexive Associations and Roles
Good and Bad Examples of Association Names
Example: Roles and Association Names
Review: What Is Multiplicity?
Multiplicity Indicators
What Does Multiplicity Mean?
Guidelines: Multiplicity and Role Names
Example: Multiplicity
What Is Aggregation?
Shared Aggregation
Aggregation Tests
Association or Aggregation?
Example: Aggregation
Example: Multiple Associations
Describe Event Dependencies
Concept: Subscribe-Association
Subscribe-Association and MVC
Subscribe-Association from Boundary Classes
Subscribe-Association from Entity Classes
Subscribe-Association from Control Classes
Example: Subscribe-Association
Association Type Usage Guidelines
Purpose of Qualify Analysis Mechanisms
Review: Why Use Analysis Mechanisms?
Example: Describing Analysis Mechanisms
Unify Analysis Classes
Checkpoints: Analysis Classes
Checkpoints: Use-Case Realizations
Purpose of Review the Design
Role: Design Reviewer
When Do You Conduct A Review?
Purpose of Review the Design Model as a Whole
Layering Defects
Concept: Coupling
Package Coupling: Package Dependencies
Package Coupling: Class Relationships
Concept: Cohesion
Examples: Cohesion
General Checkpoints
Layers Checkpoints
Purpose of Review Each Use-Case Realization
Enforcing Consistency
Documenting Results: The Review Record
Exercise: Review the Design Model
Design: A Step Closer to Source Code
Design: Tasks to Complete
Review: Analysis vs. Design
From Analysis Classes to Design Elements
Identifying Design Classes
Subsystems and Interfaces
Subsystems and Interfaces (cont.)
Subsystems vs. Packages
Subsystem Usage
Review: Course Registration Analysis
Design Mechanisms: Persistence: RDBMS: JDBC
Example: Persistence: RDBMS: JDBC
Example: Persistence: RDBMS: JDBC: Read
Use-Case Realization Refinement
Use-Case Realization Refinement Steps
Representing Subsystems on a Sequence
Example: Incorporating Subsystem Interfaces
Subsystem Responsibilities
Distributing Subsystem Responsibilities
Where Are You?
0 of .
Results for:
No results containing your search query
P. 1
Chapter 1

Chapter 1

Ratings: (0)|Views: 36 |Likes:
Published by preeti198615

More info:

Published by: preeti198615 on Aug 12, 2010
Copyright:Attribution Non-commercial


Read on Scribd mobile: iPhone, iPad and Android.
download as PPT, PDF, TXT or read online from Scribd
See more
See less





You're Reading a Free Preview
Pages 7 to 30 are not shown in this preview.
You're Reading a Free Preview
Pages 37 to 111 are not shown in this preview.
You're Reading a Free Preview
Pages 118 to 135 are not shown in this preview.
You're Reading a Free Preview
Pages 142 to 144 are not shown in this preview.
You're Reading a Free Preview
Pages 151 to 302 are not shown in this preview.

You're Reading a Free Preview

/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->