Go to the Datasim Education BV homepage Datasim Education BV Datasim Education BV Datasim Education BV Datasim Education BV Datasim Education BV
Information request

Follow datasim on Twitter

Share this page

Object Oriented & Component Technology Training

Course Category: 

Component Oriented Design  - (code COD)

Generic and Multi-threaded Implementations

The goal of this updated and revised course is to design complex software system using modern object-oriented, generic and multi-threaded (parallel) design techniques. Starting from a high-level specification of the problem (from analysis) we then design it while taking account of the functional and non-functional requirements in the system. We take this specification and design in it in ever-increasing detail so that it can be implemented in a language such as C#, C++ or Java.

In particular, we design a system using object, generic and interface architectures and we support both parallel/multi-threaded and sequential programming models. Furthermore, we apply parallel design patterns (such as Producer-Consumer) as well as the GOF and POSA patterns (and their improved versions) to speed up the development process and improve design quality.

Major Topics in the Course

The following topics are discussed as a step-by-step process and they allow developers to design flexible and maintainable software systems using modern design techniques:

  • System decomposition into loosely-coupled components
  • The ability to design large, complex systems
  • Integration with existing systems
  • Interface, object and plug-and-socket architectures (OCA, ICA, PSA)
  • Extending Gamma (GOF) and POSA patterns for ICA and PSA
  • Multi-threaded and parallel design patterns
  • How to do COD in C++ and C#: implementation mechanisms


New course since March 2010

Course contents

Day 1: High-level Design

Overview of High-level Design

  • Mapping analysis to components and interfaces
  • Specifying the architectural type and style
  • Using system patterns to design systems

Choosing an Architectural Style

  • Pipes and filters
  • Blackboard and repository systems
  • Event-based, implicit invocation
  • Data abstraction and object-oriented organization
  • State transition systems

System Decomposition

  • Data and task decomposition
  • Grouping and ordering tasks
  • Data sharing
  • Design evaluation

Components and Interfaces

  • Component and interface definitions
  • 'Provides' and 'requires' interfaces
  • Conformance

Day 2: Core Design

Overview of Core Design

  • Choosing a connection architecture
  • Detailed component decomposition
  • Modelling component lifecycle

Object Connection Architecture (OCA)

  • Properties of object-oriented systems
  • ISA and HASA relationships
  • Disadvantages of OCA approach

Interface Connection Architecture (ICA)

  • Predicting system behaviour before it is built
  • Varieties of component/module specifications
  • Provided and required features
  • Data type compatibility

Plug and Socket Architecture (PSA)

  • Modelling complex topologies
  • Interface grouping
  • Services (plugs) and dual services (socket)
  • Refining communication detail without increasing complexity

Choosing an Architecture

  • Functional and non-functional requirements
  • Checklist of questions to determine OCA, ICA, PSA
  • Substitutivity of conforming components
  • Performance issues

Detailed Component Decomposition

  • Whole-part decomposition
  • Layered decomposition
  • Separation of data and UI: PAC and MVC models

Data Decomposition

  • Divide and conquer
  • Geometric decomposition
  • Recursive data pattern

Review of Core Design

  • Creating a Proof-of-Concept in an OO language
  • Conformance and Compliance
  • Component and class diagrams
  • Physical diagrams

Day 3: Implementation Mechanisms

Overview of this Stage

  • Gamma (GOF) patterns using OCA, ICA and PSA
  • Multi-threaded and parallel design patterns
  • Specific examples in C++ and C#
  • Test cases and applications

Gamma Pattern Overview: which patterns are most useful?

  • Object factories and Builder patterns
  • Flyweight pattern with reference counting
  • Bridge, Composite, Proxy
  • Command, Strategy, Observer, Visitor

Generic Gamma Patterns

  • Implementing GOF in C++ and C#
  • Using boost libraries (Function, Signals)
  • GP approach versus OOP: which one to use and when
  • Test case: a generic Command pattern

Performance Tuning

  • Avoiding unnecessary object creation
  • Loop fission and fusion
  • Dynamic polymorphism versus static polymorphism (CRTP pattern)
  • Shared versus private data

Multi-threaded Patterns

  • Master/worker
  • Fork and join
  • Shared queue/producer consumer
  • Loop parallelism

Languages and Libraries

  • Threads, synchronization and notification
  • OpenMP and boost Thread
  • C# Thread and parallel libraries
  • Speedup, performance and troubleshooting

The student should have a number of years experience in at least one modern OO language (such as C#, Java, C++) and project experience in a production environment is an asset.

Who should attend?
Developers and designers who wish to design robust and flexible software systems using modern OOP. GP and parallel design methods. The percentage theory/practice is 65:35 and the exercises range from examples to show understanding of the topics up to component and application level.

Duration, price, date, locations
Course duration 3 days
Price Euro 1425.-- ex. VAT
Euro 1724.25 inc. 21% VAT
Date and location Dates available on request

It is also possible to organize this course at your company premises (the in-company option). If you have any question, please contact our Datasim office.

Share this page

Contact and Profile
Registration form
Course Dates