Object Oriented Analysis and Design with UML

A thorough grounding in traditional and modern approaches to OOAD

Overview

This course gives delegates a thorough grounding in traditional and modern approaches to OOAD. The primary goal is to enable delegates to create designs which can be translated into efficient and maintainable implementations. As the course progresses delegates also learn when and how to draw and apply the UML 2 diagrams. The course is workshop based, with delegates producing designs for sample problems and then trying to realize them in code.

Outline

Introduction to OOAD

  • How OO emerged from procedural programming
  • Analysis is about discovery, design is about invention
  • Object Orientation and the Sapir–Whorf hypothesis
  • Class based vs prototype based OO languages
  • Smalltalk and ‘pure’ Object Oriented development
  • Compromises made in adapting OO for use in industry
  • Common principles shared across all modern OO languages
  • The fundamental importance of abstraction and encapsulation
  • Different ways of composing trees of linked objects
  • How inheritance and polymorphism simplify your designs

Moving from Requirements to Analysis

  • How requirements analysis affects OOAD
  • Comparing common approaches to requirements gathering
  • Brainstorming requirements documents using CRC cards
  • Evaluating candidate classes using UML sequence diagrams

The Theory Behind OOAD

  • Classic MVC
  • Open-Closed
  • The Law of Demeter
  • Dependency Inversion
  • Coupling and Cohesion
  • Liskov Substitution
  • DRY and YAGNI

Modeling the Clients Business Using Domain Driven Design

  • Why understanding the problem domain is crucial to good design
  • Creating a domain model which is framework independent
  • Identifing and modeling Entity, Value and Service classes
  • Partitioning the domain model and managing dependencies
  • Reviewing models and adapting them to changing requirements

Design Patterns Used in Analysis

  • Hiding object creation using Factory and Builder
  • Representing algroithms using Strategy, Command and Visitor
  • Abstracting persistence using Repositories and the DAO Pattern

Principles for Good Class Design

  • In general the more minimal the better
  • A class should represent a single abstraction
  • Favor composition over inheritance
  • A class should be indifferent to its environment
  • Clients should only care about the public interface
  • The interface should never expose implementation details
  • Adjacent method calls should be at the same level of abstraction
  • Query and state-change operations should be separate
  • Classes should be immutable whenever possible

Smells that Signal Bad Design

  • A small number of Superman classes
  • Classes with several MVC responsibilities
  • Poor partitioning and confused terminology
  • Unclear interfaces and inappropriate intimacy
  • Framework dependencies and speculative generality
  • Frequent violations of the Law of Demeter
  • Feature envy and overuse of accessors

Creating Fluent Interfaces

  • How Fluent Interfaces can simplify design
  • Using Method Chaining to create Fluent Interfaces
  • Fluent interfaces and internal Domain Specific Languages
  • Examples from mocking tools and scripting languages

Advice Specific to Java and C

  • Express dependencies between classes using interfaces
  • Use a dependency injection container to inject dependencies
  • Create unit and integration tests for each layer in the design
  • Use ORM frameworks and DAO’s for database access
  • Only use frameworks that are based on plain objects
  • Choose your web framework carefully

Heretical Approaches to OOAD

  • Situations when MVC isnt appropriate
  • The Naked Objects approach to user interfaces
  • Agile methodologies and Test Driven Design
  • Using Aspect Oriented Programming to enhance OOAD
  • Using meta-programming techniques in dynamic languages
  • Exposing class libraries as Domain Specific Languages
  • Mixing Functional and OO programming in Scala

Requirements

  • This course is designed for experienced programmers who have a clear understanding of basic OO concepts. Examples are drawn from a variety of languages, including Java, C# and Ruby. Exercises can be conducted using any OO language.

Sign up and stay in the loop

Be the first to know about upcoming workshops, courses, talks and events

Learn more

This course was great introduction to the Analysis and Design and will defiantly help me in the future when doing design work. Thank you for a great delivery.