Sign upTraining Design patterns and emergent architecture

Software - Design patterns

Course overview

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

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.

Detailed explanation


Price

€ 1.980,00 excl. VAT

Duration

4 consecutive days

Score

How participants recommend this training to others:
7.9   
(average score of last 3 editions)

Timetable

27-11-2018 | 09:00 - 17:00
28-11-2018 | 09:00 - 17:00
29-11-2018 | 09:00 - 17:00
30-11-2018 | 09:00 - 17:00

Location

Eindhoven

Contact

Tel. 085 401 3600
E-mail: training@hightechinstitute.nl

Partner


vObjective

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.

vIntended 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.

Read more prerequisites.

vProgramme

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.

vMethods

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

People who attend this training are also interested in:

Training Design patterns and emergent architecture

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

Download as pdfSign up for this training Sign upPlease give me a call Call Me Back

Sign up