object oriented programming - syllabus for 5 day course

objectives

- learn the two fundamentals of object oriented programming: modelling and patterns
- understand what does and does not go to make up a pattern
- understand the beneficial role of patterns in all aspects of development
- learn and use common patterns for object-oriented design
- gain enough competence in object-oriented analysis and design (OOAD) to tackle a complete OO project
- acquire UML, a common language for talking about requirements, designs, and component interfaces
- understand the main principles of good OO design
- understand what major tasks are appropriate to developing OO models and software

overview
Object oriented programming languages provide a powerful tool for building flexible and extensible software components.  However, maximum benefits are gained only if the software is appropriately designed. The choice of classes, and the distribution of tasks between the objects, is of crucial importance.  Nontrivial systems include many recurring design problems whose solutions are commonly repeated from place to place, and from programmer to programmer.  The essence and basic structure of a solution may be repeated many times, even though the realization is different in each case.  Patterns offer a technique for capturing good design, and offer a quick way to become proficient at Object Oriented design.  This course introduces patterns from the ground up, presenting principles as well as concrete examples in UML and Java.  It develops understanding through lectures, discussion, and some exercises to reinforce the concepts by putting them into practice.

The course is suitable for developers familiar with Java, wishing to gain design and analysis skills as well as experience in using patterns.  The course is presented by one of our senior consultants, each of whom has at least ten years' experience in object oriented software development, and at least three years' experience as a trainer and consultant in a diverse range of application areas.  At the detailed design level, we will use pattern examples in Java.  Ideally this training would be preceded by the course: design and develop Java applications.

content

1. OO design Introducing the principles of OO design - aims of OO design - OO designs are based on the 'real' world - what's an object? - distribution of responsibilities - objects, classes, messages and methods - decoupling for flexible software - interfaces and the 'implements' relation - types and object specifications - class extension 2. OO analysis - layering design decisions: abstraction - exposing gaps and inconsistencies: precision - traceable designs: continuity - clear, ready communication: a language for design - a vanilla process: development from scratch (brief overview) - business modelling: concepts and tasks - system requirements models - responsibilities and collaborations - persistence, GUI, distribution - coding in an OO language - component-based design (brief overview) - robust, flexible software - components and interfaces - components kits and architecture - component and reuse culture - patterns (brief overview) 3. Modelling with UML This section covers techniques of identifying business concepts and tasks, and introduces relevant parts of UML along the way. - static models - objects, types, attributes, snapshots - subtypes - dynamics - use-cases and tasks - event charts - state charts - building a business model - finding use-cases - connecting use-case and class views - the dictionary - UML notation review - uses of business model - architecture of business process - context for software requirements - basis for component interface definition - documentation style 4. Analysis and requirements This section deals with the specification of requirements for a software component, application, or complete system.  More modelling patterns and techniques are investigated. - system context models - high-level operation specs - state charts for system models - meaning of 'model' - how to start abstract and get more detailed - event charts: horizontal and vertical expansion - elaborating models - relating the levels of detail - building a system spec - system context - defining system use-case goals - modelling patterns 5. Basic design The key principle of OO design is assigning responsibilities and designing collaborations. - separating core from GUI, persistence, and other layers - selection of control objects - designing system operations with messages - decoupling, extensibility, reusability - CRC 'cards' - dependencies and visibilities - the class dictionary - translation to code 6. Patterns - basic form - problem and forces - solution and consequences - an example: the Composite pattern - documenting patterns - documenting pattern use 7. Organizing patterns - pattern catalogues - the "Gang of Four" - "Pattern-Oriented Software Architecture" (POSA) - strategic versus tactical patterns - review of organizational patterns - review of analysis patterns - review of architectural patterns - review of design patterns and idioms - pattern languages 8. Delegation patterns - basic principles - Adapter and its variations - Proxy - Bridge - Manager 9. Domain coupling The linkage of the 'core(s)' to presentation, persistence, and other layers. - GUIs - reification of use-cases in UI objects - persistence and proxies - building atop object and relational DBs - networks and layering 10. Decoupling patterns - layers - Interface Decoupling - Role Decoupling - Observer - The Law of Demeter 11. Creational patterns - Factory Method - Disposal Method - Singleton (and issues) - Cloning - Copy Constructor 12. Value patterns - value-based programming - Whole Value - Value Object - Enumeration Values - Class Factory Method - Copied Value - Immutable Value - Mutable Companion 13. Functional patterns - Named Selector - Command - Command Processor - Command Adapter - Composite Command - Composite Exception - Block - Active Object 14. Sequential patterns - Combined Method - Finally for Each Release - Execute-around Method 15. Iteration patterns - Iterator - Combined Iterator - Enumeration Method 16. Selection patterns - Null Object - State-based Selection - Objects for States (State) - Collections for States 17. OOAD process review This section reviews the tasks and deliverables involved in a typical object-oriented development project. - the main tasks and artefacts - business/conceptual modelling - specification/requirements modelling - architecture - design, Implementation - integration and test - short-cycle development - spiral model - phased development - role of prototyping Please note, when taught at your site, this course is customizable.  Modules can be adapted, removed, added from other courses, or even created.

timings
Day 1
1. OO design
2. OO analysis
3. Modelling with UML
Day 2
4. Analysis and requirement
5. Basic design
6. Patterns
Day 3
7. Organizing patterns
8. Delegation patterns
9. Domain coupling
10. Decoupling patterns
Day 4
12. Value patterns
13. Functional patterns
14. Sequential patterns
Day 5
15. Iteration patterns
16. Selection patterns
17. OOAD process review