Evanetics - Use Cases to Code: Design

Use Cases to Code — Design with UML 2

Description

Based on the author's award-winning article series "Getting From Use Cases to Code", published at IBM developerWorks, this 3-day course focuses on the needs of programmers, designers and architects to understand and apply current best-practices in object-oriented design. Starting with basic concepts for newcomers, and moving to accepted design principles from Gamma, et al, Meyer, Martin and others, this course challenges students with real-world examples and exercises of object-oriented thinking and UML modeling within a design mindset. Students will learn the power of the Unified Modeling Language 2 (UML 2) for expressing object-oriented design concepts. The relationship between software architecture and software design is explored in detail, including select Gang of Four design patterns, Web architecture and Model-View-Controller, the evolution of Service-Oriented Architecture and Web Services, and how to develop a persistence layer for mapping classes to a Relational DBMS. Extensive hands-on exercises using two complete, and parallel, case studies assure that students see how a concept is modeled, and then have the opportunity to immediately apply and test their understanding.

At the end of the course, the student will be able to:

Transform UML analysis models to UML design representations.
Describe and apply the major design principles from Meyer and Martin.
Incorporate collection classes to represent design model multiplicities.
Identify the core “Gang of Four” Design Patterns and when to use each.
Describe the Model-View-Controller, and other, architectural patterns and when to use each.
Identify the major issues in persistence design, and constructing a persistence interface to RDBMSs.
Produce design models at the appropriate level to translate into code.
Develop both static and dynamic UML design models to specify a software system from multiple perspectives, and know when to use each type of model.
Articulate a common design mindset and vocabulary with other members of object-oriented projects.

Note: no computers or software modeling tools are used in this course. The emphasis is on thinking in an object-oriented manner, not on using a CASE tool. With the concepts gained in this course, the students may then apply them using any CASE tool of their choice.

Duration

Three days.

Prerequisites

Students must have a knowledge of UML 1.x or 2.x notation used in object-oriented analysis. Students who have taken the Evanetics Use Cases to Code: Analysis with UML 2 will be ideally prepared. Experience in software architecture or software design is desirable, but not mandatory.

Cost

$3,200 per course-day includes up to 12 students for on-site training. $300 per course-day for each additional student up to a maximum of 16 students.

Topics

Introduction

Object-Oriented Software Process

– A “Process Miniature” Of Project Design

The Design Discipline

– Goals of Design

– Inputs, Activities and Outputs

Introduce The Course’s Two Case Studies

– Example Case Study

– Student Exercise Case Study

– Review Analysis Models as Input to Design

The Unified Modeling Language

– Key Modeling Concepts For The Developer

– The 13 Diagrams In UML 2

– Structure/Static Diagrams

– Behavior/Dynamic Diagrams

– Overview of UML Modeling Syntax

Design Principles

– Abstract classes & Interfaces

– Recognizing Bad Design

– Meyer's Open-Closed Principle

– Martin’s Design Principles

– Separation of Concerns

UML Structural Design Modeling

Designing Class Association

– 1:1, 1:many, many:many relationships

– One-way and two-way Navigation

– Designing 1:1 associations

– Example: 1:1, two-way association

– Exercise: 1:1, two-way association

– Designing 1:many associations

– Example: 1:many, two-way association

– Collection Classes: Why you cannot live without them

– Exercise: 1:many, two-way association

– Designing many:many assocations

– Association Classes

– Example: many:many, two-way with association class

Designing Class Aggregation and Composition

– Containment & Ownership

– Structural & Semantic characteristics

– Deciding between aggregation & composition

– How their semantics determine design

– Example: Designing 1:many aggregation

– Exercise: Designing 1:many composition

Designing Class Inheritance

– The uniqueness of inheritance relationship

– Policy versus specifics

– The 4 Laws of Inheritance

– Signs of Good Inheritance/Bad Inheritance

– Accidental Inheritance

– Delegation

– Example: Designing Inheritance

– Exercise: Designing Inheritance

– Inheritance or Roles?

– Example: Modeling the “barkless” dog

Architecture and Design

– What is architecture?

– What is software architecture?

– Architectural Styles

– Architecture Patterns

– Layers, Pipes & Filters, Broker

– Frameworks

– Model-View-Controller (MVC) & The Observer Design Pattern

Web Application Architectures

– Web and MVC

– Service-Oriented Architecture

– Evolution from single-process/single address space to Web Services and SOA

Design Patterns

– The “Gang of Four” (GOF)

– Factory Method

– Façade

– Adapter

– Bridge

– Composite

– State

– Command

Wrapping Techniques

– Wrapping Techniques Using Façade

– Wrapping Shared Resources

– Wrapping Databases & Legacy Systems

– Wrapping the Wrapper

UML Behavioral Design Modeling

Design-level Squence Diagrams

– Transforming the Analysis Sequence Diagram

– Creating a MVC approach

– Example: Design Sequence Diagram for a use case scenario

– Exercise: Design Sequence Diagram for a use case scenario

– Updating the Class Diagram

Design-level State Machine Diagrams

– Transforming the Analysis State Machine Diagram

– Mapping Events, etc. to the Class Diagram

– Example: Design State Machine Diagram

– Exercise: Design State Machine Diagram

– Updating the Class Diagram

Representing Object State

– Enumerated state variables

– The GOF State Design Pattern

– Choosing the correct method

Persistence Design

– Data Modeling vs. Object Modeling

– Mapping Objects to RDBMS

– Mapping Classes, Objects

– Mapping Class Relationships

– Representing Inheritance

– Constructing a Persistence Interface

Course Wrap Up

Audience

Programmers, designers and software architects who need broad exposure to the principles and techniques common to object-oriented design.

For more information about this course or other courses please contact Evanetics at 1-803-781-7628.