Course: Object-Oriented Analysis and Design with UML (and, optionally, Rational Rose)

Duration: 3 to 5 days (depending upon your objectives and requirements)

Delivery: Presentation and discussion with hands-on exercises delivered on-site. Optionally, can include:

• a workshop based upon general topics or real, project-specific work
• an introduction to Rational Rose and using Rose to complete the exercises

Audience

The core audience roles include:

• Software Architects
• Software Designers
• Software Developers

Other roles that can benefit include:

• Business/Requirements Analysts: especially the first 2 to 2.5 days
• Project Management, Customers and other Stakeholders: especially the first 1 to 2 days
• Senior Management: especially the first 0.5 to 1 day

Price (in USD): The billing for seminar and workshop sessions is computed as follows:

• $285/student/day for students 1 through 12
• $240/student/day for students 13+
• minimum billing for 6 students
• travel and living expenses, at cost
• pro-rated billing for pre-arranged partial-attendance by Managers, etc.

Overview

A 3 to 5 day seminar that starts with the Unified Process and progresses through requirements analysis using Use Cases and how to use these requirements to drive the discovery of an object-oriented software architecture, in a very repeatable way. The session then presents various aspects of object-oriented design, working up to producing class diagrams.

The seminar teaches and uses the basics of the Unified Modeling Language (UML) and is presented within the context of the Unified Process. Optionally, a 1-day Introduction to Rational Rose and/or Workshop topics can be woven into the seminar and exercises.

This seminar is an excellent choice for projects/teams wanting a comprehensive view of OOAD. Although it's been said that it's "a little like drinking from a fire-hose," it is the best way to get a "gestalt view" of vital OOAD topics. For the uninitiated, it provides the kind of background that accelerates becoming proficient. For people who've been using various aspects of OOAD for some time, the common comment is "Wow ... that really fit everything together and filled in a whole bunch of gaps!"

The material is more weighted to the earlier-lifecycle aspects (analysis and high-level design) because these are the areas where projects tend to have the most difficulty and are the areas where deficiencies are the most costly. As such, this material is completely technology agnostic. The concepts and strategies apply regardless of today's, or tomorrow's, computer languages, OS vendor, etc.

Available Modules

The following table presents some suggested content mixes that have proven to work well:

Description	Duration	Content (Included Modules)
Abbreviated training — limited to lecture and discussion (no exercises, just review of example problem solution), often followed by on-site consulting and/or off-site reviews.	3 Days	Unified Process, UML, Use Cases, Object Technology, Use Case Driven Analysis and Design, Software Architecture and Class Design
Training for projects/teams wanting a comprehensive view of OOAD, sometimes followed by on-site consulting and/or off-site reviews.	4 Days	Unified Process, UML, Use Cases, Object Technology, Use Case Driven Analysis and Design, Software Architecture and Class Design
Training for projects/teams that have done some Use Case work but are struggling or finding that they've developed "useless cases" that don't add much value. This is sometimes followed by on-site consulting and/or off-site reviews.	5 Days	Unified Process, UML, Use Cases, Object Technology, Use Case Driven Analysis and Design, Software Architecture and Class Design

Unified Process
0.5 to 0.75 Day (varies depending upon audience focus and discussion)

• The Rational Unified Process (RUP) : an assembly of industry best practices
• Practice 1 : Develop Iteratively
• Practice 2 : Engineer/Manage Requirements
• Practice 3 : Use Component Architectures
• Practice 4 : Modeling Visually (using UML)
• Practice 5 : Continuously Verify Quality
• Practice 6 : Manage Change
• RUP Lifecycle Phases
• Habits of Successful Projects

UML - The Unified Modeling Language
(an introduction) - 0.15 Day

• Overview
• The UML Diagrams
• Working with UML

Specifying System Behavior via Use Cases
1.0 to 1.5 Days (varies depending upon audience focus and discussion)

• Introduction
• Requirements
• Use Case Fundamentals
• Creating Use Cases
• Capturing Detailed Requirements
• Simple Example
• Additional Use Case Concepts
• Using Use Cases (includes a free Use Case style guide)
• Use Case Exercise - 0.5 Day

Introduction to Object Technology
(using UML notation) - 0.5 Day

• Basic Principles of Object Technology
• Objects
• Classes
• Operations
• Attributes
• Generalization
• Polymorphism
• UML Stereotypes
• UML Properties
• UML Notes
• UML Packages
• UML Interfaces
• UML Components
• UML Subsystems
• Strengths of Object Orientation
• Review/Quiz
• Relationships
• Association Relationship
• Multiplicity and Navigation
• Aggregation Relationship
• Composition Relationship
• Dependency Relationship
• Generalization (Inheritance) Relationship
• Single Inheritance
• Multiple Inheritance
• Constraints
• Review/Quiz

Use Case Driven Analysis and Design - From Use Cases to Classes
0.5 to .75 Day (varies depending upon audience focus and background)

• Artifacts Overview
• Identify Classes from Use Case Flows
• Sequence Diagrams
• Collaboration Diagrams
• Use Case Driven Analysis and Design Steps
• Understanding the Relationships
• Creating an Initial Class Diagram

Software Architecture
0.25 Day

• UML's "4+1 Views" of Software Architecture
• The Logical View: Modeling Organized Class Structures
• The Implementation View: Modeling the Development Environment
• The Process View: Modeling Concurrency
• The Deployment View: Modeling Distribution and Configurations

Class Design
0.25 Day

• Class Design: Initial Sources
• Class Refinement
• Class Persistence vs RDBMSs
• Utility Classes
• Defining States
• Refining Attributes
• Refining Multiplicity
• Parameterized Classes
• Refining Generalization
• Handling Non-Functional Requirements

Introduction to Rational Rose
0.8 Day (inserted when doing the exercises)

• The Rose Model, Model Elements and Diagrams
• basic concepts and configuration
• the model – modeling elements and diagrams
• creating and managing model elements
• Use Case Diagrams
• model-element specifications
• actors, use cases and relationships
• Interaction Diagrams
• sequence diagrams
• objects and messages
• focus of control
• interconnecting diagrams
• collaboration diagrams
• Class Diagrams
• classes, operations and attributes
• class relationships
• understanding context
• controlling class presentation format
• editing operations and attributes
• editing relationship navigavility and multiplicity
• Activity and Statechart Diagrams
• Component Diagrams
• Deployment Diagrams
• Model Organization
• Publishing a Model
• Common Issues

Workshop
0.5 to 2 Days

• An Interactive Review of Project Work and/or Work on Actual Project Requirements or Architecture
• Topics based upon current project/team issues (after pre-review of prior work done or attempted)

I'm interested, what's the next step?

Learn more about the process or simply contact us to let us know what you're currently thinking or what additional information you'd like and you'll get a reply, normally via email the same working day.