Workshops

I have given commercial workshops for developers since 2012, most of them via Bottega IT Minds.

My focus is on Software Architecture, Test/Behavior Driven Development, Domain Driven Design, Spring, Reactive Programming and craftsmanship.

With 208 commercial workshops so far, 1-5 days long, on-line and on-site in Europe, Africa and Asia, plus another dozen for free, I feel I cannot call it a hobby anymore. Let’s call it “my side project”.

Below you’ll find details of some of them. All available in English and Polish.

Designing architecture for modular, distributed, and event driven systems; a pragmatic approach

Duration: 3 days. Description available also in Polish

This workshop teaches a sane and practical approach to architecture of three popular classes of systems: a modular monolith, a distributed synchronous system, and a distributed asynchronous system driven by events.

You’ll learn how to approach architecture, what drives it, what you need to consider to get it right (including team dynamics), which style solves which problems better, how to visualize your architecture, how to verify it, what tools to use, and finally you’ll learn heuristics to use when designing modules & microservices.

I’ll give a lot of real life examples, you will design a system in 3 different flavors, and we will review those designs in detail, fixing all the problems as we go.

While the workshop is programming language agnostic (doesn’t matter if you are on .NET, JVM, PHP or Perl), it is not technology agnostic. We will design assuming a public cloud (i.e.: with kubernetes), Apache Kafka as a message bus and persistent transaction log, and different database choices.

Synopsis

How to organize architecture in the company. What all those “solution”, “software”, “enterprise” really mean in the architect position description. How to work with different teams, depending on their maturity level.

Tools and notations: C4 Model, Sequence diagrams, diagram as code.

How do we verify the architecture. ArchUnit. Consumer Driven Contracts

What drives architecture, and what can you optimize for. What are the consequences of each optimization. How to calculate SLA, availability, maintainability, flexibility etc. Trade-offs.

How to design a modular monolith. What are modules. What are the benefits and when you should never use it. How to deal with high risk of deployment. How to change your thinking about modules (moving from data oriented to process oriented). Large exercise in design.

How to design a synchronous, distributed system, a.k.a microservices. How do we test distributed systems in practice. How to deal with networking deficiencies. Communication and control: Orchestration versus Choreography. Why Saga is just both a pattern and an antipattern. How to use it the right way. How do we deal with errors. How to provide performance. Data locality and read models. How to optimize for high SLA, and what does SLA even mean in a distributed system. Typical errors in designing such systems.

How to design an Event Driven system. What are the 3 different types of messages you can send. How do process streams, ensure ordering, deal with multiple consumers and producers. How Kafka works internally, and what a persistent transaction log allows us to easily design. Topics, partitions, consumer groups, compacted topics and read models, transactional publishing. When should we use all of that, and when a synchronous communication make more sense. Typical errors when designing such a systems.

Finally, how large heterogeneous systems work in real life, and which style is the best when.

Microservices: culture, management, organization

Duration: 2 days.

In 2012 Thoughtworks, by introducing microservices, sped up the process of building large software systems by an order of magnitude, breaking Fred Brooks law and problems of large projects from the previous 38 years. Due to that, companies like Amazon (AWS) say the bigger they grow, the easier it is to bring new features to the end-user. Achieving this requires a set of cultural and management changes, a completely different approach to teams, architecture and testing. There’s a lot of companies that were able to replicate it, and there’s even more that failed on the way.

This workshop is aimed at managers. We go through all the best practices that enable this transformation, and mistakes that will stop you from getting any benefits. All of them with real world examples.

We will answer those questions

How do we set up new products and teams?
How do we handle cross-product projects & problems?
How do we handle architecture on a large scale?
How do we make estimations and plan work?
How do we evaluate teams and people?
How do we hire new people?
How do we test such a system?
Why you cannot use ESB and what is an ESB good for today?
Why shouldn’t you build generic microservices on the first try?
Why should you avoid mono-repo?
Team composition: How many junior devs per team? What’s a senior?
What’s a platform? Types of teams (team topologies)?
Optimizing for cognitive load: what’s the size of a product/microservices/module?
How to set up on-duty and what happens to support?
How event driven microservices handle errors?
Organization structure: how many bugs will you have in production?

And we will also cover those topics

FinSecDevOps
Cynefin framework: types of problems and decisions
Continuous Deployment - how it’s done, and what to do with old monoliths
Migration to microservices: strangler pattern
Resiliency
Tailored Service Template
Typical errors in architecture
When the product team says no
Orchestration & choreography, context mapping

At the end of this workshop, you will know everything you need, to make people go faster the bigger the system gets.

Well designed applications in Spring framework

Duration: 3 days.

This is a zero-to-hero type of a workshop: no prior knowledge of Spring framework required.

In this workshop I teach the best practices of working with Spring framework, while at the same time explaining all the core features. This workshop is designed not only to show you how to do things, but how you should approach development with Spring to build easy to maintain software, and what features you should avoid.

Together we will build a modular app, using Test & Behavior Driven Development (with Spock), hexagonal architecture and make the process easy using all the best practices. Examples are in Java, Groovy and Kotlin.

I will cover:

Boot & Core

What is Spring Boot, how it works.
Boot events and bootstrap
Setting up and autoconfiguration
Tuning autoconfiguration
Component scan gotchas
Ways Dependency Injection works in Spring: JavaConfig vs @Autwired vs Functional configuration (including examples in Kofu straight from production)
Ports&Adapters / Hexagonal Architecture
Properties, Profiles, Conditions
Spring Actuator: endpoints, security
Testing your app

Spring MVC

How it works: Dispatcher, Request Mapping
Defining controllers: arguments & return values
Building URIs, RESTafaranism
Controller Advices, Handling Exceptions
Serving errors & static content
Locales, Session & Request scopes
Spring MVC testing
HATEOAS
Spring MVC vs Spring WebFlux

Spring Data

What it is, how to use it
Repositories, fine tuning
Nested properties
Query creation anatomy & Native Query
Page, Slice, Sort
Custom logic in repository implementation
Default methods & additional logic in repository
Populating the database & bootstraping
Auditing
Criteria/Specification
Testcontainers and in-memory databases

Spring Data JPA & transactions

Transaction management & attributes
Isolation & Propagation
Declarative Transactions
Manual Transactions
Patterns: where to start transaction
DDD Aggregates and JPA misconceptions
NoSQL + SQL, best of both worlds

Spring AOP

Aspect Oriented Programming nomenclature
LoadTimeWeaving vs CompileTimeWeaving vs Proxy
practical usage with examples

Reactive programming with Project Reactor

Duration: 2 days.

Reactive programming is fun and efficient, but creates a lot of confusion at first, because you have to switch your way of thinking. In this workshop we look into why & how to use it. We will create a reactive application from the ground up and dig a bit deeper into how the concurrency works in here. Because changing the way of thinking is the crucial part here, most of this workshop is actual coding.

Synopsis:

Why we need reactive programming
Reactive theory: backpressure and JVM foundations
Landscape of libraries
The problem of not reactive http and solutions (reactor-netty, rsocket)
Basics of Mono/Flux
How to think about reactive programming (declaration versus execution, cold vs hot)
How to test reactive code
Reactive operations
How to handle synchronous resources (RDBMS, etc.) from reactive code
Webflux and full reactive stack
Advanced Reactor features
When NOT to use reactive programming
Communication via RSocket
R2DBC
Fibers (Project Loom) vs Reactor

Test & Behavior Driven Development

Duration: 2 or 3 days.

This is a hands-on workshop for developers and QAs on how to build systems using Test & Behavior Driven Development. You will also learn Hexagonal Architecture, a bit on modularity and a lot on working with requirements. We will use the Spock test framework, but all the knowledge is ready to apply in all the other frameworks and languages.

Synopsis:

what are the alternative methods to TDD & BDD
what types of tools we can use
how to work with requirements, use cases, user stories, define acceptance scenarios, behavioral scenarios, think about corner cases
how to design test cases
an anatomy of a test, and best practices
setting the system up in unit and integration test, cleaning up afterwards
mocking, stubbing and spying
how to work with databases using testcontainers, in memory DBs, dedicated DBs, how some people test with a production copy and why you shouldn’t
how to organize test, how to keep them clean and maintainable
the power of Domain Specific Languages, and how to use them to make complex scenarios obvious and easy
what is the role of QA in most agile teams using TDD/BDD