Software

Systems & Software Academy

Intro

This course is intended for software engineers and software architects and fits an agile process that they may have deployed in their organization.

The proposed training program focuses on the application of design patterns from the Gang of Four to satisfy non-functional requirements and to obtain a software architecture that can withstand software evolution in an emergent manner. The basic idea that permeates the course is that non-functional improvements are made by transforming and refactoring a software application using patterns. An important aspect is the shaping of component interfaces in a way that makes integration easier by guaranteeing backwards compatibility with existing client code. 

The program offers a healthy mix of theory and exercises. In the exercises the participants must select a pattern to improve an existing design on a particular non-functional aspect. Typical such aspects are scalability, reuse, extensibility and portability. The last half day of the course addresses various architectural patterns from Buschmann et al. and shows how these architectures can be realized using the GoF design patterns by making stepwise transformations.

Objective

After successful completion of the course, participants will:

  • have understanding of the architectural relevance of patterns;
  • have insight in the way patterns can be applied to take into account various kinds of non-functional requirements;
  • have knowledge on the GoF patterns;
  • have obtained some skills in recognizing situations where patterns can be applied;
  • knowledge of decision criteria in applying design patterns;
  • understand some of the pitfalls that pattern application may pose;
  • understand OO principles behind patterns: meta patterns and using object orientation to localize variability;
  • understand how to use scrum principles in combination with patterns as an architect, to develop software using emergent architecting and to support productivity, quality, continuous improvement, continuous integration and continuous deployment;
  • understand how to prevent and reduce technical debt in agile projects.

Intended for

Software architects and software developers.

The participant should have insight in the background of object-oriented techniques, have a working knowledge of a common object oriented programming language (C++, Java, C#), have knowledge of syntax and semantics of most-used UML modeling concepts.

The course requires the capability to abstract from details in the source code using UML class diagrams. Regularly example program-fragments will be shown. The course is accompanied with source code in Java as well as the executables related to the case studies.

Course schedule
09-11-2020
09:00 - 17:00
10-11-2020
09:00 - 17:00
11-11-2020
09:00 - 17:00
12-11-2020
09:00 - 17:00
Location Eindhoven
Duration 4 consecutive days
Score
8.2
(Average score of last 3 editions)
Price € 1,980.00 excl. VAT.
Keep me posted
Program

Day 1:

  • Patterns in the Scrum Development process;
  • Handling Technical debt, Emergent Architecting;
  • Supporting Continuous Integration, continuous deployment and release trains;
  • The architectural relevance of design patterns;
  • Patterns and modularity;
  • Patterns and non-functional requirements;
  • The application of patterns in an agile development process (Scrum);
  • Classification of patterns;
  • Examples of patterns (from GoF: Gamma et al.): Command, Abstract Factory, Bridge, Exercise (maintainability), Prototype, Composite, Observer, Exercise (scalability, reuse, extensibility), Scrum exercise.

Day 2:

  • Examples of patterns (from Gamma et al.): Exercise (continued), Guided discussion on interface design and component integration, Factory Method, Proxy, Strategy, Exercise (maintainability), Singleton, Adapter, Listener (and C# delegates), Scrum exercise (decoupling for portability).

Day 3:

  • Examples of patterns (from Gamma et al.): Mediator, State, Template Method, Exercise (state machines), Guided discussion on avoidance of deadlock and race conditions, Decorator, Flyweight, Visitor, Exercise (extensibility), Interpreter, Builder, Iterator.

Day 4:

  • Examples of patterns (from Gamma et al.): Exercise (reuse), Facade, Chain of Responsibility, Memento.
  • Architecture patterns (Buschmann et al.);
  • Realizing architectures using design patterns: Layers, Scrum exercise, MVC, Guided discussion on MVC, Broker, Guided discussion on Broker;
  • Conclusions.
Methods

Lectures, practical pencil and paper exercises and guided discussions. Teaching material: Copies of presentations, hand-outs of exercise solutions, executable example cases in Java (for later reference), book: "Design patterns: elements of reusable object oriented software" Gamma, et.al.

Language: English

Remarks from participants

"Clear, understandable, good balance between theory and exercises."

Tim van den Kerkhof – Sioux Embedded Systems

"Clear and good training. Relaxed and open atmosphere. Significant room for discussions."

Bart van Knippenberg - Thermo Fisher Scientific

"Most important items I have learned: General understanding/ existence of GoF patterns. Functions as a base to improve my OO design skills."

Erik Nagel – Kipp & Zonen

"What I like the most is the step by step transformation of a basic design to a good OO design."

Alexandros Loizidis - Thermo Fisher Scientific