You have to master Design Patterns to identify and reason about design alternatives, but also to understand existing code and better communicate with colleagues/architects. Despite the fact that the workshop is heavily code-driven, the focus stays on the evergreen design principles and values. In the agenda you’ll find simple patterns like Singleton, Factory Method or Strategy, but don’t expect to hear the dogmatic definition of them. Instead, we’ll discover together pitfalls, variations, tradeoffs and alternative designs that will equip your toolbox for writing better, simpler code in your actual project.
At the other end we’ll explore patterns (like Proxy) that underly mainstream framework today, as well as inter-system collaboration patterns, like commands and events. However, one of the most important take-away will probably be the Clean Architecture (aka Onion), implemented with a pragmatic code-first mindset.
- Design Principles (with tradeoffs):
» Coupling: code, fan-in, fan-out, temporal
» High-cohesion / Low-coupling
» Single Responsibility Principle (SRP)
» Don't Repeat Yourself (DRY)
» Keep It Short and Simple (KISS & YAGNI)
» SOLID Principles (by Uncle Bob) + critique
» Rules of Simple Design (by Kent Beck)
» “Encapsulate what varies”
» “Program to abstractions” + Separation by Layers of Abstraction
» “Favor composition over Inheritance”
- Creating Objects
» Singleton + other lifecycles in Spring
» Factory Method - 7 reasons
» Builder Pattern – 5 styles + why are they bad
» Decorator, Proxy - Spring AOP interceptors
- System Architecture
» Adapter Pattern, Anticorruption Layer, and Dependency Inversion Principle
» Facade Pattern, Layered Architecture, and Evolutionary Architectures
» The Clean Architecture (aka Onion, Hexagonal, Ports-and-adapters)
» Modularizing a Monolith - Techniques to vertical-slice a large codebase
- Propagating Change
» Observer Pattern: Spring Events, Message Integration
» Command Pattern: Thread pool executors with JDK and Spring
» [optional] Microservice Orchestration vs Choreography, the Saga Pattern, Event Sourcing, CQRS
- Object-Oriented Patterns
» Strategy and Chain of Responsibility (aka Filters)
» Template Method versus Passing a Block (functional programming)
»Anti-Patterns + typical workarounds
You can download the full program for this workshop at the following LINK.
* If you're interested in this program, please contact us at firstname.lastname@example.org to find out more about availability and prices.