Overview
This course teaches proven real-world techniques to meet the biggest challenge in the software development community - building quality systems which fulfill your requirements, and delivering them on time. The focus of the course is to give you the practical skills that are most critical in building well designed software systems. It is extremely hands-on and applied, as well as giving you the formal knowledge you need to be fully conversant in this important area.
Participants will finish this course with a thorough understanding of what OOAD is (and is not), what are the techniques and choices that are available, how to use the techniques, and most importantly, when to use a particular technique to best effect, and when not to use it (e.g. - to avoid “analysis paralysis”). Software built using these techniques has a very high success rate industry-wide.
The course focuses on three areas:
Concepts : OO concepts & best practices
Notation: OO diagramming notation (UML)
Process: Process of developing OO systems
Each area is introduced individually for clarity, and then all three are brought together with added depth in the context of a group project. The group project gives participants the chance to apply what they have learned, and also reflects the team environment most people are working in.
The course includes coverage of the most useful tools that exist today, including: Using Unified Modeling Language (UML) to document designs, documenting requirements with Use Cases, static and dynamic system modeling, software processes (Unified Process/RUP/Agile), Design Patterns, and coverage of best practices in software development.
Hands-on:
50% hands-on, 50% lecture
Supported Platforms:
Platform Neutral
Skills Gained:
Concepts and Notation
- Understand basic OO concepts such as types, inheritance & interfaces, & know how to use them
- Understand OO analysis and design and its difference from structured design
- Develop a gut feel for OO do’s and don’ts
- Utilize OO architectural and design patterns
- Be familiar with the Unified Modeling Language (UML) diagrams
- Use the UML as a modeling and communications tool
- Create Use Cases to document requirements
- Create a static conceptual model of your system
- Create a dynamic behavioral model of your system
- Use Design Patterns to refine your model
Process
- Understand what a software development process is and why it is important
- Understand the industry standard processes including Unified Process/RUP and Agile Processes
- Design a software development process that fits the ceremony and complexity of your projects
- Utilize the steps of the process to produce better software
- Understand what NOT to do
Course duration
5 Days
Course outline
Session 1: Introduction to OOAD
- Intro: Fields of Study
- Object Orientation Overview
- Object Oriented Concepts
- Stating the Case for Object Orientation
- Labs: The OO Paradigm, Object Oriented Concepts
Session 2: Unified Modeling Language (UML)
- Unified Modeling Language Defined
- Static Diagrams
- Use Case, Class, Package, Component, Deployment
- Dynamic Diagrams
- Collaboration, Sequence, State Chart, Activity
- Labs:Class Diagram, Collaboration/Sequence Diagram, State Diagram
Session 3: The Software Development Process
- Software Development Process Overview
- Iterative Processes
- Agile Processes
- Unified Software Development Process
- Phases
- Iterations
- Disciplines (Workflows)
- Models
- Use Case Driven, Architecture Centric, Iterative and Incremental
- Labs: Civil Engineering vs. Software Development, Software Development Process, The Unified Process
Session 4: The Inception Phase
- Initial Planning
- Business Modeling
- Requirements Overview
- Labs: Identifying Risks, Domain List, Vision Statement, System Context Diagram, Stakeholder Analysis
Session 5: Introduction to Use Cases
- Overview
- Actors
- Use Case Details
- Create Initial Use Case Model
- Labs: Initial Actor List, Discovering Use Cases, Initial Use Case Model
Session 6: Additional Modeling
- Domain Modeling
- Discovering Your Types
- Technology Modeling
- Non-functional Requirements
- Labs: Domain Model, Non-functional Requirements
Session 7: Elaboration Phase
- Initial Planning
- Detailing Use Cases
- Elaborating Use Cases
- Refining Analysis Model
- Labs: Architectural Use Cases, Detailing Use Cases, Elaborating Use Cases, Identify Analysis Classes
Session 8: Elaboration - Design
- Dynamic Modeling
- Frameworks and Tiers
- OO Design Principles
- Labs:Collaboration Modeling Object Refinement
Session 9 - Introduction to Design Patterns
- Introduction
- Exploring a Simple Pattern - Iterator
- Design Pattern Background
- Labs:Examining Collection Traversal, Examining the Iterator Pattern
Session 10 - Design Patterns: A More Formal Approach
- The Gang Of Four Description
- The GOF Patterns
- Labs:Discussing the GOF Patterns
Session 11 - Moving Deeper Into Patterns
- Factory Method Pattern
- Strategy Pattern
- Decorator Pattern
- Template Method Pattern
- Labs:Using Factory Method, Using Strategy, Considering Decorator
|
