UMBC Training Centers logo

Object Oriented Analysis and Design with UML and RUD

 

Course Description | Outline | IT Home

1. Overview of OOAD
* Topics
* A Brief History of Object Oriented Languages
* Tower of Hanoi
* Objects
* Objects Examples
* Objects Identification and Attributes
* Operations and Methods
* Object Relationship
* Encapsulation
* Classes
* Examples of Classes
* Examples of Object Type Identification in UML
* Inheritance
* Example of Inheritance
* Discovering Inheritance
* Polymorphism
* Example of Polymorphism
* Object-Oriented Programming Languages
* Topics
* Development Process
* The Rational Unified Process
* Inception Phase
* Elaboration Phase
* Construction Phase
* Transition Phase
* Software Development Life Cycle with the RUP
* Topics
* What is UML?
* History of UML
* UML 2 Architecture
* UML Infrastructure
* UML Superstructure (or UML)
* Object Constraint Language (OCL)
* UML Diagram Interchange
* Building Blocks of UML
* Things in UML
* Examples of UML Things
* Relationships in UML
* Examples of UML Relationships
* Diagrams in UML
* Classifier in UML
* Examples of UML Classifiers
* Common Mechanisms in UML
* Common Mechanisms in UML cont
* Examples of UML Extensibility
* Advantages of UML
* Summary

2. Requirements Workflow
* Topics
* Requirements Workflow
* What Is A Requirement?
* Requirements Gathering
* What Is Requirements Management?
* Requirements Management
* Timing of Requirements Workflow
* The Cost Of Requirement Errors
* The Game Plan Towards Building Quality Software
* Problem Analysis and Understanding User Needs
* Problem Analysis Steps
* Business Models
* Gather Requirements
* Interviewing
* Requirements Workshop
* Brainstorming
* Brainstorming- Idea reduction
* Storyboarding
* Use Cases
* Prototyping
* Requirements and the Unified Process
* Recall: Inception Phase
* Example of Use Cases
* Recall: Elaboration Phase
* Example of a Use Case Diagram
* Delivery

3. Use Case Analysis
* Topics
* Use Cases
* Benefits of Use Cases
* Classifying Use Cases
* Levels of use cases
* For use case modeling
* Use Case Modeling
* Use Case Modeling Steps
* Step 1 - Scope
* Lists used to manage scope In/out list
* Step 2 - Actors
* Actor Notation
* Finding Actors
* Finding Actors - continued
* Step 3 - Goal List
* Step 4 and 5 Finding Use Cases
* Sections Of A Use Case
* Documenting Use Cases
* Use Case Notation
* Action Sequence
* Use Case Relationships
* Time Schedule Application
* Case Study
* Case Study Time Schedule Management
* Use Cases Time Schedule Management
* UC01 Add a new appointment
* Use Case Diagram
* Time Schedule Use Case Diagram

4. Analysis Workflow
* Topics
* Analysis Workflow
* Motivation
* Analysis Deliverables
* Good Analysis Characteristics
* Analysis in the Rational Unified Process
* Analysis Workflow Steps
* Class Analysis
* What is an Analysis Class?
* Analysis Class Relationships
* Use Case Analysis
* Architectural Analysis
* Packages
* Package practicality
* Post Analysis

5. Class Identification
* Topics
* Identifying Classes
* Entity Class
* Control Class
* Boundary Class
* A Good Class
* A Good Class cont'd
* Bad Classes
* Finding Classes and their Relationships
* Noun/verb Analysis
* Noun/verb Analysis example
* Refine
* CRC Cards
* What is a Responsibility?
* What is a Collaboration?
* Identifying Classes Using CRCs
* CRC Cards An Example
* Class Diagram
* Class Notation in UML
* The Name Compartment
* The Attribute Compartment
* The Operation Compartment
* Translating CRC Cards to a Class Diagram
* The Scheduling System
* UC-01 Classes
* The EmployeeInfo Class
* Object Diagram
* Object Notation in UML
* Object Links and Messages
* Message Notation
* Link Types
* Examples of Object Links

6. Class Relationship Analysis
* Topics
* UML Diagrams
* Class Diagram
* Object Diagram
* Types of Class Relationships
* Identifying Class Relationships
* Examples of Relationships in UML
* Class Association Relationship
* Class Association Relationships in UML
* Reading Class Associations
* Multiplicity
* Reading Multiplicity
* Aggregation
* Aggregation An Example
* Composition
* Composition An Example
* Qualification
* Qualification An Example
* Association Class
* Association Class An Example
* Class Diagram Multiplicity and Ordering
* Class Diagram Operations Compartment
* Class Diagram Interface Notation
* Class Diagram Combining Interface Notations
* Class Diagram Object Relationships
* Package Diagram

7. Object State Analysis
* Topics
* Object State
* UML and State
* Object States
* State Machine Diagrams
* State Notation in UML
* Start and End Points of a state Diagram
* State Transitions
* Types of Triggers
* Signals
* Call Trigger
* Time and Change Triggers
* Substates and Superstates
* Concurrent States
* State Machine Diagram
* Usefulness
* State Diagram Example

8. Object Activity Analysis
* Topics
* Activity Analysis
* Object Activities
* Activity Diagrams
* Activity Notation in UML
* Initial Nodes and Activity Final
* Activity Transitions
* Conditional Flow
* Branch
* Example of a Branch
* Merge
* Parallel Activities
* Fork
* Join
* Synchronization of Parallel Transitions
* Signals
* Time Signals
* Accept Signals
* Partitions
* Partitions An Example
* Pins and Transformations
* Pins
* Transformations
* When to Use Activity Diagram
* Interaction Diagrams
* Sequence Diagram
* Sequence Diagram Notations
* Sequence Diagram Notation
* Message Notation
* Sequence Diagram Frames
* Sequence Diagram Frames - Conditional Messages (alt)
* Sequence Diagram Frames - Conditional Messages (opt)
* Sequence Diagram Frames Loop Messages (loop)
* Sequence Diagram Frames - Nesting
* Sequence Diagram Frames - Interaction Occurrences
* To Draw a Sequence Diagram
* Use Case Realizations
* Communication Diagram
* Communication Diagram An example
* Using Interaction Diagrams

9. Design Workflow
* Topics
* Analysis and Design
* Design Time
* Design in RUP
* Design vs. Analysis Model
* One Model Or Two?
* Design Workflow
* Design Classes
* Design Class Refinement
* Class Removal
* Refining Relationships
* Use Case Design
* Construction

10. Object Design
* Topics
* Object Design
* Generalization
* Root and Leaf Classes
* Abstract Class and Operation
* Generalization an Example
* Modeling with Generalization
* Modeling with Encapsulation
* Visibility of Features
* Owner Scope
* Friendship
* Value Containers
* Types
* Interfaces
* Interface Modeling
* Interface Modeling an Example
* Roles
* Modeling with Types, Interfaces and Roles
* Object Persistence
* Define a Base Class for Persistent Objects
* Representing Objects as Tables
* Object Serialization
* Active Objects
* Active Class an Example
* Communication of Active Objects
* Object Communications an Example
* Synchronization
* Template Classes
* Template Class and Instantiation an Example

11. System Design
* Topics
* System Design
* Collaborations
* Examples of Collaborations
* Modeling the Relationships of Collaborations
* Using Collaborations in the Realization of Use Cases
* Modeling the Realization of a Use Case
* Packages
* Visibility of Package Elements
* Relationship of Packages Generalization
* Relationship of Packages Import Dependency
* Modeling the Package Hierarchy of a System
* Systems and Subsystems
* Components
* Representation of Components in UML
* Stereotypes of Components in UML
* Examples of Component Types
* Component Diagrams
* Example of Component Diagram
* Deployment Diagrams
* Example of a Deployment Diagram
* Modeling the Architecture of a System
* Different Views of a System

12. Other UML Diagrams
* Topics
* UML Diagrams
* Composite Structure Diagram
* Timing Diagram
* State-as-Line Timing Diagram
* State-As-Area Timing Diagram
* Interaction Overview Diagram

13. The Software Development Process
* Topics
* Software Development Processes
* Risk Management
* What is a "risk"?
* Identify
* Analyze
* Plan and Manage
* Review
* Requirements Change
* Change Control Board
* Handling Change
* Incorporating Change
* Quality Assurance
* Testing
* Testing Categories
* UI Testing
* UI Testing - continued
* Common problems with error messages
* Common UI Errors
* Functional testing
* Types of testing
* Types of testing - continued
* Bugs
* Configuration Management
* Goals of Team Development
* Team Development Architecture
* Repository
* Version Control Systems
* Agile Modeling
* AM Values
* AM Principles
* AM Practices
* AM Practices Continued
* Using AM

14. The Software Development Project Life Cycle Using RUP
* Topics
* Software Development Methodologies
* Waterfall Development Methodology
* Iterative Development Methodology
* Iteration v.s. Waterfall Process
* Low Ceremony/High Ceremony
* Comparison of Some Software Methodologies
* Spirit of RUP: Well-Defined Software Engineering
* Two Dimensions of the RUP Process
* Dynamic Dimension of RUP: Lifecycle Phases & Milestone
* Static Dimension of RUP: Modeling Elements
* Static Dimension of RUP: Disciplines
* Typical RUP Roles
* Spirit of RUP: Iterative & Risk-Driven Approach
* The RUP Iteration
* Spirit of RUP: Customizable and Configurable Process
* Inception Phase
* Inception Phase cont
* Develop a Vision Document
* Develop a Vision Document: An Example
* Develop System Overview
* Develop System Overview: An Example
* Plan the Project and Analyze Risks
* Plan the Project and Analyze Risks: An Example
* Plan the Project and Analyze Risks: An Example cont
* Elaboration Phase
* Elaboration Phase cont
* Develop Use Case and Domain Object Model
* Develop Executable Architecture
* Construction Phase
* Construction Phase cont
* Organize Teams Around Architecture
* Example of Construction Iterations
* Transition
* Transition cont
* Elaboration Phase cont
* Examples of a RUP Development Lifecycle
* Typical Time & Resource for a RUP Development Lifecycle
* Multiple Development Lifecycles

15. Refactoring
* Topics
* What is Refactoring
* An Example
* Why We Need Refactoring
* Principles of Refactoring
* Principles of Refactoring cont
* Steps for Performing Code Refactoring
* Anti-patterns
* Anti-patterns cont
* Moving Features Between Objects
* Move Method
* Extract Class
* Introduce Local Extension
* Dealing with Generalization
* Pull up Field/Pull up Method
* Push Down Field/ Push Down Method
* Extract Superclass
* Extract Subclass
* Composing Methods
* Extract Method
* Replace Method with Method Object
* Making Method Calls Simpler
* Rename Method
* Replace Parameter with Explicit Methods
* Introduce Parameter Object
* Encapsulate Downcast

16. Software Reuse
* Topics
* What is Software Reuse
* Example of Software Reuse
* Why Reuse Software
* How Software Assets Become Reusable
* Major Disciplines for Software Reuse
* Basic Techniques for Software Reuse
* Software Reuse in the Software Development Lifecycle
* Critical Factors to Successful Reuse of Software
* Techniques for Reuse Asset Management
* Techniques for Reuse Asset Management cont
* Techniques for Reuse Process Management
* Domain and Domain Specific Reuse
* Domain Model and Domain Architecture
* Domain Engineering v.s. Software Engineering
* Domain Identification
* Domain Analysis
* Domain Design

17. Design and Architecture Patterns
* Topics
* Patterns
* Example of Design Patterns
* Example of Architecture Pattern
* Factory Method
* Singleton
* Command
* Modeling the Structure Aspect of Command Pattern
* Modeling the Behavior Aspect of Command Pattern
* Facade
* Adapter
* Proxy
* Publish-Subscribe
* Modeling the Structural Aspect of the Publisher-Subscribe Pattern
* Modeling the Behavioral Aspect of the Publisher-Subscribe Pattern
* Three-tier Architecture
* Multi-tier Architecture
* Model-View-Controller
* Model-View-Controller Framework