Victor’s Talks
With 20 years of experience, Victor is a Java Champion specializing in training software developers and architects. Thousands of engineers from over 150 companies have attended Victor’s workshops, enabling him to develop deep insights across a variety of application domains. Distilling the lessons learned from these sessions, he gave countless educational yet entertaining talks at top conferences, where he’s known as ‘the speaker with the soundboard’. In his spare time, Victor coaches individuals and teams and organizes online meetups for the European Software Crafters community. More on https://victorrentea.ro
Title: Trainer & Consultant
Company: Victor Rentea Consulting
- History of Talks: https://victorrentea.ro/blog/talks/
No talk is identical to its previous run, as I keep learning from the workshops I run every day.
I can also run a 1-2 full-days workshop for your conference, or for your local community on the following topics: http://victorrentea.ro/catalog
In this document:
Streamtoxication: How a Fluent API Turns into a Tangled Mess.
Top 10 REST API Design Pitfalls
Top 10 Event-Driven Architecture Pitfalls
Modular-Monolith-first Architecture
Functional Programming Code Smells
🌟 Evolving a Clean Architecture
🔥 Tracing Java Performance Bottlenecks
Virtual Threads: Strengths and Pitfalls
Upgrading Java: Best Features and Practices
Pragmatic Hexagonal Architecture
Top Resilience Patterns for Microservices
Spring Integration Testing like a Pro
Security Vulnerabilities for Mortals [apisec]
The Secrets of the Fastest Java Developers on Earth
Software Craftsmanship - Growing a Technical Culture
The Dark Tenets of Hibernate and Spring
Deadly Java Puzzlers for Daily Life 🆕
Tracing Java Bottlenecks Masterclass - 1 day
Practical Modular Monolith Architecture - 1 day
Mastering and Tuning JPA - 1 day
Event-Driven Patterns - 1 or 2 days
Spring Integration Testing, Zero to Hero - 1 day
Refactoring to Patterns of Modern Java - 1 day
Reactive Programming Patterns - 1 day
Speaker Credentials:
Best talks (Youtube playlist): https://www.youtube.com/playlist?list=PLggcOULvfLL_MfFS_O0MKQ5W_6oWWbIw5
Full list of past talks: https://victorrentea.ro/blog/talks/
YouTube Channel: https://www.youtube.com/user/vrentea
Photo Young: https://victorrentea.ro/fata.jpg
Photo jpoint: https://victorrentea.ro/face.jpg
Twitter: @victorrentea
LinkedIn: https://www.linkedin.com/in/victor-rentea-trainer/
GitHub: https://github.com/victorrentea/
Let’s use streams everywhere!! While streams are often clearer and more concise than traditional iteration, some scenarios require complex combinations of collectors, monads, and deeply nested lambdas, so the verdict becomes debatable. After implementing the same use cases in both imperative and functional style, you’ll get to vote which is best, and we’ll argue over the results. If you're a Java developer, this entertaining and highly interactive session will leave you with a sharper understanding of where streams excel and where you should stick with the old-fashioned imperative style.
What if your worst bugs aren’t in the code, but in your head?
Cognitive biases, emotional traps, and mental load silently shape every line we write and every design we argue over. From Impostor Syndrome to the Shiny Object Effect, our psychology impacts team dynamics, architecture decisions, and even how we debug. In this keynote, we’ll unpack the hidden forces behind technical work—why smart teams make irrational choices and how to build awareness into your engineering culture. Learn to outsmart your own brain and ship better software, together.
An entertaining review of the top mistakes in API design, from the most outrageous goofs to the most dangerous "innocent" shortcuts: breaking changes, exposing domain model, leaking sensitive data, performance massacres, endpoint coupling, CRUD-mania (vs CQRS), PUT/PATCH overload, and careless error handling. Collected with love from over 150 companies.
You send a message instead of an API call - what can possibly go wrong? Enter the Event-Driven Adventure Park, where every message is a rollercoaster ride! Hold tight as we race through the wild loops of duplicate deliveries, out-of-order, and race conditions. Survive the dual-write drop, escape the consumer error maze, solve the lost message mystery, and find the cure to the poison pill messages. We’ll have 10 thrilling rides — all real war stories collected with ❤️ from 150 companies Victor trained at. Whether you’re an architect, coder, or ops hero, get ready for a wild tour through the quirks and best practices of messaging systems. No REST, just ride! 🎪
Trying to split a legacy codebase into manageable pieces? You aren't sure you really *need* microservices? Then this talk is for you. Meet the Modular Monolith Architecture - the best architecture for some domains, and the safest way to transition to microservices. What is a Module, and how do they communicate? Can they share tables? How to enforce code boundaries and ownership? What should go in the 'shared' module? How to test a module, and how does Spring Framework help us with all that? When and how to extract a module into a microservice? We’ll address these questions in an entertaining, interactive session that no tech lead or architect should miss, drawing lessons from many successful real-world projects.
In the agenda:
Clean Code principles have become a cornerstone of professional developer teams worldwide. Languages and frameworks have evolved, code analysis tools and IDEs have matured, so it’s time to raise the bar for code quality to increase our agility to rapidly incorporate changes and new features. Join this tour of the most common Code Smells as of 2025 and fill your toolbox with many techniques you can immediately apply in your practice, via an entertaining show spiced with live-coding moments.
Every year code quality improves everywhere thanks to mandatory reviews, quality gates, and #responsible unit-testing. However, many code smells survived, while fresh ones joined to poison our codebases in new ways. Join this entertaining tour of the top code smells in 2025, and ways to fix them.
Code quality rises yearly thanks to mandatory review, quality gates, and responsible unit-testing. However, teams started struggling with new challenges for code maintainability: Functional Programming misuse by newbies or abuse by FP enthusiasts. Join this entertaining tour of the newly emerging Functional Programming code smells: Fragmented Immutables, Tangled Tuples, Functional Chainsaw Massacre, Reduce Rodeo, Mutant Pipeline, Double-Edged Return, Function Frenzy, Optional Obsession and more.
The architecture should help you solve your core complexity in the simplest possible 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 helps you find the right balance between "Clean" and "Pragmatic" design, showing ways to avoid common sources of over-engineering. Warning: this talk might shake your assumptions about design best practices, brutally questioning everything: agnostic domain? DTOs? strict layers? automappers? Rich Domain Model?
Plan 2025
Event: CUD -> Workflow
Event vs Command (request)
dups: de ce e o problema? ~command. idemp-key. delivery-promises; transactions
out-of-order -> temporal coupling -> freeze on error if critical
Event Storm (M cycle,watchdog retry,batch-to-stream) -> throttle
Error handling
Painful days wasted optimizing the wrong part of the code... Blind attempts to fix a production performance issue. Then, speculative “micro-optimizations" that clutter the code for no measurable gain. Only to later trace the problem to the most unexpected cause. This talk explains how to efficiently zoom in on a performance bottleneck using opentelemetry distributed tracing, metrics, and execution profiling. After we learn to read a flame graph, we’ll trace typical backend bottlenecks, like resource starvation (threads and JDBC Connections), time-consuming interceptors, repeated network calls, CPU hot points, and lock contention, all using a variety of mainstream tools. Join this session to prepare for the performance issues that any successful application will eventually have.
TODO: dT waiting for Tomcat thread=?
TODO: async-profiler for a C++ bottleneck example
TODO: @Observed + OTEL for reporting a custom span + baggage example
TODO: N+1 query/API call problem on a trace
TODO: tracing down to PostgresSQL article splunk
Deep-Dive: 105m=50+10+45, or 3 hours
Let's explore memory leaks and memory inefficiency patterns in Java backend systems. After reviewing the Java Memory Model and the JVM flags you #musthave in production, we’ll analyze heapdumps of 10 common memory leaks, collected with ❤️ from 150+ companies over a decade of consultancy. You'll hear about ThreadLocal, inner classes, cache/hash keys messup, thread leaks and many others. As the end, you'll get access to a large repo of memory leaks + heapdumps for later self-study. Oh, and you can get a bounty for any real memory leak you had, which is not yet in that repo 😊.
Over the last 3 decades, Java language acquired various concurrency techniques. But which is best for my use case? Would virtual threads help my project? Are CompletableFutures dead? Do I need the complexity of reactive programming? What are the pros and cons of each technique, and what would be an ideal use case for each of them? Join this talk if you want to avoid useless complexity while optimizing performance, and understand the future of concurrency and parallel programming in Java.
You will hear about:
- Thread Pool Executors (Java 5)
- Completable Futures (Java 8)
- Reactive Programming (RxJava / Reactor)
- Virtual Threads (Java 21)
- Structured Concurrency (Java 25 LTS)
Bring your use-case to the debate.
In September 2023 Java 21 introduced Virtual Threads, one of the longest-awaited improvements in the history of Java language. Massive concurrency with cheap threads without the cognitive load of a callbacks-based/reactive model, says the commercial. But what dark tenets and best practices must you learn to adapt to this paradigm shift? Can I expect a benefit from VT? How to measure it? What does Virtual Thread Pinning, CPU Monopolization, and Platform Pool Deadlocks mean, and how they can hurt me?
Upgrading the language version has never been such a hot topic in the entire Java history. One in three teams that I train is ‘transitioning’ to Java 11, 17, or even 21, sometimes upgrading two LTS versions at once. Suddenly you can use so many cool features: immutable collections, records, sealed types, switch expressions, text blocks, virtual threads ... But which of these will be a game changer for your project? Which are worth embracing and refactoring your old code to use them? Don’t miss this critical review of the best practical use cases of the modern Java features.
Many developers working with Hexagonal Architecture (aka Ports-and-Adapters) complain of overengineering. This talk starts from the religious architecture and brutally challenges every boundary to explore when and how you might want to soften them. Along the way we will use a couple of tools that will forever change how you look at code structure: ArchUnit and DSM. If you are an architect or senior seeking to keep complexity under control, you should not miss this talk.
The network is reliable and has zero latency with infinite, free bandwidth. And then you wake up. The plan was to go to microservices to build those reliable, super-scalable systems you saw in the ad. But your systems only communicate over synchronous protocols and the team never had a serious discussion about timeouts, retries, circuit breakers, and bulkhead patterns. If that’s your crude reality, please attend this session!
Integration Tests are slow, flaky, and too deep -- developers often complain, then fall back to their Unit Tests riddled with mocks that break at every refactoring and slip bugs into production. Join this talk for 7 lessons that will turn you into a Pro in Spring Integration Testing: Test Context Cache Optimization, DB Cleanup techniques, Message Broker Draining, Awaiting for side-effects, Testing DSLs, Object Mother Pattern and Parallel Tests. All in an entertaining style spiced with jokes and real-life stories from 150+ companies Victor has trained at -- a must-see for anyone serious about testing their microservices.
Good engineers refactor code continuously, but we rarely dedicate deliberate time to improve this skill. We keep manually editing the code, cut-pasting, wasting time, focus, and risks. In this live-coding workshop, you will learn how to apply the must-have refactoring moves to fix various code smells in tiny, safe steps: extract and inline of methods, parameters, variables, constants, and interfaces, moving methods next to data, and much more. We will then study classic refactoring combos combining tiny refactoring moves for a significant design impact. Along the way, we’ll explore tradeoffs of each design change, touching on fundamental design principles that stand at the root of Clean Code. Apart from these refactoring moves, you will discover hidden gems for massive refactoring: IntelliJ’s Structural Replace and Error Prone’s Resharper.
Writing unit tests provides one of the most comprehensive feedback about how to improve the design of your production code. However, if this feedback comes too late it’s often too brutal and we ignore it, writing contrieved, fine-grained, mock-full tests that instead of helping us on the long run end up adding to our pain. This talk overviews ten design improvement points that unit tests are pointing to, from the most obvious improvements like more specialized method signatures and value objects to some of the most subtle design principles like Command-Query-Separation Principle and Separation by Layer of Abstraction. Attend this session to fill your design toolbox with practical techniques immediately applicable to your project.
Security is NOT someone else's concern. You, the developer, are responsible to secure your application, provided with support from security specialists and tools. This introductory talk explores the OWASP Top 10 API Security vulnerabilities, through a series of simple, entertaining demos that everyone in your team should be familiar with.
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 IntelliJ tricks: Auto-completion tricks, live templates, postfix expansion, multi-cursor, statement completion, code navigation, and a few 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).
Happy, motivated developers who take ownership of their product to deliver more value for their users, instead of blaming games, expedient patching, communication friction, and ceremonial "agile". How to get there? Join this talk for a series of practical tips and tricks for driving a change in mindset, collected from 150 companies by the founder of the largest software craftsmanship community in the world.
Spring + Hibernate is probably one of the most common library combo in the Java ecosystem worldwide, allowing you to kick-start a project in no time. But these libraries hide dark secrets that cause hard to understand bugs and performance issues to both novice and experienced developers. This live-coding presentation reveals many of these secrets via a series of puzzles distilled from problems of projects throught Europe. You will learn the main pitfalls and best practices around transaction management, write-behind, lazy loading, concurrency management, and more.
= classic and new pitfalls of the java basics, collections, and performance that you can encounter in real-life (not corner cases); audience votes using their phones; explanation follows
* Do you know your Java? It's time for some (not so) simple puzzles on operator precedence, object equality, performance, immutability, and null handling in collections. Join this interactive session and guess the outcome of the code samples to earn the "Java Geek of Devoxx Poland" gold medal (not kidding). Don't worry, everything will be explained so you will leave not only entertained but aware of both well-known and obscure new Java pitfalls you can easily encounter in your daily practice.
https://youtu.be/wbp-3BJWsU8 by Jeremy Manson, Josh Bloch, 2011
https://youtu.be/qRTIpyd_snc by Bob Lee and Josh Bloch, 2013
https://www.jrebel.com/blog/java-8-puzzlers by Viktor Gamov, 2016 <<<<
https://youtu.be/BVxrlc-pAX8 by Baruch Sadogursky and Viktor Gamov, 2017
https://youtu.be/NG-27PnRcTc by Baruch Sadogursky, 2018
https://youtu.be/w6hhjg_gt_M by Maurice Naftalin and Jose Paumard 2022
AI-Assisted Coding
About
We’re living in an exciting time. AI has clearly demonstrated enormous capabilities and yetis not highly reliable or even predictable for providing correct or factual responses.
How can we benefit from AI as programmers? Should we shy away from using it or jump in with full faith? How can we benefit without being burned by it?
Those are the questions we will answer in this workshop, by way of practical examples and hands-on exercises.In this workshop we will,not by talking, but by walking through many examples, see the power and the perils of AI for application development. We will tear thing apart to understand where it gives us the most benefits, and in areas where it is not reliable. We will identify the techniques we can use to make the best use of AI. We will look at how we can practically use AI tools and, in areas, vibe coding, and how to make sure the results are reliable, maintainable, and dependable.
The overall goal is for us to be able to use the powerful tools to accelerate the development of applications, but in a way that we can still standby and sign off the applications we are ultimately responsible to deliver.
Course contents
Day 1:
Day 2:
Tools:
The tools that will be used include, but are not limited to
What will you learn:
You will learn how to:
What can you do after taking this course:
Details of Topics Covered:
Target audience and prerequisites
This workshop is for you if you are:
A suitable agenda will be extracted from https://victorrentea.ro/catalog
Load tests, profiling, metrics
Module interation patterns, spring-modulith, comparison with microservices
Jan:
Feb: jFokus✅, Voxxed CERN.ch
Apr: Voxxed Ams✅, JCon.de
Mar: Voxxed Bucharest, devoxx Fr✅, JavaLand.de (cfp:sep)
May: DevTalks.ro⭐️, Spring IO✅, Devoxx.UK, Devoxx.pl, jPrime.bg (cfp:feb), JAX Hybrid, DevWorld Ams, TechWeek, JCon.DE(cfp.oct), GeeCon Krakow+workshops (cfp:dec)✅
Jun: DevBCN⭐️, NDC{Copenhagen}(cfp:jan), Craft-conf.hu⭐️❌
Sep:
Oct: GOTO Berlin, CodeMotion Milano, JAX London
Nov: Devoxx Belgium⭐️, Voxxed Cluj, DevCon⭐️
Dec: JavaZone
====== 2026 submissions =======
Voxxed Amsterdam: memory leaks✅, java profiling✅
Voxxed Bucharest:
Spring IO: spring integration testing?, event driven?, psychology?,
DevTalks Bucharest:
