Design and architectonical patterns and effective Object Oriented Design techniques for system designers

Code: craft-patterns-Patterns Sys
Category: Design patterns
Format: 50% lecture / 50% workshop
Duration: 3-4 days
Target audience: architects
Enrollment: Groups, companies
Venue: Client's office.

The training presents selected Design Patterns in a practical and non-textbook approach set in the context of designing libraries, frameworks, platforms and systems. During the training, examples of practical use are presented, taken from real systems of classes: ERP, visual tools, distributed systems, servers. During the training, participants will obtain integrated knowledge about achievements of modern software engineering, allowing them to create advanced systems. During the practical workshops, we combine design and architectural patterns to create flexible and open for extension solutions, which are characterized by a high level of testability.

Discussed issues are at the root of modern frameworks and technologies – which increases the level of their understanding and allows for conscious use. We present techniques of combining patterns into higher-order structures.

The training is intended for designers and architects, who want to expand their competences in terms of professional techniques of software engineering that increase the project and code quality.

It's all about the content.

  • Focusing on the context of designing applications and systems
  • Selecting only useful patterns and techniques
  • Real-life examples

Training Program

The content of our program can be customised during pre-training analysis.

  1. System architecture patterns
    1. Layers
      1. What is layer for?
      2. Relaxed Layers
    2. Micro Kernel
    3. Command and Command Handler
    4. Ports and Adapters
    5. Restful
      1. 4 maturity levels
      2. REST as an application protocol, and not a transport one
    6. Event Driven
      1. Time dependencies between events
      2. Sagas/Process managers – event orchestration
  2. Application architecture patterns
    1. Division into application logic and domain logic
    2. Application logic
      1. Use Case/User Story modeling
      2. Stateful or stateless
      3. Using the Aspect Oriented Programming
    3. Domain Logic
      1. Domain Driven Design techniques - Building Blocks
        1. Aggregates
        2. Entities
        3. Value Objects
        4. Domain Services
        5. Policies
        6. Using Dependency Injection
        7. Specifications
        8. Factories
        9. Repositories
        10. Invariant modeling
      2. Model levels
        1. Capacity
        2. Operations
        3. Policy – model tuning
        4. Decision Support
  3. Paradigm of the Inversion of Control – a tested concept of framework and system building
    1. Dependency Injection – the basis of modern frameworks – a detailed discussion with tasks
      1. Support for testability
      2. Practical application techniques to achieve the flexibility of design
    2. Event driven systems – talking over concepts and problems
      1. Plug-in architecture
      2. Separation of modules
      3. Increasing the system responsiveness
      4. Scaling
  4. Design patterns - practical, non-bookish examples based on real problems in the context of the Enterprise application
    1. Command – services encapsulation, access authorization
    2. Decorator – logic reusability
      1. Forming a complex, incremental business logic
      2. Wrapper – variant of a pattern useful in modeling oriented on meaning
      3. Combining a Decorator with a Strategy in order to build variants of incremental algorithms
    3. Strategy – encapsulation of business logic
      1. Selecting a variant of algorithm without an interference in the business core
      2. Integration with dependency injection mechanisms
      3. Defining a specific business strategy in the Inversion of Control container (XML or factory methods)
    4. Chain of Responsibility – two variants of the pattern
      1. Selection of a business logic for current conditions
      2. Combining a Chain with a Strategy in order to build variants of condition algorithms
    5. Abstract Factory – creating domain artifacts
      1. Consistent way of creating families of business objects dependent on the system implementation configuration
      2. Producing Strategies
    6. Builder – reduction of the complexity of structure creation
      1. Unified export of domain objects
      2. Hiding the complexity of query building
    7. Template Method – process templates
      1. Business logic unification technique
      2. Template Strategies
      3. Examples of an anti-pattern
    8. Singleton – a dangerous pattern on examples
      1. Details of implementing Singletons created with a delay, resistant to a concurrent access
    9. State – encapsulation of a business process
      1. Implementing a state machine representing a complex life cycle of the business object
      2. State Machine as a Wrapper that adds new functionalities
      3. Traps of excessive generalization of State Machines
    10. Observer – complexity reduction
    11. Event Broker – generalization to the level of the System Architecture
    12. High-performance Event Driven systems and asynchronous processing
    13. Process Manager – orchestration of multiple events in time
    14. Specification – encapsulation of business rules
      1. Reducing the complexity of systems containing a complex decision logic
      2. The case, when there are many possible logical criteria
      3. However in a given context (implementation, client), only a subset of rules is used
    15. Role Object
      1. Modeling roles in a system
      2. Alternative to inheritance
      3. Variant of the Bridge pattern
    16. Facade – reducing the complex structure under a convenient API
  5. Useful patterns with a technical use
    1. Bridge – separating the concept interface from its implementation
    2. Flyweight, Prototype – optimization patterns
    3. Memento – communication between contexts
    4. Proxy – basic pattern of frameworks
    5. Composite – repeatable structures
    6. Visitor – dynamic expansion of a Class API (Double Dispatch emulation)
    7. Iterator – a standard pattern for a collection
    8. Interpreter – a convenient pattern for creating own DSL
    9. Observer – systems oriented on events, MVC Component
    10. Extension Object – generalization of the Role Object for systems open to extension
  6. Testability – impact of using OOD good practices and Patterns on the code testability
    1. Issues of architecture susceptibility to tests: problems and traps
    2. Techniques of unit testing: dummy, fake, stub, mock
  7. Architecture documenting in the 4C approach - Context, Containers, Components, Classes
    1. Context
      1. Context, in which the system will be working
      2. Main actors
      3. Processes on the level of organization, in which the system is involved
      4. The role of other systems
    2. Containers
      1. Technical containers, in which the system will be arranged
      2. Integration patterns
      3. Communication protocols
    3. Components
      1. Components and Services in terms of SOA
      2. Canonical data exchanged between the Services
      3. API design
    4. The single source of truth rule
    5. Classes
      1. Introduction to techniques and patterns of designing on the level of classes

Download PDF


Meet the experts who will conduct your training.

Contact us for a free consultation.

Firstname and lastname:

If you prefer direct contact then you can always call.

Iwona Sobótka

Training coordinator

I agree to the processing of my personal data in accordance with the Law on the Protection of Personal Data in connection with sending a request via the contact form.

Providing the data is voluntary but necessary to process the query. I have been informed that I have the right to access my data, the possibility of correcting them, demanding stopping their processing.

The administrator of personal data is Bottega IT Minds, ul. Jana Sawy 2, 20-632 Lublin, Poland.

The information clausule