Published using Google Docs
Victor's Talks
Updated automatically every 5 minutes

Victor’s Talks
(for Conferences and Meetups)

This document is intended for conference organizers and community leads, to help select a talk.

Table of Contents:

About Victor (aka “Bio”)

🌟 Clean Code, Two Decades Later [cc]

🌟A Clean, Pragmatic Architecture [cleanarch]

🌟The Way of the Modular Monolith [modulith]

🌟Your unit tests are trying to tell you something [uthints]

🌟Profiling your Java Application - A Beginner’s Guide [prof]

A Promise to End Reactive [endreact]

🌟The Secrets of the Fastest Java Developers on Earth [IJ]

Unleash the Ultimate Refactoring Weapon on Earth [IJref]

Software Craftsmanship - Growing a Technical Culture [softcraft]

Pure Functions and Immutable Objects - the Functional Programming philosophy [fp]

Designing Expressive and Performant ORM Entity Models [ormmodel]

Integration Testing with Spring [inttest]

Refactoring Games - 12 things you can do after extracting a method [extrmeth]

The Definitive Guide to Working with Exceptions in Java [exceptions]

Don’t let Mocks Mock you [mocks]

Proxy Fairy and The Magic of Spring [proxy]

My Mistakes (and others’) - The Hall of Infamous Errors

Workshop: Reactive Programming Patterns (1 day workshop @ VoxxedDays Bucharest 2023)

Conference List:

About Victor (aka “Bio”)

Title: Trainer and Consultant, Software Craftsman

Victor is a Java Champion, and Trainer writing code for over two decades. He regularly shares his passion about Refactoring, Architecture, and Unit Testing with the Bucharest Software Crafters Community that he founded, today one of the largest in the world. He gives intense conference talks that aim to educate in an live, entertaining way. On you can find his past talks, training offer, video classes, and social channels.

Speaker Credentials:

Best talks (Youtube playlist): 

Full list of past talks: 

YouTube Channel:

Twitter: @victorrentea



🌟 Clean Code, Two Decades Later [cc]

Clean Code principles have become a cornerstone of professional developer teams worldwide. But frameworks and languages changed, and so have the challenges we’re facing today while crafting modern applications. Single-page apps, extremely DRY code, microservices, excessive functional programming, and reactive flows have all taken their toll on our code quality. Hop aboard this roundtrip of the most damaging Code Smells as of 2023 and fill your toolbox with a load of practical tricks you can immediately apply to your day-to-day work. All in an entertaining show spiced with lightning live-coding snippets.

🌟A Clean, Pragmatic Architecture [cleanarch]

The architecture should help you solve your core complexity in the simplest possbile way. But you can’t always anticipate where complexity will accumulate, so the only way to keep your code simple is to gradually evolve your architecture towards the most simple design that suits the problem. Building on concepts from Domain-Driven Design and Onion/Clean Architecture, this talk will help you find the right balance between "Clean" and "Pragmatic" design, pointing out ways to avoid common sources of overengineering. Warning: this talk might shake your assumptions about design best practices, brutally questioning everything: agnostic domain? DTOs? strict layers? automappers? OO Domain?

🌟The Way of the Modular Monolith [modulith]

(alternative title: Modular Monolith over Microservices)

How do we progressively transition a monolithic codebase into decoupled modules in tiny baby-steps? What if we get the boundaries wrong? How do we enforce decoupling between modules? This talk overviews the main steps to move towards a Modular Monolith, aka Modulith. You will hear about breaking data structures, module APIs, choreography vs orchestration, events, transactions, and 6 strategies to fix cyclic dependencies between modules. Finally, extracting such a module into a microservice becomes a trivial task. But maybe, like some of my clients, you will be so happy with your codebase that you would choose NOT to take that dangerous step towards distributed systems.

🌟Your unit tests are trying to tell you something [uthints]

If tests are hard to write, the production design is crappy - goes an old saying. Indeed, writing unit tests gives you one of the most comprehensive, yet brutal, feedback about the design of your production code, but if it comes too late, many developers can’t stand it anymore and they will either stop testing or test more superficially. At the other extreme, others struggle to write contrived, fragile tests full of mocks that end up frustrating more than helping them. This talk reviews the main hints that unit tests provide you, from the most obvious improvements to some of the most subtle design principles.

🌟Profiling your Java Application - A Beginner’s Guide [prof] 

Professional performance optimization always starts with tracing the root cause of the bottleneck, to make sure we fix the correct problem. Trying to optimize the program by ‘guessing’ what can cause the performance issue is known as Shotgun Tuning, and typically results in messy code, wasted effort, and lots of frustration. In this talk, we’ll explore the best 3 free tools for profiling a Java application: Micrometer, Glowroot, and Mission Control and we’ll discover the power of a profiler built-in already into your JVM – the Java Flight Recorder. Using these tools, we'll trace typical issues like connection/thread starvation, long-running methods or repeated queries, TLAB issues, lock contention, and more.

A Promise to End Reactive [endreact]

Reactive Programming constantly gains traction, fueled by areas with large request volumes like IoT, FAANG-scale apps, and mobile games. Of course, major frameworks adapt to support such domains, but this can disrupt the projects that are not facing such volume challenges. This talk explores less powerful but simpler options for orchestrating asynchronous flows, like using CompletableFutures, or virtual threads, applied to a series of typical usage patterns for Reactive Programming.

🌟The Secrets of the Fastest Java Developers on Earth [IJ]

This session will teach you a lot of tricks that will skyrocket your Java coding speed, after a few days of practice. Writing, editing, navigating, and refactoring code faster will let you focus on your goals and allow you to experiment with various design alternatives without wasting precious time. In this talk, I’ll demonstrate some of the best tricks of IntelliJ (also available in the free community version): Auto-completion tricks, live templates, postfix expansion, multi-cursor, statement completion, code navigation, and several non-trivial automated refactoring moves.

Note to organizers: Even though it was curated by a few JetBrains folks, this talk is not a pitch: the features that I demonstrate are all available in IntelliJ Community Edition (free). I have no commercial relationship with JetBrains apart from raffling 3 free licenses/month for the community that I run (as JB does with hundreds of other communities).

Unleash the Ultimate Refactoring Weapon on Earth [IJref]

When writing a backend system aimed to survive decades, many choose Java not only for its backward compatibility philosophy but also for having the most powerful refactoring tools of all programming languages today.

Unmatched in this area, IntelliJ (free version also) offers dozens of refactoring actions and hundreds of inspections that can help you change the design easily and safely. We’ll cover in detail the mechanics of the most frequently used refactoring moves, we’ll see how to chain them together to achieve larger goals, and then we’ll also explore some very complex ones. All, while having lots of fun along the way with a Clean Code maniac😜.

Software Craftsmanship - Growing a Technical Culture [softcraft] 

Decades ago, IT started as a single engineering practice, but over the years it grew increasingly fragmented. The overspecialization we face today, in the context of a management-first agile transformation leads to a lack of responsibility, blaming games, repeated patching, painful communication overhead, and fulminating costs. The software craftsmanship movement is rising in this post-agile world with professionals that take control of their careers and continuously learn in the pursuit of mastery. But changing mindset requires determined team efforts and communities, especially when working remotely. What techniques and tricks can you use to grow such a culture of learning in your team? Find out from the founder and lead of one of the largest software craftsmanship communities in the world.

This talk is about technical culture and attitude.

Pure Functions and Immutable Objects - the Functional Programming philosophy [fp]

This presentation focuses on two of the most advanced design tools in your toolbox, whatever the language or framework you might be using. After understanding the basics, we'll see techniques that can be used in real-world scenarios to simplify the most complex use-cases in your application. Following a mix of slides and live coding, you'll get a clear picture of the power of immutable objects and you’ll know how to apply them in your day-to-day work. You’ll hear about: Side Effects, Idempotency, Referential Transparency, Deep/Shallow Immutability, plus the Functional Core - Imperative Shell segregation principle. Prepare for an entertaining, highly interactive session that will shake your assumptions about design. Written in Java and spoken in English.

Designing Expressive and Performant ORM Entity Models [ormmodel] 

The goal of an ORM (like Hibernate) is to hide the details and pain of interacting directly with the relational database. And it does it so well that you can start neglecting your database and shift your focus solely on building a beautiful object model. This works like magic for simple applications, but when the domain model gets complex or when you hit a performance issue, you will be brutally woken up to reality. To address these concerns, the Domain-Driven Design community developed a series of "DDD technical tactics" that we will cover in this session. Among the topics that I will explain by live-coding: challenge bidirectional links, favor numeric ids, ID Types, and Semantic IDs, decomposing large entities, and enforcing entity consistency & validation.

Integration Testing with Spring [inttest]

We get a better night's sleep with longer-scoped tests. Our life is brighter when our fine-grained tests don’t break at any refactoring. Let’s see how to test longer flows, using features offered by the Spring Framework. We'll discuss how to mock a Spring bean, testing with an in-memory or dockerized database, and how to mock external API responses. Along the way we'll also see how to extend JUnit, and discuss best practices for integration testing, all in an entertaining live-coding session.

Refactoring Games - 12 things you can do after extracting a method [extrmeth] 

In our quest against increasing complexity, Extract Method is probably the most important refactoring technique in our hands. We use it a dozen times per day as a first-level weapon, but it very often leads us to deeper design insights. Let’s look at several such next steps you might take after pulling some code out in a separate method:

Grab a black coffee and join this whirlwind of live-coding and design discussions spiced with jokes and metaphors. Victor will be coding Java, demonstrating and briefly discussing each point above.

The Definitive Guide to Working with Exceptions in Java [exceptions] 

Life isn’t perfect. Nor is our program’s execution. Bad things happen and then you meet them.  Exceptions have been with us for 25 years in Java but have we learned to use them properly? Are checked exceptions a mistake? Should you use throw runtime or checked exceptions? And when you get a checked one, what to do with it? And how to defeat the queen of all exceptions: the NullPointerException. Let’s put these old topics in the context of Java8+ lambdas, Vavr monads, Lombok, Spring, JAX-RS and other modern frameworks, and see the best practices of handling errors in Java today.

Don’t let Mocks Mock you [mocks] 

Do you ❤️ Mocks? When you write your first unit tests, especially on older codebases, mocking foreign code is key to survival. But as you grow older in the craft, you start piling up hours and days wasted to refactor fragile tests or to fix bugs that those heavy mock-based tests didn't catch. And so you start looking at Mocks differently.

Let's go through the key factors to consider to strike the optimal balance between what needs to be mocked away and what code should be tested in integration. There's sometimes a fine line there, often interwoven with strong emotions: "why am I testing this", "Argh… these tests take too long", "Can this ever really break?", etc...

Among the points that we'll cover:

The talk is focused on design decisions and although briefly demonstrated in Java, the discussion remains programming language-agnostic. Get ready for an entertaining, intense session, directly distilled from Victor's training content.

Proxy Fairy and The Magic of Spring [proxy] 

You can only claim to know Spring if you fully understand the Proxy design pattern, and how the framework uses it to do its magic. Join this session to explore 6 ways of intercepting method calls that you can use to cast your own spells and dramatically simplify your codebase.

Grab a strong coffee and prepare yourself for a whirlwind of live-coding, interwoven with deep theoretical concepts and implementation details that you have to master if you are using the Spring Framework. During this session, Victor will share one of the key parts of his Design Patterns training, applied to Spring. You'll hear about the Decorator pattern plus 2 ways to wire it with Spring, bare-hands interface proxies, concrete classes proxies, @Aspect applied to custom annotations, plus some of the most common standard off-the-shelf Spring aspects. Come and learn from a hands-on practitioner real-world best practices of using Aspects, design hints, under-the-hood details, debugging tips, and performance impact of aspects, all in an interactive, entertaining, and extremely dynamic session.

My Mistakes (and others’) - The Hall of Infamous Errors

(to protect the innocent, this is available only for internal private events)

I led 7 projects in my career, and by the time I switched to full-time freelancing, I committed an impressive series of design and coding mistakes. After that, in the workshops I’m constantly running today, I got to talk with developers from hundreds of projects in dozens of companies. I learned about their pain points and mistakes. Protecting the innocent, this is the The Hall of Infamous Errors - the most painful engineering mistakes I (or others) did.

Workshop: Reactive Programming Patterns (1 day workshop @ VoxxedDays Bucharest 2023)

- The purpose of this course is to explain the most common patterns and pitfalls when working with Reactive Programming, immediately applicable in day-to-day work.


- Why attend this workshop?

* To learn under-the-hood details of Reactive Programing that will help you understand bugs and avoid common pitfalls

* To odentify and align patterns in your code with established best practices designing reactive chains

* To take a dive into one of the most difficult programming paradigm in use today


- What will you learn?

* Key Concepts - Signals, Marble Diagrams (plus hidden tricks)

* Query Patterns - efficiently enrich data from multiple sources

* Command Patterns - trigger side effects to external systems

* Error Handling Patterns

* Bridging Reactive to non-reactive world - blocking and call-back based

* Infinite Fluxes - error handling, grouping fluxes

* Testing Patterns

* Tracing and Monitoring - Reactor Context, Operator Lifting, exception traces, and collecting metrics


- Who is the trainer?

Victor is a Java Champion, Consultant, and Trainer writing code since 2006. He regularly talks about Refactoring, Architecture, and Unit Testing at top conferences, but also at the Bucharest Software Crafters Community that he founded. On you can find a selection of his past talks, his full training offer, video classes, open masterclasses, social channels, and more.

- Who is it for?

* Software Engineers working with Reactive Programming

* Avid Learners willing to spend some extra prep time before the workshop to get familiar with the basics.

* All participants are expected to be fluent with Functional Programming concepts: .filter() .map(), lambda syntax, :: notation, immutable objects

* Prior experience with multi-threaded code is desirable, but not mandatory.

- Technical requirements:

* JDK 11 installed

* decent IDE - IntelliJ Community or Ultimate latest version is perfect

* unrestricted access to (!double check if it's your work laptop)

* several days before the workshop, clone the code at and import it as a Maven project.

- Prep work [optional]:

For the best learning experience, the participants are invited to solve as many exercises they can from the project's git repo, at reactor/src/main/java/victor/training/reactor/workshop. For example, fill in the solution in the P1_Creation and then run the tests in P1_CreationTest and enjoy the tests go green. Then P2_... and so on.

To solve the exercises, please:

- allocate 2-4 hours of fresh brain time

- make extensive use of the Flux/Mono javadocs

- have a look at Project Reactor reference documentation

- if you block, you can also take a peek at the solutions 🤫

Having this time of self study is very useful especially for developers with little/no prior hands-on contact with Reactive Programming. To make the best out of the single day we have together, I will have to take the lead during the workshop so you might not be able to follow the discussion AND type at the same time.

Conference List:

GeeCon, JokerConf, XP Days, Voxxed, Bucharest Java User Group, Logeek, SoftLabs, DevTalks, Agile Tour)

Jan - jchampions

Feb - jfokus (sweden)

Mar - JavaLand (DE) cfp oct

Apr - Devnexus (SUA)

May - JAX Hybrid

May - CodeMotion madrid

May - Devoxx UK

May - jPrime ( cfp feb)

Sep - Geekout (ESTONIA)

Sep - GeeCon (Polonia)

Oct - Joker

Oct - Craftconf (HU)

Oct - Goto Berlin

Nov - Devoxx BE

Nov - Build Stuff (lituania)

Dec - Devternity + Workshops

Dec - JavaZone