Victor’s Talks
(for Conferences and Meetups)
Here is my up-to-date list of talks. No talk is identical to the previous iteration, their contents continuously change, as I keep learning new best practices and trends during the workshops I do each week.
🌟Don’t hesitate to reach out to organize a workshop next to your conference, or for your community - see here my training catalog: http://victorrentea.ro/catalog
Table of Contents:
🆕 Functional Programming Code Smells
🌟 Evolving a Clean Architecture
🔥 Tracing Java's Hidden Performance Traps
🔥 Upgrading Java: Best Features and Practices You Should Embrace
🔥 Resilience Patterns your Microservice Teams should know
🔥 The Modular Monolith Architecture
🌟 Testing Microservices - Join the Revolution
🌟 Test-Driven Design Insights [uthints]
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
Designing Expressive and Performant ORM Entity Models [ormmodel]
ConfWorkshop: Reactive Programming Patterns (1d)
Title: Trainer & Consultant
Company: Victor Rentea Consulting
With over two decades of experience, Victor is a Java Champion with extensive experience training mid-to-senior-level developers. Each week, Victor engages in intense workshops with talented engineers, addressing the challenges specific to their projects. He then regularly distills these insights into conference presentations and online meetups for the European Software Crafters, the world’s leading community focused on architecture, refactoring, and testing. Explore first-class training, consultancy services, and educational YouTube content with Victor. Learn more at https://victorrentea.ro
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/
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 2024 and fill your toolbox with many techniques you can immediately apply in your practice, via an entertaining show spiced with live-coding moments.
Code quality rises every year: projects kick off with high coding standards, mandatory code review, quality gates, and reliable unit-tests. However, I met many teams struggling with new challenges for code maintainability: Functional Programming misuse (by newbies) or abuse (by seasoned FP enthusiasts). Join this entertaining live-coding to learn about new code smells emerging in FP-enabled languages: - Fragmented Immutables, Tangled Tuples, Reduce Rodeo, Mutant Pipeline, Double-Edged Return, Function Factor 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?
At first, there was no structure. But then features grew complex, and developers started looking for ways to keep their code maintainable. This pragmatic talk explores the essential boundaries you can enforce in your architecture to address common pain-points you might be experiencing. You’ll learn about: Contract vs Implementation, CQRS, Separation by Layer of Abstraction, Agnostic Domain, Dependency Inversion, and the Modulith Architecture in an entertaining journey that overviews the main architectural guidelines for backend systems.
Tracing the root cause of a performance issue requires great focus, experience, and patience. It’s sometimes so difficult that we attempt to guess it by trying out tentative fixes, which usually leads to frustration, messy code, and a considerable waste of time and money. This talk explains how to correctly zoom in on a performance bottleneck using three levels of profiling: distributed tracing, metrics, and method profiling. After we learn to read the JVM profiler output as a flame graph, we explore a series of bottlenecks typical for backend systems, like connection/thread pool starvation, invisible aspects, blocking code, hot CPU methods, lock contention, and Virtual Thread pinning, and we learn to trace them even if they occur in library code you are not familiar with. Attend this talk and prepare for the performance issues that will eventually hit any successful system.
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.
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.
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!
What’s the safest way to split a monolith into smaller pieces that separate autonomous teams can easily manage? And then, do we really *need* microservices or is a singular monolithic deployment a better fit for our problem (spoiler: many are)? Please meet the Modular Monolith (friends call it ‘Modulith’), an architecture that reaps the benefits of functional decomposition without the costs and risks of distributed systems. In this architecture, a “module” fulfills a business capability via a well-defined API containing methods and events, encapsulates its implementation and its Domain Model, and has exclusive access to its DB tables. With help from Spring Modulith, this talk explores the main challenges of this trendy architecture style: enforcing boundaries, decoupling data, and monolithic deployment risks. The live coding will demonstrate that even if you aim to move to microservices, transitioning through a Modulith offers the team the ideal sandbox to experiment with different boundaries and decomposition patterns.
In the agenda:
Testing strategies for modern software architectures are evolving. As we transition from large monoliths to domain-aligned, team-sized microservices exposing crisp APIs, we encounter many stable testing surfaces we can use. This shift triggered many high-performing teams to favor integration testing over fine-grained, brittle unit tests. Integration tests prove to be more trustworthy as they get closer to the requirements, they don’t break on internal refactoring, and can also cover additional concerns typical for microservices. This vivid and entertaining live-coding presentation will cover the best practices and challenges of writing integration tests: cognitive overload, test isolation, and test execution speed. Join the microservice testing revolution and discover how to enhance your team's testing efficiency and effectiveness.
If tests are hard to write, the production design can be improved - 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.
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 (hopefully) you'll find outrageous, both you and everyone else on your team😉. For a preview of the agenda, check out https://owasp.org/www-project-api-security/
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 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).
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 who 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 of the largest software craftsmanship community in the world.
This talk is about technical culture and attitude.
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.
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.
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?
* Learn under-the-hood details of Reactive Programing that will help you find bugs and avoid common pitfalls
* Identify and align your code with established best practices designing reactive chains
* Take a deep-dive into the most difficult programming paradigm in use today
- What will you learn?
* Fundamentals - Signals, Reading Marble Diagrams (plus secrets)
* 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 metrics
- Who is the trainer?
<bio from above>
- Who is it for?
* Software Engineers working with Reactive Programming
* Avid Learners, willing to spend some extra time understanding the basics before the workshop.
* 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 17 installed
* decent IDE - IntelliJ Community or Ultimate latest version is perfect
* unrestricted access to github.com and maven central (!double check if it's your work laptop)
* several days before the workshop, import the project from a git in your IDE.
- 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 focused hours
- make extensive use of the Flux/Mono javadocs
- have a look at Project Reactor reference documentation https://projectreactor.io/docs/core/release/reference/
- 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.
Some Conferences I attended, by month ------------
Jan - jChampions online, Voxxed CERN.ch
Feb - jfokus.se
Apr - Devnexus (US), jPoint.ru
Mar - JavaLand.de (cfp:oct), VoxxedDays Bucharest
May - JAX Hybrid, DevTalks.ro, CodeMotion.es, Devoxx.UK, Devoxx.pl, jPrime.bg (cfp:feb), Bucharest TechWeek, GeeCon.pl
June - DevBCN
Sep -
Oct - Joker.ru, Craftconf (HU), GOTO Berlin, GeeCon.cz
Nov - Devoxx.be, VoxxedDays Cluj
Dec - Devternity, JavaZone
