Application and Systems Architecture – Architectural Patterns for application architects

Code: Arch-patterns
Category: Architectural patterns
Format: 50% lecture / 50% workshop
Duration: 3 days
Target audience: architects
Enrollment: Groups, companies
Venue: Client's office.

This training presents selected Design and Architectural Patterns in a practical and non-textbook approach, set in the context of designing web applications, platforms, systems, and frameworks.

It includes practical examples drawn from real-world systems such as ERP, visual tools, distributed systems, and servers.

Participants will gain integrated knowledge of modern software engineering achievements, enabling them to create advanced systems. The discussed topics underpin modern frameworks and technologies, enhancing understanding and facilitating conscious usage. Techniques for combining patterns into higher-order structures are also presented.

The training is intended for designers and architects seeking to expand their competencies in standard architectural styles.

The program serves as a general framework; its full implementation exceeds 3 days. During the pre-training analysis, we select patterns beneficial for the team and focus on them during the training. Typically, we can address about 70% of the listed patterns within 3 days.

It's all about the content.

  • Modern architectures (CQRS – supporting DDD)
  • Possibility of basing examples on Kafka
  • Matching solution class to problem class

Training Program

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

  1. Documenting Architecture in the 4C Approach - Context, Containers, Components, Classes
    1. Context
      1. The context in which the system will operate
      2. Main actors
      3. Organization-level processes involving the system
      4. Role of other systems
    2. Containers
      1. Technical containers in which the system will be deployed
      2. Integration patterns
      3. Communication protocols
    3. Components
      1. Components and Services in the SOA context
      2. Canonical data exchanged between Services
      3. API design
      4. Single source of truth principle
    4. Classes
      1. Introduction to design techniques and patterns at the class level
  2. System Architecture - Overview of Approaches
    1. Modularization
      1. Levels of separation
      2. Techniques for integrating modules
    2. Micro Kernel Architecture
    3. Command + Command Handler
    4. Ports and Adapters
    5. Restful
      1. Four maturity levels
      2. Rest as an application protocol, not a transport protocol
    6. Event Driven Architecture
      1. Architectures based on events
        1. Events broker
        2. Events Bus
        3. Eventual Consistency
      2. Temporal dependencies between events
      3. Sagas – orchestration of events
  3. Application Architectures
    1. Layered Approach
      1. Differences between Layer and Tier
      2. Separation of application logic and domain logic
        1. Application Logic
        2. Modeling Use Case/User Story
        3. Stateful or stateless
        4. Challenges in module API design
        5. Domain Logic and Domain Driven Design Techniques - Building Blocks
        6. Aggregates
        7. Entities
        8. Value Objects
        9. Domain Services
        10. Policies
        11. Specifications
        12. Factories
        13. Repositories
        14. Modeling invariants
        15. Model levels: Capacity, Operations, Policy – model tuning, Decision Support
      3. Strategic Layer Testing – general approach overview
        1. Combinatorial explosion of test cases problem
        2. Testing upper layers using end2end approach
        3. Testing lower layers using unit approach
    2. Practical use of Inversion of Control techniques (DI, Events, AOP)
      1. Dependency Injection – basic IoC technique
        1. Use instead of factory patterns
        2. Building specific Strategies, Decorators, etc. depending on application state (context, configuration)
        3. Openness to extension via Strategy patterns
      2. Event-driven systems – stronger IoC technique
        1. Use for creating extensible plugin-based architectures
        2. Use for creating scalable high-performance systems (using queues, e.g. JMS)
        3. Sagas - modeling complex event-driven processes
      3. Aspect Oriented Programming
        1. Introduction to AOP
        2. Interceptor techniques
        3. Examples of AOP usage
    3. Designing extensible systems
      1. plugins
      2. listeners
      3. injecting extensions
      4. aspect-oriented approach
  4. Data access layer patterns
    1. DAO
    2. Repository
    3. Active Record
    4. Object-relational Mapping - using Java Persistence API (Hibernate)
    5. ORM Issues
      1. Paradigm mismatch
      2. Object boundary mapping
      3. Composition or aggregation - mapping
      4. 3 approaches to optimistic locking
      5. Versioning
      6. Locking objects that serve as bases for others (READ)
      7. Ensuring consistency of object graphs via root locking (WRITE)
  5. Modularization
    1. Separation of Bounded Contexts
      1. Techniques for defining module boundaries
      2. Techniques for module encapsulation
        1. API
        2. DTO
    2. Module integration - approaches
      1. Events
      2. API calls
      3. Business process engines
  6. Command-query Responsibility Segregation – extended layered architecture
    1. Support for Domain Driven Design
    2. Solving ORM mismatch problems for data viewing in grids
    3. Oriented toward scalability and extensibility
    4. Creating dedicated models: for reading, for business operations
      1. Solving performance issues
      2. External index architecture using noSQL
  7. noSQL
    1. Use cases
    2. Types of databases - matching to the problem
  8. Testability – designing test-oriented application architectures
    1. Strategic testing
      1. Combinatorial explosion of test cases
      2. Mapping application layers to the testing pyramid
      3. Strategy
        1. Domain layer - unit testing
        2. Service layer - end2end testing
    2. Striving to run logic outside the server – increasing productivity, reducing redeployment time
    3. Architecture’s susceptibility to testing: problems and pitfalls
    4. Unit testing techniques: dummy, fake, stub, mock
    5. Unit and integration testing tools (ex: JUnit, Mockito)
    6. 3 levels of tests
      1. Specification by Example - business goals
      2. Flow - User Story
      3. Automating UI interaction - Agents as abstraction over test scripts


Download PDF

Trainers

Meet the experts who will conduct your training.

Andrzej Ludwikowski

Michał Mac

Marcin Markowski

Marek Skorek

Sławomir Sobótka

Paweł Szymczyk

Bartłomiej Słota

Mike Wojtyna

Contact us for a free consultation.

Firstname and lastname:
Company:
E-mail:
Phone:
Subject:
Message:

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