Victor Rentea

Java Champion, ex Lead Architect @IBM
Victor (@VictorRentea) is a Java Champion, and one of the top Technical Trainers, having trained more than 1.5K developers in dozens of companies worldwide.
Victor’s talks are regularly top-rated at the largest international conferences in Europe: his live-coding sessions are lightning-fast but well crafted, full of enthusiasm, deep insights and take-away tips. His passion is Simple Design, Refactoring, and Unit Testing, about which he regularly talks at top conferences. His personal commitment is to seed passion for writing clean, professional code.

Workshop topic:
Design Patterns and Principles 

Time & Date:
March 28th & 29th | 9am-5pm CEST

About workshop

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
      » Abstract Factory
      » Factory Method - 7 reasons
      » Builder Pattern – 5 styles + why are they bad
  • Magic
      » 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
      » Visitor Pattern
      » State Pattern (brief)
      » Strategy and Chain of Responsibility (aka Filters)
      » Template Method versus Passing a Block (functional programming)
      »Anti-Patterns + typical workarounds
      »Final Test + awards.

You can download the full program for this workshop at the following LINK.

* If you're interested in this program, please contact us at to find out more about availability and prices.