Victor’s Talks
With 20 years of experience, Victor is an AI-Augmented Java Champion who has trained thousands of engineers from over 150 companies in a large variety of domains. The lessons learned from these sessions, he shared in countless educational talks, top-rated at major conferences, where he’s known as ‘the speaker with the soundboard’. In his spare time, Victor runs 1:1 individual coaching sessions and organizes online meetups for the European Software Crafters community. More on https://victorrentea.ro
Title: Trainer & Consultant
Company: Victor Rentea Consulting
- Full History of all my past talks: https://victorrentea.ro/blog/talks/
- YouTube Playlist with my best 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
Talks I can run:
AI-Augmented Engineers - Upgrading Professionals
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
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/
I was an AI skeptic. Like a respectable engineer who spent decades practicing the craft, I laughed at vibe coders, prompt engineers, Cursor, Claude, and the entire wave of AI “hype”. I waited for it to pass. But I was wrong. AI fundamentally changed our profession forever. This talk reviews the key practices of professional AI-first software engineers: prompt/context engineering, MCP tools, agentic design and orchestration, AI SecOps and architecture observability.
This is not a hype talk, nor a doom talk - it's a field report from the middle of the shift already happening around us. The game is changing. The question is not whether we like it, but whether we are ready to adapt to stay relevant.
How do you enforce and observe the quality of AI-generated code? After months of fine-tuning their custom agentic workflows, my top training groups report 100% of their code is written by AI. This talk summarizes design metrics they use as automatic feedback loops for their agents, as well as the techniques with high signal/noise they found to optimize the human code review step - the last bottleneck in software engineering.
We’ve always been rewarded for writing code, debugging systems, and mastering frameworks. But today, AI no longer just assists - it builds, analyzes, debugs, and reasons, so our role gets upgraded to "builders" taking decisions, and achieving outcomes. But as our attention lifts up from code, how can we remain in control and keep the product quality high? - many senior engineers are concerned. Compiling lessons from early adopters of agentic engineering, this talk shows how AI agents can handle chores, preserve our mental energy, and amplify our impact across the system, turning us into super-charged builders.
But this is not a talk about tools. It’s a talk about identity.
Because the real question today isn’t: “Will AI change my job?”
It’s: “Will I evolve fast enough to stay relevant?”
A compilation of emerging patterns and common pitfalls observed in over 50 companies. From unhealthy context management, naive prompting, unvetted AI slop, and careless supply-chain to self-learning skills, sub-agent orchestration, AI guardrails, and backpressure. Join this talk to cut through the hype, learn from the early adopters of agentic engineering – see what works, what ships better code 3x faster in production, and what fails
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.
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.
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
To survive in distributed systems, teams centralize Logs, Metrics, and Traces throughout their ecosystem using the Open Telemetry standard, often with zero-code instrumentation. In this game, we’ll trace several common bottlenecks using traces and various metrics to debunk the myth surrounding these practices. As a bonus, you’ll learn the basics of PromQL language, a prerequisite for painting your next Grafana Dashboard masterpiece.
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
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:
