Offer - ALL

TRAINING OFFER FOR
<YOUR COMPANY>
VICTOR RENTEA – INDEPENDENT TRAINER
2023
- Email: victorrentea@gmail.com
- Phone: +4 0720 019 564
- Web: https://victorrentea.ro
- Client feedback on LinkedIN, Facebook and on https://victorrentea.ro/#testimonials
- Active on Twitter, LinkedIn, and Facebook
Technologies continuously change, tech stacks evolve, the mindset shifts, and the best practices constantly align, so…
⚠️Please find the most up-to-date version of this file at 👉 https://victorrentea.ro/training-offer
Contents
Curricula 2
Design Patterns and Principles – 2-3 days 2
Clean Code and Refactoring – 2 days 4
Clean Code for JavaScript/TypeScript – 1 day 6
Unit Testing – 2 days 7
Software Architecture – 2 days 9
Microservice Patterns – 2 days 11
Pragmatic Domain-Driven Design (DDD) – 2-3 days 12
Mastering the new Java Language Features – 1 day 14
Spring Framework – 3 days 15
Secure Coding in Java – 2 days 17
JPA/Hibernate Performance Tuning – 2 days 19
Java Performance – 2 days 21
Reactive Programming – 3 days 23
Selected Sub-Topics / Debates [pro] 25
One-to-One Coaching [pro] 25
DATE: 26
Fee: 26
Terms and Conditions: 26
Legal Entity Details 26
The agenda of any topic can be tailored to fit your needs: items removed, added, or edited.
Full Training Offer – Victor Rentea victorrentea.ro
CURRICULA
Design Patterns and Principles – 2-3 days ⭐
Overview
Mastering Design Patterns helps you understand existing code, identify, and compare design alternatives, and
better communicate your ideas with your colleagues/architects. Since developers are fluent in code, the
workshop is heavily code-driven, but the focus stays on the evergreen design principles and values. In the
agenda, you’ll find a range of patterns from simple ones like Singleton, Factory Method, or Strategy, up to
strategical ones like Visitor and Saga Pattern, but don’t expect to hear the dogmatic definition of them. Instead,
we’ll explore together pitfalls, tradeoffs, and alternative designs that will fill your toolbox for writing better,
simpler code in your actual project. Along the way we’ll also explore patterns (like Proxy) that underly
mainstream framework today, as well as inter-system collaboration patterns, like commands and events,
choreography, and orchestration. One of the most important takeaways, however, will probably be the Clean
Architecture (aka Onion), implemented with a pragmatic code-first mindset.
By the end of this live online course, you’ll understand:

● The most important Design Patterns in use today
● The principles underlying these Patterns
● The benefits and tradeoffs that Patterns introduce
And you’ll be able to:

● Identify design patterns applicable to real-life problems, and weigh their pros/cons
● Find a simple solution to the problem at hand after considering design alternatives and evolution paths
● Read complex code faster and deeper understand the frameworks and libraries you use
● Refactor code in baby-steps towards Design Patterns
This Online Training is for you because…

● You can read Java and you want to upgrade your design skills
(* coding can also be performed in PHP, C#, TypeScript, Scala, or Kotlin)
● You are considering an Architect career path
● You want to design a new system, or just review the design of your current one
If you want the best of this training, you can prepare in advance by:
- (MUST) READ: 5-10 minutes about each pattern in the agenda below from...
o This website: https://refactoring.guru/design-patterns or
o This book: Head First Design Patterns
- (RECOMMENDED) CODING: apply as many design patterns as possible you can to this exercise:
o https://github.com/victorrentea/design-patterns/blob/master/src/main/java/victor/training/patterns/assignment/
- (OPTIONAL) READ (15 minutes): this very influential article about Clean Architecture:
https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html
IMPORTANT: The patterns listed in the agenda target a backend developer using Java/Kotlin/Scala (±
Spring), C#, or PHP. For developers developing Web Frontends (Angular, React..), Games (eg Unity) or Scripts (eg
python), we can tailor the agenda for their needs during a prep-call. Even if the principles stay the same, their
materialization in patterns is highly dependent of the application challenges, language and frameworks used.
Code: https://github.com/victorrentea/design-patterns
Page 2 / 26 Get the most up-to-date version of this document at: https://victorrentea.ro/training-offer
The agenda is fully configurable to suit your team's needs.

Agenda
Design Principles (covered along the way) – 2 hours
- Coupling & Cohesion
- SOLID Principles
- Don't Repeat Yourself (DRY)
- Rules of Simple Design (by Kent Beck)
- Encapsulate what varies
- Program to Abstractions
- Favor composition over Inheritance
System Architecture – 1 hours

- Adapter Pattern and Dependency Inversion Principle (brief)
- Facade Pattern and Separation by Layers of Abstractions
Forking Behavior: OOP vs FP implementation – 3-4 hours

- Strategy, Lightweight version (FP)
- Chain of Responsibility (aka Filters)
- Template Method
- Passing-a-Function/Loan Pattern (FP)
- Visitor Pattern vs Sealed Classes
- State Pattern + State Machines
Intercepting Calls – 1.5 hours

- Decorator, Proxy, Aspect Oriented Programming (AOP)
- Execute-Around (FP Alternative)
Creating Objects – 1.5 hours

- Factory Method
- Singleton, Dependency Injection, Object Pool
- Builder anti?-Pattern
Propagating Change - 2 hours

- Observer Pattern, via Spring Events or Messaging
- Command Pattern, via thread pool tasks or Messaging
- Observer vs Command
Microservice Patterns – 3-4 hours

- Comparing Integration Paradigms: RPC (eg REST), Messaging, shared DB, File transfer
- API Gateway / Backend-For-Frontend (BFF)
- Consistency Patterns:
o Idempotent APIs
o Choreography vs Orchestration
o Saga Pattern, maintaining distributed consistency using Compensations and Reservations
o Transactional messaging: Outbox table, Change Data Capture (Debezium)
o Exercise: designing a food delivery application using a Saga
- Resilience Patterns: Rate Limiting, Bulkhead, Circuit Breaker, Retry
- Event-Driven Architectures [on-demand]: notifications, carrying state, event sourcing, CQRS
Wrap-up – 30 min
- Anti-Patterns + typical workarounds
- Recap & Classification. Quiz.
Clean Code and Refactoring – 2 days ⭐

Learn code smells, key refactoring moves, and fall in love forever with continuous improving code quality.
Deliverable in: Java, Kotlin, PHP, TypeScript, C#, Scala.
Goals:
- Empower you to refactor continuously
- Identify Code Smells and understand typical ways to fix them
- Refactor Safely breaking large changes in safe baby-steps
- Master your IDE refactoring tools with huge impact on your productivity and focus
Structure: The workshop is composed of an extensive set of exercises, covering the most common and
dangerous code smells, that we will fix using powerful refactoring moves. In parallel with the coding part, we
will brainstorm on design topics, motivation, attitude, ethics, teamwork, and more. The best part however will
be the larger refactoring katas, ideally on snippets from the audience’ production code. The training will be
spiced with analogies, real-life stories, and jokes that will make it a very entertaining and memorable experience.
Individual Work: To make the best use of your time, the participants will not be tasked to code during the
training days. Instead, they with be provided with a prep assignment (see below) that should be worked out
BEFORE the training, individually, in pair programming (best), or even mobbing with your team. If time allows,
we can review some of the solutions and provide hints on how to further refactor the code.
🔥new [optional] Deep Hands-on Experience: We can split an online training in half-days, and have the
participants work in pairs independently for the other half of those days on more refactoring and self-study tasks
that we then review together. In other words, if you can find more time for the participants, you can get almost
twice the impact with the same training fee. – ask me for more details.
Preview: TO get a taste of it, you can watch some teaser videos (in Romanian), Code Smells and live-refactoring
sessions on my YouTube channel, or purchase my Core Refactoring training on Teachable.
Prerequisites: Working experience with Java, ideally with prior contact with bad (legacy) code.
Prep work (mandatory):

1. Coding: Refactor this exercise on GitHub: https://github.com/victorrentea/kata-trivia-java (or ZIP).
Ideally work in pair-programming/trio/quartet/mob. It should take up to 4 hours. When done, centralize the
solutions and send them to me for a review. Deadline: the evening before the training.
2. Send me Production Code Snippets to refactor together (for dedicated sessions only):
- 2-3 snippets/a class of ≤ 200 lines of your project’s code
- Ideally manifesting some typical issues, eg debated at code reviews
- NOT the most complex part of your code, nor the most trivial: the point is learning and brainstorming
- Someone should be familiar with the functionality of the code
- If you don’t have time to make the extract compile, send just that file to me and I’ll fill the necessary gaps.
- Check with your lead about an NDA; if missing, anonymize the code: e.g., rename Account to “Basket”, etc..
- Deadline: the evening before the training
3. Reading:
a) Code Smells Overview: Chapter 2 & Chapter 3⭐ from Refactoring 2nd ed by Martin Fowler, 2018
or Browse an online catalog of Code Smells (fastest)
b) [nice to have] The Clean Code “bible”: Chapter 1-11 from Clean Code book by Robert C. Martin
c) [optional] Observe the tricks I use in IntelliJ in these videos: Productivity and Refactoring Tips
Follow-up Refactoring Exercises (optional, after the workshop):

- Yatzy (FP): https://github.com/emilybache/Yatzy-Refactoring-Kata
- Gilded Rose (for OOP): https://github.com/emilybache/GildedRose-Refactoring-Kata
- Supermarket (modeling): https://github.com/emilybache/SupermarketReceipt-Refactoring-Kata
Workshop Code: https://github.com/victorrentea/clean-code-java (please clone and import in IDE in advance)
Agenda
The agenda should be tailored for your team in a prep-call.
- Refactoring Concepts & Team Work

o Definition, what is NOT, when NOT to refactor
o Refactoring Opportunities: Boy Scout, Comprehension-, Repent-, Preparatory-, Planned-, TDD
o Common Stoppers: Time, Focus, Fear, Merge Conflicts
o Teamwork: Code Review, Pair Programming, Branches, Collaborative Code Ownership
o ⭐Baby-steps Refactoring: large changes in tiny steps, using IDE refactoring; Micro-commits
- Code Smells – a detailed review of the most common micro-design issues of today + ways to fix them
- Expressive Code
o Refining names, extracting explanatory variables, methods, and constants
o Function signature: booleans and default arguments, numbers of parameters
o Function Depth and Cognitive Complexity; Guard Clauses
o The Clean Switch rules
o Finding seams to break code: spaces, indents, comments
o Exceptions Best Practices
- Clean OO Code
o True Encapsulation, Behavior next to State
o Enforcing Domain Constraints, Null-safe data structures
o Finding and extracting Value Objects
- Clean FP Code
o Functional Programming Philosophy (vs Imperative)
o Replacing loops with FP pipelines
o Pure Functions; Functional Core – Imperative Shell Segregation
o Immutable Objects: cost/benefit, collections, implementation patterns
o [java] Optional<> patterns and anti-patterns
- Surviving a Legacy Codebase [optional]
o Special refactoring techniques: Extract Method Object, Split Phase, ..
o Cookbook: Refactoring Monster Methods; Mikado Method
o Golden Master Testing Technique
- Refactoring Moves
o Extract and Inline of: Variables, Methods, Parameters, Constants and Interfaces
o Change Method Signature, Introduce Parameter Object, Move Function
o IDE productivity tips
- Larger Refactoring Exercises (2-4 hours) on
o Production Code snippets from the audience
o Ensemble Refactoring Kata (Mobbing)
Clean Code for JavaScript/TypeScript – 1 day

In this immersive workshop, you will dive deep into the principles of clean code and the art of refactoring in
JavaScript. Clean code is not just about writing code that works; it's about writing code that is easy to
understand, maintain, and collaborate on.
What to expect
- Learn the fundamental Principles of Clean Code

- Acquire Practical Code Refactoring Techniques
- Analyze real-world examples of poorly written code and collaboratively refactor them into clean,
elegant solutions.
- Master industry best practices for writing clean, efficient, and reliable JavaScript code.
- Identify common code smells and anti-patterns and learn how to address them effectively.
- Engage in hands-on exercises to apply the concepts you learn and gain confidence in refactoring code.
- Every question is welcome, triggering live debates
- Receive a valuable Certificate of Completion to add to your portfolio
Agenda
- Refactoring: definition, opportunities: Boy Scout, Comprehension-, Repent-, Preparatory-, and Planned
- Baby-steps Refactoring: break large changes in tiny safe steps, using IDE refactoring; micro-commits
- Names that are consistent, searchable, explanatory but concise
- Method Parameters: number of parameters, default parameters, boolean parameters
- Method Body: SRP and SLAb principles, function depth and Cognitive Complexity; Guard Clauses
- Data Structures: avoid prototype overload, Object.assign, objects via clojures (≤ES5), ES6 classes
- Embrace Functional Programming: pure functions, split loop and use array ops
- Concurrency: from callback hell > promises > async/await
- Error Handling patterns
- Code Smells: overview of most common micro-design issues today + solutions
- IDE Refactoring: Extract/Inline variables, methods, and constants; change signature, and more
- Larger Refactoring Exercise (~2 hours), ideally extracted from codebase of participant’s projects
Note: if targeting TypeScript, the agenda will be slightly modified.
Unit Testing – 2 days ⭐

This training aims to upgrade developers from I have to write tests to Living a better life thanks to tests.
Constantly looking through the maintenance perspective, we go from immediate test-writing tricks and
techniques to best practices in the design of tests, and up to what writing tests can tell us about the design of
our production code. A deep discussion will revolve around best practices and pitfalls of using mocks in our tests.
Along the way, we'll understand what Test-Driven Development and Behavior-Driven Development mean, as
well as some special testing techniques like Golden Master, Characterization Tests, Approval Tests, and more.
Then, at the end, we'll see how we can cover more code with wider-scoped integration tests using Spring Boot
(if the group speaks Java).
Main Goals:
- Motivate developers to test thoroughly their code
- Understand the design insights provided by testing
- Review the state-of-the-art testing techniques of today
Ideal audience: Developers that have

- Written/fixed at least 100 Unit Tests
- Working knowledge with mocking frameworks (e.g., Mockito)
- At least 2-3 years of experience and/or bright-minded
(The content can be scaled down for less experienced groups)
Prep-work:
- Read: Excellent article about different levels of testing - Practical Test Pyramid
- Coding Exercises to practice writing unit tests and mocks BEFORE the training, (mandatory for those
with less working experience) https://github.com/victorrentea/unit-testing-katas - (Java)
- [optional] Watch: A recorded TDD Coding Kata: https://www.pentalog.com/pentabar/tdd-live-coding-
kata
- Send me samples of Unit Tests (for dedicated sessions only)
o 1-3 typical test classes of ≤ 100-200 lines + production code under test
o I don’t need all the code around it I will fill create the missing code to make it compile
o At least one participant should be familiar with the code.
Deliverable in: Java, Kotlin, Scala, PHP, TypeScript, or C#
Code: https://github.com/victorrentea/unit-testing
Agenda
- Fundamentals
o Why test, why test-first, cost of tests, test-around-bugs
o Key Concepts: Line/Branch Coverage, Mutation Testing, Test Isolation, Flaky Test
o Testing Strategies: Pyramid vs Honeycomb
o Types of tests: Unit Tests (solitary vs social), Integration Tests
o Test anatomy, naming tests, single assert rule
- Test-Driven Development (TDD) – 2 hours
o Rules of TDD, Red-Green-Refactor workflow
o TDD Styles: Chicago(“triangulation”) vs. London(“outside-in”)
o TDD Pros / Cons, TDD in real-life
o Exercise: Classic TDD Coding Kata
o Exercise: Outside-in TDD Coding Kata [optional]
- Testing Techniques
o Creating test data
o Expressive asserts with Assert4J (assertThat)
o Parameterized Tests – uses/abuses
o Using “.feature” files: best practices, Behavior-Driven Development (BDD/ATDD)
o Testing Legacy Code: Characterization Testing and Golden-Master technique
o Approval Testing
o Subcutaneous tests, @VisibleForTesting
o Nested test classes
o Extending JUnit Framework – examples
- Using Mocks – 2 hours
o Reasons to Love (3) and Hate (3) Mocks
o Basic Features: stubbing, verification, argument matchers, captors, mocking statics…
o Advanced/Dangerous Features: lenient, any, doReturn, spy, times, noMoreInteractions
o Exercise: Covering Legacy Code with tests
- Design Hints from Unit Testing - 4 hours
o What am I testing here? Syndrome
o Precise method signatures
o Object Mother (over stubbing getters)
o Agnostic Domain Tests (aka Dependency Inversion Principle)
o Split by Layers of Abstraction (over partial mocks)
o Split unrelated complexity (over bloated shared test fixture)
o Mock Roles, not Objects! (over fine-grained tests)
o Decouple complexity, Functional Core/Imperative Shell segregation
o Immutable objects (over temporal coupling)
- Testing with Spring Framework – 4-6 hours
o Testing with DI: @Import, @MockBean, @Primary, profiles, test properties, @DirtiesContext
o Testing with Persistence: in-memory DB, @Transactional tests, cleanup, @Sql, Testcontainers
o Testing with External APIs: essentials of WireMock, recording proxy; vs MockServer
o Testing your API: MockMvc, strategies, building custom testing DSLs, testing authorization
o OpenAPI-freeze approval test
o Exercise: refactoring from a mock-based test to an end-to-end system test
o Optimizing run time of integration tests
o [optional] Consumer-Driven Contract Tests with Pact 1h
o [optional] Spring Cloud Contract 1h
- Code review of unit tests code from projects of participants [optional]
Software Architecture – 2 days ⭐

Join us in this engaging workshop where we'll dive deep into mainstream architecture styles currently
employed in backend systems. We'll explore Layers, Ports-and-Adapters, Onion, Vertical Slice
Architecture, and the Modular Monolith. To bring these concepts to life, we'll refactor a sample Java
application in each style, weighing the pros and cons along the way. We will also discuss how the features
of modern frameworks can help simplify these architectures.
Rather than getting lost in language and framework specifics, we'll focus on the correlation between
these architectural guidelines and the fundamental design principles, keeping in mind the constraints of
our system. This workshop is open to backend developers, tech leads, architects, or anyone interested in
a lively and informative exploration of software architecture.
By the end of this course, you will have:
Understanding:
● The Dependency Inversion Principle and its role in concentric architectures.
● How to clarify logic through the Separation by Layers of Abstraction.
● The principles underpinning the Onion, Hexagonal, and Clean Architectures.
● The main challenges in breaking down a codebase into vertical slices.
Capabilities:
● How to protect your core logic against API models to simplify it.
● Extracting orchestration logic into Facades.
● Comparing and implementing strategies to decouple a monolith into subdomains.
This Training is for You if:

● You are a developer with hands-on experience in software design.
● You are an architect or technical lead keen on discussing pivotal design decisions.
● You are an eager learner aiming to delve into the realm of software architecture.
If you want to take the best out of this training, you can prepare in advance by:
● READ this article about Clean Architecture:
https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html
● READ this comparison of the main architectural styles today:
https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexagonal-onion-clean-cqrs-how-i-put-it-
all-together/
● READ this intro to Vertical Slice Architecture https://jimmybogard.com/vertical-slice-architecture/
● WATCH this Intro to Modular Monolith: https://www.youtube.com/watch?v=Xo3rsiZYsJQ
● THINK of some ideas/questions to debate and send them to me (victorrentea@gmai.com) 1 day in advance
Code: https://github.com/victorrentea/clean-architecture
Agenda:
● Fundamentals – 1 hour
o Coupling and Cohesion: granularity and tensions
o SOLID principles, Beck's Rules of Simple Design
o Uniformity vs Pragmatism, under-design vs over-engineering
● Domain Model Design – 1 hour
o Identifying and delineating the “domain code”
o Align domain code with the problem to solve (DDD ubiquitous language)
o Rich domain entities that hold behavior (OOP)
o Validation: strategies to maintain domain invariants
o Domain vs Data Transfer Objects
o The Fallacy of Auto-Mappers (eg. MapStruct, …)
● Dependency Inversion Principle – 1+ hour
o Protecting the Domain: why and when?
o Adapter Pattern, plus a pragmatic variation
o Enforcing architectural boundaries – techniques
o Exercise: refactor integration logic out of domain
o Testing Integration Layer
● Orchestrating Logic – 1 hour
o Layered Architecture
o Application Services and the Separation by Layers of Abstraction Principle
o The need for Controllers?
o Evolutionary Design – hands-on
● Clean Pragmatic Architecture ✨ – 1 hour
o Domain vs Persistence – debate
o Testing the Domain Logic
o Use-case-optimized Query
o Classic Concentric Architectures: Clean, Onion, and Hexagonal; overengineering.
● Vertical Slice Architecture – 1-2 hour
o Fundamentals
o Pitfalls and Best Practices
o Exercise: Refactoring from Clean Architecture to VSA
● Command-Query Responsibility Segregation (CQRS) – 1 hour
o Endpoint-specific DTOs
o Fine-grained commands and Task-Based UI
o Data Change Contention
o CQRS Interpretations
● The Modular Monolith (Modulith) – 3 hours
o Migrating from a Legacy Big Ball of Mud to Microservices – steps & benefits
o Finding Module Boundaries
o Data Decoupling Levels
o Module API: Calls (Queries and Commands) and Events
o Relationships between Modules
o Exercise: Spring Modulith
● Wrap-up: Main take-aways; Quiz & Debates
Microservice Patterns – 2 days

Welcome to our focused training on Microservices Architecture. In this session, we will dissect essential
Design Patterns and brainstorm on the critical decisions encountered in a microservices setup. While touching
upon cloud development, our discussion remains unbiased towards any provider, concentrating on the design
alternatives and the inherent trade-offs. To foster a rich understanding, we will supplement our debates with
occasional Java code examples where necessary or seek examples from audience to showcase implementation
details. Join us as we navigate the foundational principles of microservices, equipping you with the tools to
wisely manage your microservices journey.
Agenda
- Introduction 10m
o Definition and History
o Benefits and Drawbacks
o CAP Theorem
o Integration Paradigms: RPC, Message Queues, Shared DB, File transfer
- Design Principles 1h
o Single Responsibility Principle
o Domain-Driven Design
o From Monolith to Modulith to Microservices
- Resilience Patterns 1h
o Timeouts, Retry and Circuit Breaker
o Rate Limiter and Bulkhead
o Load Balancing and Auto-scaling
- API Design and Management 30m
o RESTful APIs, Swagger/OpenAPI
o GraphQL
o API Gateway / Backend For Frontend (BFF) pattern
o Service Discovery
- Messaging Patterns 1h
o Comparison: Messages vs RPC
o Communication Styles: request/response, pub-sub, fire-and-forget
o Messaging Features: persistent q, durable subscriber, priority q, claim check, DLQ, competing
consumers
o Smart endpoints and dumb pipes
o Choreography vs Orchestration
o Event-Sourcing overview
- Distributed Consistency 1h
o Idempotency
o Saga Pattern, Compensations and Reservations
o Transactional messaging: Outbox table, Change Data Capture (Debezium)
o Exercise: design a food delivery application
- Monitoring and Logging 20m
o Distributed Tracing
o Centralized Logging
o Health Check endpoint
o Monitoring with Prometheus/Grafana
- Build and Deploy 30m
o 12-Factor App for Cloud Development
o CI/CD
o Service Registry
o Service Mesh pattern
- Security 1h
o Authentication and Authorization strategies
o API Security Top 10 Vulnerabilities, with examples
o Secret Management
o Securing Inter-service Communication
- Testing 30m
o Integration/Component Testing
o Contract Testing with Pact
Pragmatic Domain-Driven Design (DDD) – 2-3 days

Domain-Driven Design is a battle-proven technique established almost 20 years ago, that can significantly
simplify the evolution and maintenance of software tackling a problem with a complex domain. DDD can be
applied at two levels: strategic at the organization level (e.g., to delineate microservices), as well as tactical in
day-to-day coding. First, we will review the DDD philosophy and the key strategic-level decisions. But the main
part of the training will revolve around refactoring a traditional codebase built around an anemic domain
model, towards a more DDD-style code using a Rich Domain and Aggregates. Throughout our journey, a
question will follow us: “How does that help me?”, asked from a skeptical/pragmatical perspective.
By the end of the live online course, you’ll understand:

● Domain-Driven Design philosophy and goals
● What is a Ubiquitous Language and why it’s critical when tackling a complex domain
● The benefits and costs of a Rich Domain Model
● The core DDD patterns at both strategical and tactical level
● The principles underlying the Onion-, Hexagonal-, Ports-and-Adapters, and Clean- Architectures

● Implement the key DDD Tactical Patterns including App/Domain Service, Value Object, Aggregate, Domain
Events…
● Use Aggregate design in real-life scenarios
● Use Domain Events as an alternative to orchestration
● Progressively refactor a traditional codebase following DDD principles (the so-called “Lite DDD” approach)
● Apply many techniques in any project (even not “officially” DDD)

● You are a mid-senior (Java) developer who wants to upgrade his/her design skills
● You are an architect that regularly writes or reviews code that wants to carefully design a critical project
● You are part of a project using or starting to use DDD
● You are an avid learner who wants to understand the software architecture used for the most complex
domains in the world
Prep-work: Participants with no prior contact with Domain-Driven Design philosophy should read
- Clean Architecture primer: https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html
- DDD Terms: read at least pages 1-25 from: https://www.domainlanguage.com/ddd/reference/
- [Recommended] Have a taste of the DDD philosophy
o Domain-Driven Design Distilled by Vaughn Vernon (on Amazon), or
o DDD Quickly by InfoQ: https://www.infoq.com/minibooks/domain-driven-design-quickly/
(free)
This is not an entry-level training.
Code: https://github.com/victorrentea/clean-architecture
Code: https://github.com/victorrentea/ddd
Agenda (covered in non-linear style):

- Fundamentals (2 hours)
o DDD Philosophy, when to use/avoid, typical misconceptions
o Ubiquitous Language – why it matters
o Key values of DDD: Biz Collaboration, Domain Distillation, Exploration, and Bounded Contexts
- [Optional] Event Storming Workshop (2 hours), including PO/BA/DE

o Identifying Pivotal Events, Commands, Views, and Aggregates
o Experiencing Collaborative Domain discovery
- Onion Architecture (3-4 hours)

o Layered Architecture: Presentation, Application, Domain, Infrastructure; relaxed variant
o Anti-Corruption Layer: Adapter, Dependency Inversion Principle; pragmatic variation
o Application Services vs Domain Services, via evolutionary design
o The Onion Architecture (aka Ports-and-Adapters, Hexagonal) + a pragmatic variation
o ⭐ Hands-on refactoring
- Vertical Slicing (2-3 hours)

o Strategic Relationships between Bounded Contexts [optional]
o Drawing Boundaries – hints: changes, performance, orchestration
o Tactics: limiting Entity object links and inter-domain calls
o Data breakout: Splitting Entities, Maintaining data in sync
o Refining Bounded Contexts interactions: calls, commands, events
- Microservice patterns [optional] (½ - 1 day) – find them in my Design Patterns agenda
- Light Tactical Patterns (2 hours) – Micro-design of Domain Model

o Rich Domain Model: what, why, how, pitfalls of adding logic to the model classes
o Value Object: rules, ways to identify
o Entity: guarding domain invariants
o Identifiers: micro types, Semantic ID
o ⭐ Hands-on refactoring: from an anemic “traditional” codebase to a Rich Domain Model
o [Java] Hibernate tricks (consistent @Entity, immutable @Embeddable, ID Type)
o [Java] Spring tricks: @DomainEvents, Stereotypes, Aspects, Spring Data JPA Specifications
- Aggregate Design (3-4 hours)

o Aggregate as the consistency boundary for changes
o Domain Events, Event Sourcing (preview)
o Repository, Factory (briefly)
- Wrap-up (1 hour):
o Your first DDD project: the right domain, preparation, reading guide, planning, people
o DDD Pitfalls: DDD God Fallacy, overengineering, internal framework mania, Tech-tiger bias
o "Light DDD": 10 Takeaways applicable in any non-DDD Project
o More debates
Mastering the new Java Language Features – 1 day

Discover the best new features of the Java language and learn modern design patterns enabled by them.
If the participants are already fluent with the Java 8 lambda/Stream syntax, the focus shifts on the latest
additions to the language.
Optional Preparation:
- Watch Java 8 Stream API screencast on YouTube.

- Solve the exercises in victor.training.java8.stream.order.SearchStreams and
TransformStreams that you can find on master branch on this git:
https://github.com/victorrentea/java8-workshop.git
Agenda
- Lambda syntax (advanced): method references, target typing, effectively final

- Stream API: recap, pitfalls, Stream from File and Database
- Exceptions vs Lambdas: wrapping checked exceptions and the Try monad
- Correct usage of Optional in API design - debates
- Functional Design Patterns: Loan Pattern, BiFunctions on enums, Currying [optional]
- Interfaces with default and private methods (17) – why and when
- Parallel streams: mechanics, accumulating operators, parallel collectors, perils
- DevEx: var (11), text blocks (17), instanceof (21), String interpolation (±24)
- Enhanced Switch (17)
- Records (17)
- Sealed classes and pattern matching (21); the death of the Visitor Pattern
- Platform improvements: GraalVM and nativeimage, super-fast Garbage Collectors, helpful NPE
- Virtual Threads - Project Loom (21)
- Minor API enhancements: CompletableFuture, Files, Optional, String, Stream
- The future of Java Language…
Spring Framework – 3 days

The duration can be reduced to 2 days if we remove some chapters from the agenda.
Must-have a prep-call to tailor this long agenda to what your team really needs / uses. 👌
Target audience:
a) Entry-level developers with no/little prior contact with Spring
b) Experienced developers with hands-on experience with Spring
⚠️ For the best experience, try to avoid mixing people from both categories in the same group.
Prep work:
- [MUST] Prepare questions, debate topics, and challenging code samples from your project
- [MUST] Clone the project and mvn install it from https://github.com/victorrentea/spring
- Juniors can get familiar with the basics via a video course on Udemy/Pluralsight/Coursera …
- More experienced developers can try out samples from baeldung.com covering topics in the agenda
Agenda
- Spring Container (2h)
o Defining Beans: component-scanning, @Import, and @Bean
o Dependency Injection Styles + Lombok tricks
o Bean Lifecycle @Scope
o Spring Profiles and ConditionalOn…
- Events and Startup (.5h): @EventListener best practices, initializers
- Configuration (.5h): @Value, @ConfigurationProperties, config sources, Cloud Config Server
- Spring Boot (.5h):
o Library version management, starters
o Convention over Configuration: AutoConfiguration, devtools
- Aspects 1h: concepts, proxy implementation, pitfalls, writing an @Aspect
- Transaction Management 2-4h
o Database ACID transaction, anomalies
o @Transactional mechanics: propagation, rollbacks, read-only tx, after-tx hooks
o Best-practices and pitfalls using Transactions, tuning performance [opt]
o JPA integration: write-behind, auto-flushing, lazy-loading, and 1st level cache
- Multi-threading: Spring thread pools, @Async, and non-blocking REST APIs; @Scheduled
- Caching: annotation and programmatic, ⚠Pitfalls (stale cache, distributed cache, hit/miss ratio)
- REST Endpoints 2h
o REST API design best practices, validation, documentation
o @RestControllerAdvice
o [optional] Introduction to WebFlux 1h (see my Reactive Programming training for a deep-dive)
o [optional] WebSockets: concepts, debug, queue/topic, security, common patterns, testing
- Observability 1h
o Spring Actuator features, adding endpoints and health checks
o Exposing metrics with Micrometer
- Spring Security 2-4h
o Spring Security Architecture, Custom Security Filters
o Authentication via: User-Password login form, Basic/api-key, Preauth Headers, JWT Token
o Authorization: URL pattern vs annotations, role vs feature-based authz, data-security, testing
o Spring OAuth2 integration (example using KeyCloak) – prep video: Intro to OAuth
o (For more please see my ‘Secure Coding’ training)
- Messages on Queues 1-2h
o Concepts: durability, topic vs queue, reply queue, consumer group, tracing, DLQ, correlationID
o Spring Cloud Stream (the new Functional-Style)
o [optional] IntegrationFlows DSL
- Testing 4h+
o Testing with DI: @Import, @MockBean, @Primary, profiles, test properties, @DirtiesContext
o Testing with Persistence: in-memory DB, @Transactional tests, cleanup, @Sql, Testcontainers
o Testing with External APIs: essentials of WireMock, recording proxy; vs MockServer
o Testing your API: MockMvc, strategies, building custom testing DSLs, testing authorization
o OpenAPI-freeze approval test
o Exercise: refactoring from a mock-based test to an end-to-end system test
o Optimizing run time of integration tests
o [optional] Consumer-Driven Contract Tests with Pact 1h
- Spring Batch [optional] 2-3h
o Concepts: Step, Job, Listener, Execution Context, Transaction control, Resume
o Using Listeners to track metadata
o Fine-Tuning Performance: Chunking, Parallel Steps, Multi-Threading processing
- Wrap-up:
o Real-life scenarios - Brainstorming
o Spring Overview: main features, strengths and weaknesses, best learning sources
Secure Coding in Java – 2 days

Overview
This workshop starts by reviewing the essential cryptography and web-security concepts and techniques.
The top web attacks identified by OWASP (https://owasp.org/) are then explained and fixed with Spring
Framework in several ways comparing the tradeoffs of each option. We’ll then dive into the two main
coordinates of security: authentication and authorization and we’ll explore the mainstream practices as
well as some advanced use-cases that will lead us to discover many details of the Spring Security
framework.
This Training is for you because:
- You had security incidents in production.

- You got a pen-test/security audit, and you want to prevent the issues discovered from recurring.
- Security is an early concern in your project, due to its sensitive nature.
- You are looking for a review of your team’s secure coding practices.
Prerequisites: Prior contact with security concerns is recommended
Prep-work:
- Read a bit in advance about the topics in the agenda that interest you the most. (request links)
- Watch Introduction to OAuth: https://www.youtube.com/watch?v=996OiexHze0
The agenda will be adapted for the technical stack / security techniques in use, ideally guided by the
client pen-testing findings.
Agenda
- Cryptography Fundamentals (2 hour)

o Hashing, Salting, bcrypt, Encryption (symmetric / asymmetric), Digital Signatures
o Certificates, Certificate Authorities, self-signed certificate, keytool overview
o [optional] Java workshop experimenting all the above topics (raw)
o TLS, mTLS; [optional] Exposing https endpoints on a Spring Boot App
o Web Sessions and Cookies
o Security Architecture Overview: DMZ vs Intranet, WAF, Security Proxy
- OWASP Web App Top 10 Vulnerabilities (link)
o Cross-Site Request Forgery (CSRF)
o Cross-Origin Resource Sharing (CORS)
o Injection of SQL/NoSQL/JPQL, javascript (XSS, CSP), OS commands, url parts (SSRF)
o Risks of handling files: upload, zips, XML/YAML attacks, insecure deserialization, viruses
o Vulnerable Dependencies (CVE): fixing strategies; security scanning tools
- OWASP API Security Top 10 Vulnerabilities (link)
o Broken Function- or Object- Level Authorization
o Excessive Data Exposure
o Lack of Resources & Rate Limiting
o Mass Assignment
o Flaws in Configuration, Monitoring, and Deployment
- Securing Applications with Spring
o Authentication: Form Login, Basic, API Token, Pre-Auth headers, JWT token
o Function-Level Authorization: URL-patterns and annotations, Role- vs Authority- based
o Spring Security Architecture, writing a custom filter, debugging
o Object-Level Authorization: data jurisdiction, permission evaluator, data visibility
o Unit-Testing Backend Authorization
- OAuth2 (4-5 hours)
o Tokens, Actors, Front- vs Back- channel, Single-Sign On (SSO)
o Flows: Authorization Code, Client Credentials, Implicit Flow Authorization Code+PKCE
o Social Login (eg “login with Google”), OpenID Connect
o Workshop: Spring OAuth using KeyCloak
o [optional deep-dive] Example attacks on OAuth; dissecting the exchanges (2 hours)
JPA/Hibernate Performance Tuning – 2 days

Everyone thinks they know Hibernate. And then they have their first performance issue. Or they try to deeply
refactor their JPA model. And then, they search for this training.
By the end of the live online course, you’ll understand:

● Why Hibernate is by far the most complex Java library in broad use
● The internal behavior of Hibernate that has an impact on performance
● The exact lifecycle of an Entity
● How Hibernate controls transactions

● Locate the performance bottlenecks
● Fix the root cause of performance issues and improve the overall performance of your application
● Write highly efficient read queries
● Optimize writes to DB and batches
● Design safe and performant Entity models with Hibernate

● You are an experienced professional with strong practical experience with Hibernate
● [ideally] You had prior contact with tuning the performance of the interaction with a Relational Database.
Prep work (optional):

- ORM Exercise (“put the annotations”), for the less experienced: https://github.com/victorrentea/jpa-
assignment/
- Problems from the project: send me a series of questions / topics to debate
Code: https://github.com/victorrentea/jpa
Agenda:
- Chapter 1: Efficient Searching
o Lazy Loading: pitfalls and best practices
o N+1 Queries Problem + solutions; debate
o Paginated queries: pitfalls, best practices, UX Tricks
o Dynamic Queries with jpql+=, criteria, metamodel, specifications, fixed JPQL, and QueryDSL
o Tuning JPQL and SQL – practical hints
- Chapter 2: Designing a Clean, Performant Entity model
o Primitive links vs JPA links
o Persisting enums via Hibernate type mappers
o Bidirectional JPA Links – best practices
o Rich Deep Modeling using @Embeddables, ElementCollections and safe-guarding entities
o Advanced mapping: @MapsId, Composite PKs
o List<> vs Set<> of Children; implementing hashCode on Entities
- Chapter 3: Efficient Transactions
o Spring @Transactional: mechanics, propagation, error handling, after commit hooks
o Persistence Context as 1st Level Cache and Write Buffer (aka write-behind)
o Auto-flush dirty entities: embrace or reject?
o How to detect and avoid Connection Starvation issues
o Transaction management best practices
- Chapter 4: Batch Inserting
o Generating Primary Keys efficiently
o getReference()
o Batching inserts
o High-performance Spring Batch jobs – hands-on (on demand)
- Chapter 5: Caching (optional)
o Enabling Second-level Cache for Entities and Queries; tuning
o Comparison with Spring @Cacheable
- Chapter 6: Working with Large Files
o Domain modelling alternatives
o Streaming CLOB/BLOB data
- Chapter 7: Updating Entities
o Mastering .merge() operator
o Concurrency Control using optimistic and pessimistic locks
o [opt] Bulk update JPQL queries - pitfalls
Java Performance – 2 days ⭐

A deep dive in Java Concurrency, Memory Management, Profiling, and Benchmarking, spiced with under-the-
hood details of the JVM and debates around typical performance issues of Java projects. The workshop is
packed with experiments distilled from real-life projects to explore and demonstrate different performance
issues.
Prerequisites: Solid knowledge of the Java Language. Ideally: prior contact with performance issues.
Prep-work:
- CompletableFuture Workshop:
o Watch this introductory video: https://www.youtube.com/watch?v=PL_i--e9dow
o Solve the exercises on this project git
- Bring as many performance issues you encountered by now; ask your friends too for more.
- [optional] Install tools: VisualVM, Java Mission Control
- [optional] Study in advance heap-dumps of some memory leaks, available here
Code (please clone in advance):
- Profiling Project: https://github.com/victorrentea/performance-profiling
- Main Project: https://github.com/victorrentea/performance
Agenda:
- Introduction:
o War stories from participants
o Key Concepts, Metrics and Questions
o Principles and Strategies to improve Performance
o Typical bottlenecks of modern applications
- Multi-threading
o Thread Pools: mechanics, tuning parameters, typical usage scenarios
o Multi-threading Risks: race bugs, deadlocks, thread pool starvation
o [on request] Concurrency Primitives: Lock, Semaphore, CyclicBarrier, wait-notify
o Concurrency Control: ‘synchronized’, atomic primitives, synchronized+concurrent collections
o Exercise: Designing a thread-safe concurrent workflow
o Non-blocking concurrency with CompletableFutures, Reactive and Virtual Threads
o Spring support: ThreadPoolTaskExecutor, non-blocking HTTP Endpoints, @Async
o Exercise: parallelizing a non-blocking REST API
o Parallel streams: mechanics, best practices, pitfalls
- [optional] CompletableFuture deep dive workshop (4h – 8h with participants hands-on)

o Combining, Chaining
o Exception handling
o Controlling Parallelism
o Best Practices and Common Patterns for Non-blocking Flows
o Testing & Debugging
o Advanced: Tracing (ThreadLocal), Monitoring (Micrometer) & Profiling (JFR)
- Tracing the Bottleneck:

o Execution profiling with Glowroot, Java Flight Recorder / Java Mission Control, Micrometer
o Exercise: Using a “flame graph” to detect bottlenecks in a sample app
o Load testing: principles and techniques
o Benchmarking with Gatling, jMeter, Java Measuring Harness
o JIT Compiler: mechanics, dynamic optimizations, writing JIT-friendly code
- Memory Management
o Java Memory Model: old/young, metaspace, TLAB
o Garbage Collector: Key concepts, Monitoring, GC Types
o Techniques for using less memory
o Thread Local data: best practices, propagation over thread pools, pitfalls
o Heap Dump analysis: retained/shallow heap, GC Roots, profiling allocations
o Exercise: Tracing ten types of Memory Leaks (some heapdumps are here)
- Caching [optional]
o Principles, cost-benefit-risk of caching, core parameters
o What & Where to cache data: comparison
o Maintaining cache consistency: eviction, TTL, distributed cache, best practices
- Tuning JPA Performance 1-2 days (not included⚠️)
o Many Java applications are bottlenecked by the way they use JPA/Hibernate. On request, we
can include JPA (1-2 more days) – see the other topic in my agenda.
Reactive Programming – 3 days

Deliverable in: Java or Kotlin; This training can cover:
➢ Project Reactor + Spring WebFlux, and/or
➢ rxJava - Android/UI flavored
Overview:
The first challenge when approaching reactive programming is understanding WHY and WHEN NOT to
use it. Starting from ‘classic’ blocking web endpoints, we’ll benchmark the bottleneck that occurs under
heavy load and then explore the different historical alternatives to Reactor. Besides exploring dozens of
operators, the focus will remain on understanding the signals that drive all reactive flows, as this is the
key to unlocking the mysteries of backpressure, hot publishers and avoiding common pitfalls when
starting to work with Reactor. We will then use this knowledge to approach several typical reactive flows,
drawing conclusions about the best way to write the code to be maintainable and safe. After a roundtrip
of Spring WebFlux features and quirks, we’ll then talk about 2 tough tasks: testing reactive flows and
progressive migration of blocking code to reactive flows, and if there’s time left, about performance
tuning.
This training is for you because:

- Your project uses Spring 5 WebFlux
- You want to optimize a heavy-loaded API or a heavy batch workflow
- You had bugs and long headaches when trying to use Reactor in your project
- Or simply you just want to master the most complex programming paradigm in the world
Prerequisites:
- Fluency with Functional Programming concepts: .filter() .map(), lambda syntax, immutable
objects
- Prior contact with multi-threaded code
Preparation:
⚠ This is a very challenging workshop ⚠
It’s imperative to allocate 2-8 hours to go through the prep work, alone or in pair programming (ask your
manager)
- The Main Workshop:
During the workshop, we will spend a lot of time solving some prepared problems (eg
C1_Creation.java) for which we’ll try to pass some pre-written unit tests (eg C1_CreationTest.java).
Please🙏 spend several hours on that code in advance to get more familiar with the concepts we’ll
be juggling with for long hard hours.
- Alternatively, check out the ProjectReactor’s official lite workshop with more explained theory is this
(est work time ≥ 3-4 hours): https://tech.io/playgrounds/929/reactive-programming-with-reactor-3/Intro
- If you get stuck, you can find the solutions on our project’s Git ( eg: ‘Part01FluxSolved.java’ )
- A good workshop (free slides and code): https://github.com/nurkiewicz/reactor-workshop
Code: https://github.com/victorrentea/reactive
Agenda
- Introduction
o [optional, basics] Recap: functional pipelines with Java8 Streams
o Blocking REST Endpoints: trace a thread pool starvation issue
o Alternatives to Reactive: CompletableFuture, coroutines(kt), Virtual Threads (Project Loom)
o Reactive Streams Spec
o Mono, Flux
o Understanding Marble Diagrams
o Signals: next, complete, error, request, subscribe, cancel
- Core Operators
o Immediate: just, empty, error, never, range, fromIterable
o Delayed: delay, interval, delayElements
o Immediate Operators: distinct, filter, map, first, take, contains, all
- Enriching Data
o flatMap vs concatMap vs flatMapSequential
o Batching requests: buffer, bufferWindow
o Handling Empty: defaultIfEmpty, switchIfEmpty
o Async filtering with.filterWhen
o Parallelizing work: Tuples, zip, zipWith, zipWhen
o Use-case Context design pattern
- Performing Side Effects
o Fire-and-forget using doOnNext
o Parallelization, cancellation
- [Hands-on] Migrating a blocking codebase to Reactive Programming
o Schedulers: CPU vs IO, best practices, ParallelFlux
o Calling blocking code in a safe way on boundedElastic scheduler
o CompletableFuture integration
o Bridging to a callback-based model: Sinks
o Reactive REST: Endpoints, and WebClient
o Reactive NoSQL: Mongo, Cassandra, Redis
o Reactive SQL: R2DBC
o Reactive Messages: send/receive
o Kafka Streams [optional]: KStream, KTable, Spring Cloud Stream Functions
- Infinite Fluxes
o Preventing cancellation with onErrorContinue
o GroupedFlux
o Time series operators: scan, reduce, window, buffer, sample, merge, concat, combineLatest
o Hot vs Cold Publisher
o In-memory broadcast using Sinks
o Caching Hot Publishers: replay, cache, connect, autoConnect
- Resilience
o Error handling patterns
o Timeout and Retry
o Back-pressure
o Throttling: rate-limiting, resilience4j integration
o Challenges of distributed systems under heavy load - brainstorming
- Testing
o StepVerifier vs .block()
o TestPublisher
o PublisherProbe + custom extension
o Detecting blocking code with BlockHound
o Controlling Virtual Time [optional]
- Debugging, Monitoring and Tuning
o Propagating metadata via Reactor Context
o Checkpoints and Hooks.onOperatorDebug
o Monitoring using .metrics, .elapsed, .timed
- Common Pitfalls and Workarounds
o Not subscribing / Resubscribing to Cold Publisher
o Loosing Data Signals (empty)
o .subscribe()
o Blocking in non-blocking threads
o Unexpected Cancelation
- Review of Production Code from the audience
Selected Sub-Topics / Debates [pro]

In case you are interested in only some subtopics, we could cover exactly what you are interested in, tailoring
a 100% specific agenda to suit your needs and make best use of the group's time.
Note: discussing items out-of-order and skipping the basics will typically require a rather more experienced
audience.
One-to-One Coaching [pro]

Intense one-to-one interactive sessions of 1-2 hours with 1-3 developers, adapted to their needs. The most
time-effective way I offer to grow one’s skills. For best results, a developer should attend a minimum of 3-4
sessions. The goal of this engagement is not to deliver software, but to accelerate the growth of developers.
Target Audience:
- Experienced developers trying to fill a gap in their skills (e.g., a framework)

- Key developers to which you want to provide an extra incentive for their great contribution
- Bright developers looking to skyrocket their coding and design skills
Activities, depending on your preference:
- Pair Programming sessions

- Assignments (homework) between sessions
- Code Reviews
- Discussions of any items from my training curricula, but also additional custom topics
Important: The fee is per-hour and considerably lower than the one for a full-blown live training.
DATE:
TBD
FEE:
BASE FEE (per day) = <request a quote> EUR
TERMS AND CONDITIONS:

● Fees are per day (not per participant)
● Training groups of 10 - 20 participants (max 25, but only if more experienced/enthusiastic)
● Delivery of 7 hours/day (e.g., 9:00 - 17:00, with 1h lunch break)
● Included: training slides (full of links for further research) and all the code we write, +git history.
● Included: prep-call to fine-tune the agenda and understand the challenges faced by the team
● Included: ⭐Follow-up support 2 weeks after the training, for any questions
● Included: Individual assignments (before and/or after), for selected topics
● Delivered as online webinar (via Zoom, Teams, ...)
● Options:
o On-site session (not online):
▪ In Bucharest, Romania = no extra fee
▪ Involving travel = +50% BASE FEE
o [webinar] Half-days (4h/day, AM / PM), with double number of days = +10% BASE FEE
o [webinar] Record the session = +20% BASE FEE.
LEGAL ENTITY DETAILS

● Company Name: Victor Rentea Consulting SRL
● Fiscal Address: Dristorului 91-95, Ap 1106, Bucharest 031538, Romania
● VAT Code: RO41987600
● Commerce Registry Number (ONRC): J40/16655/2019
Victor Rentea Consulting SRL

Victor Rentea

Offer - ALL

Uploaded by

Copyright:

Available Formats

You might also like

Offer - ALL

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Offer - ALL

Uploaded by

Copyright:

Available Formats

TRAINING OFFER FOR

Design Patterns and Principles – 2-3 days 2

Clean Code and Refactoring – 2 days 4

Clean Code for JavaScript/TypeScript – 1 day 6

Unit Testing – 2 days 7

Software Architecture – 2 days 9

Microservice Patterns – 2 days 11

Pragmatic Domain-Driven Design (DDD) – 2-3 days 12

Mastering the new Java Language Features – 1 day 14

Spring Framework – 3 days 15

Secure Coding in Java – 2 days 17

JPA/Hibernate Performance Tuning – 2 days 19

Java Performance – 2 days 21

Reactive Programming – 3 days 23

Selected Sub-Topics / Debates [pro] 25

One-to-One Coaching [pro] 25

Terms and Conditions: 26

Legal Entity Details 26

By the end of this live online course, you’ll understand:

And you’ll be able to:

This Online Training is for you because…

The agenda is fully configurable to suit your team's needs.

System Architecture – 1 hours

Forking Behavior: OOP vs FP implementation – 3-4 hours

Intercepting Calls – 1.5 hours

Creating Objects – 1.5 hours

Propagating Change - 2 hours

Microservice Patterns – 3-4 hours

Clean Code and Refactoring – 2 days ⭐

Deliverable in: Java, Kotlin, PHP, TypeScript, C#, Scala.

Prep work (mandatory):

Follow-up Refactoring Exercises (optional, after the workshop):

Workshop Code: https://github.com/victorrentea/clean-code-java (please clone and import in IDE in advance)

- Refactoring Concepts & Team Work

Clean Code for JavaScript/TypeScript – 1 day

- Learn the fundamental Principles of Clean Code

Note: if targeting TypeScript, the agenda will be slightly modified.

Unit Testing – 2 days ⭐

Ideal audience: Developers that have

Deliverable in: Java, Kotlin, Scala, PHP, TypeScript, or C#

Software Architecture – 2 days ⭐

By the end of this course, you will have:

This Training is for You if:

Microservice Patterns – 2 days

Pragmatic Domain-Driven Design (DDD) – 2-3 days

By the end of the live online course, you’ll understand:

And you’ll be able to:

This Online Training is for you because…

Agenda (covered in non-linear style):

- [Optional] Event Storming Workshop (2 hours), including PO/BA/DE

- Onion Architecture (3-4 hours)

- Vertical Slicing (2-3 hours)

- Microservice patterns [optional] (½ - 1 day) – find them in my Design Patterns agenda

- Light Tactical Patterns (2 hours) – Micro-design of Domain Model

- Aggregate Design (3-4 hours)

Mastering the new Java Language Features – 1 day

- Watch Java 8 Stream API screencast on YouTube.

- Lambda syntax (advanced): method references, target typing, effectively final