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

Design Patterns Training

Course Category: 

Design and System Patterns Revisited; A mullti Paradigm Approach  - (code DSPR)

The goal of this five-day advanced hands-on course is to design large and complex software systems using established and modern software tools and languages. We integrate system decomposition, system (POSA) patterns and design (GOF) patterns to allow us to design software systems of arbitrary complexity as a collection of loosely-coupled components with well-defined interfaces. We decompose a system based on tasks or on data, depending on the application. We note that this decomposition is applicable to both singe-threaded and multi-threaded applications. In the latter case we have identified tasks that execute concurrently.

Once system decomposition has taken place we then execute a detailed design of each component in the system. This entails creating blueprints that can be used as input to the implementation phase in languages such as C++ and C#. Here we apply POSA and some GOF patterns in order to satisfy the system's functional and non-functionality, for example Efficiency, Reliability, Functionality and Maintainability. We have great flexibility in choosing which architectural model to use (for example, object, interface or socket-based) and whether to choose a proof-of-concept prototype or a software product that has a lifetime of five years or more, for example.

The last phase is concerned with the implementation of the blueprints from the detailed design phase. We introduce the language features, libraries and language idioms that allow us to implement the blueprints in code. At this stage we can use a combination of object-oriented, generic and functional programming models.

Subjects Covered

  • System decomposition of large systems
  • Modern multi-paradigm development approach
  • Extending and improving POSA and GOF patterns
  • Component-based and object-oriented design
  • Design of multi-threaded and parallel software systems
  • Incorporating C++ 11, Boost and C# libraries to speed up development
  • Relevant examples and applications

What do you learn?

  • A defined software process A-Z
  • Design and implement complex software systems
  • Modern architectural design
  • Multi-paradigm POSA and GOF patters
  • Fine-tuning the application to the system requirements
  • Seamless integration between design blueprints
  • Optimal use of libraries: write less code and achieve more

The percentage theory/practice is 75% / 25%. You can choose the language to use for the exercises (our own preferences are for C++ and C#.)


Course updated September 2014

Course contents

Part I: Systems and System Decomposition

System Scoping

  • System goals and core processes
  • Functional and non-functional requirements
  • External systems and their interfaces
  • System context diagrams

System Decomposition

  • What is system decomposition and why is it important?
  • Data and task decomposition
  • Parallel software systems
  • System and subsystem responsibilities
  • Creating extended context diagram

An Introduction to Domain Architectures (DA)

  • Families of applications and analogical reasoning
  • The five major domain categories (MAN, RAT, MIS, PCS, ACS)
  • Using DAs to kick-start system scoping and subsystem discovery
  • Determining which DA (or combination of DA) is suitable for your system

Programming-in-the-Large versus Programming-in-the-Small

  • Structuring large collections of modules
  • Implementing single modules
  • Module Interconnection Languages (MIL)
  • Information Hiding

 Advantages of top-down Approach

  • Project management tool
  • Communication tool
  • Design tool
  • Clear, concise documentation

An Introduction to Software Connection Architectures

  • Object Connection Architecture (OCA)
  • Interface Connection Architecture (ICA)
  • Plug and Socket Architecture (P&S)
  • Synchronous and asynchronous communication

Part II: Component Identification and Specification

High-level Design and Specification of Software Components

  • The inside and the outside of a component
  • Components and Services
  • From Services to Interfaces: data and behavior
  • Data structures
  • Exception handling

Interfaces and Contracts

  • Provides and requires interfaces
  • Contracts, preconditions and postconditions
  • Interface standardisation

Detailed Design of Software

  • Components Component coupling and cohesion
  • Single Responsibility Principle (SRP)
  • Designing associations, aggregations and composition
  • Complexity Analysis and efficiency
  • Generic components

 Describing and Documenting Software Components

  • UML component diagrams
  • Statecharts and component contracts
  • Class diagrams

 Requires-Provides Interfaces and Component Contracts

  • Policy-based design (requires and provides interfaces)
  • Higher-order functions, lambda functions
  • Signals and callback mechanisms
  • The Delegate mechanism

 Implementing Components in C#

  • C# classes and interfaces
  • An Introduction to .NET Delegates
  • Lambda functions
  • Assemblies and namespaces
  • Applications of Delegates

Implementing Components in C++ and Boost C++ Libraries

  • Higher-order functions
  • Signals and callbacks
  • Lambda functions
  • Combining the object-oriented and generic programming models

Part III: POSA Patterns Revisited

An Overview of System Patterns (POSA)

  • Categories of POSA patterns
  • Architectural patterns
  • Interactive systems
  • Management and Communication patterns
  • Post-analysis of POSA patterns

Migrating from POSA to new Paradigms

  • What are the attention areas?
  • From Domain Architectures to POSA
  • Designing components and their interfaces
  • Pattern selection
  • From POSA patterns to GOF patterns

Presentation-Abstraction-Control (PAC)

  • The importance of PAC
  • Discovering PAC models from Domain Architectures
  • Designing PAC models
  • PAC versus Model-View-Controller (MVC)
  • Relationship with other Patterns

 Layers Pattern

  • Levels of abstraction
  • Designing layered systems: the steps
  • Layer interfacing and decoupling
  • Application areas

Proxy Pattern

  • Categories of proxy
  • Applications and advantages
  • Implementing proxy in C++ and C#
  • Relationships with other patterns

Command and Command Processor Patterns

  • A review of the GOF and POSA Command
  • A critique of OO Command
  • Command: a new design
  • Command Processor and Multi-threading solutions

An Overview of Design Patterns (GOF)

  • Categories of GOF patterns
  • Strengths and weaknesses of GOF patterns
  • The top five useful patterns
  • Post-analysis of GOF patterns

Migrating from GOF to new Paradigms

  • Background and bottlenecks
  • Why a multi-paradigm approach resolves problem
  • Design approach
  • Guidelines

Test Case: Command Pattern

GOF Command: Analysis

  • Proliferation of classes and objects
  • Performance issues (subtype polymorphism)
  • The OO single paradigm bottleneck
  • Extendibility issues

Next Generation Command

  • Shifting focus from objects to functions
  • Using C++ and C# universal function types
  • Multi-paradigm clients
  • Parallel processing
  • Integration with Command Processor pattern

Notification Patterns

  • Loose-coupling and notification
  • Using FP and Boost Signals(2)
  • Observer revisited
  • Propagator pattern

Portability and new Patterns

  • Using Boost Function and Boost Bind to promote information hiding
  • Structural patterns new style
  • Behavioural patterns new style
  • Creational patterns new style

Part IV Design of Parallel Systems

An Introduction to Parallel Systems

  • Background and Jargon of parallel computing
  • Parallel architectures
  • Shared memory and distributed systems
  • Speedup and efficiency

System and Data Decomposition of Parallel Systems

  • Decomposition patterns
  • Dependency graphs and load balancing
  • Task and data decomposition; grouping and ordering tasks
  • Shared data pattern

Parallel and Multithreaded Algorithms

  • The Algorithm structure decision tree
  • Task parallelism pattern
  • Divide and conquer pattern
  • Geometric decomposition pattern

Parallel Design Patterns

  • What are the special issues?
  • Master/Worker
  • Shared Data and Shared Queue
  • Fork/Join
  • Loop Parallelism

 Implementing Parallel Design Patterns in C++ and C#

  • Thread classes
  • Mutex, semaphore, condition variable
  • Synchronisation and notification mechanisms
  • The libraries PPL and TPL

Parallel Libraries

  • C++ 11 concurrency
  • OpenMP
  • PPL and TPL

This is not a beginners course. We assume that you are an experienced developer/designer with in-depth knowledge of C++, C#, Java or some other high-level language. Project experience is also needed because then you realise that building adaptable software systems is vital for the organization.

Who should attend?

Senior software developers, designers and architects who are interested in designing and implementing complex software systems.

This course is also useful for technical project leaders; it becomes possible to estimate, plan and monitor projects due the specific nature of the design process in this course.

Duration, price, date, locations
Course duration 5 days
Price Euro 2250.-- ex. VAT
Euro 2722.50 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