Functional Patterns with Java8 @Bucharest Java User Group
Download as pptx, pdf1 like42,862 views
The slides for the presentation I gave at Bucharest Java User Group. This session was the largest Romanian Java community meetup ever organized until now.
1 of 22
Downloaded 29 times
Ad
Recommended
Clean Pragmatic Architecture - Avoiding a Monolith
Clean Pragmatic Architecture - Avoiding a MonolithVictor Rentea Talk built based on several of my trainings: http://www.victorrentea.ro/#training
Covers: Clean/Onion/Hexagonal Architecture, Domain Entities, Value Objects, Repository, Extract When it Grows Principle, Dependency Inversion Principle, Clean Code and Design Patterns.
These are the backing slides of the talks given at JPoint 2017 and Devoxx PL 2017: https://www.youtube.com/embed/4-4ahz7zDiQ
Don't Be Mocked by your Mocks - Best Practices using Mocks
Don't Be Mocked by your Mocks - Best Practices using MocksVictor Rentea Do you ❤️ Mocks? When you write your first unit tests, especially on older codebases, mocking foreign code is key to survival. But as you grow older in the craft, you start piling up hours and days wasted to refactor fragile tests or to fix bugs that those heavy mock-based tests didn't catch. And so you start looking at Mocks differently.
Let's go through the key factors to consider to strike the optimal balance between what needs to be mocked away and what code should be tested in integration. There's sometimes a fine line there, often interwoven with strong emotions:
"Why am I testing this?"
"Argh… these tests take too long"
"Can this ever really break?"
etc...
Among the points that we'll touch on:
- Mocks vs Refactoring
- Mocks vs Reliability
- Fine vs Coarse Mocks
- Reproducibility
- Partial Mocks
- Mocking Statics
- Alternatives to Mocks
Speakers: Victor Rentea
Victor is a Java Champion and Independent Trainer with an impressive experience: thousands of developers in dozens of companies trained in dedicated company sessions. He is the founder of one of the largest developer communities in Romania, Bucharest Software Craftsmanship Community and a top international conference speaker.
To find more about him, join a live masterclass or call him in for a company dedicated training: victorrentea.ro
Clean Lambdas & Streams in Java8
Clean Lambdas & Streams in Java8Victor Rentea Are you using Java8 Lambdas & Streams in your core business logic? Then you might be having this strange feeling that it’s not Java anymore: at times it’s cryptic, barely readable.. This was the topic of the workshop with the same name that I held at VoxxedDays Bucharest 2017. These are the slides backing the that workshop.
As a summary, the materials walk through the functional features of Java8, adding details along the way about how we can keep the code clean as we embrace the Java 8 features.
The entire desktop screencast + voice it's on youtube, here: https://youtu.be/uH9A37k2QkU
The Art of Clean code
The Art of Clean codeVictor Rentea Slides of the talk held at JEEConf, Kiev and jPrime, Sofia. A personal view on the classic topics from the Uncle Bob's Clean Code bible, with some personal additions and tips&tricks. This topic actually represents the core of the training sessions that I provide as an independent trainer (www.victorrentea.ro)
Integration testing with spring @snow one
Integration testing with spring @snow oneVictor Rentea This document provides an overview of integration testing strategies and techniques. It discusses the differences between unit tests and integration tests, including that integration tests involve multiple layers and dependencies like databases, files, and web services, making them slower and more fragile. It also covers best practices for integration tests such as using an in-memory database, WireMock for stubbing external services, transaction management, and strategies for cleaning up after tests.
The Art of Unit Testing - Towards a Testable Design
The Art of Unit Testing - Towards a Testable DesignVictor Rentea Slides of the Talk I gave at Devoxx Belgium 2019.
=== Abstract ===
Focusing on the creative work without being terrified of breaking the existing behavior can make software development very addictive! Good automated tests can buy you that!
However, if your tests are not maintainable they may end up slowing you down and causing you painful headaches, compilation errors and spurious failures. To avoid that, your unit tests should be significant; expressive; clean; DRY; non-overlapping; and blazing fast. Writing good tests becomes the toughest challenge for any developer, no matter how battle-hardened: you need to balance risk with test maintenance costs, while looking out for test design smells that call for [risky] refactoring to drive your design towards a set of key principles (included:).
Principles that will end up shaping the way you craft the Production code itself. Because in the end, a good, clean design is more important than coverage%.
But testing gives you the best feedback to get there.
Grab a black coffee and join this snippet from Victor’s Pro Unit Testing #training, to learn about testing priorities, buggy tests, the shared @Before, Mocks vs Stubs and how to reduce them by "purifying" your logic, testing Legacy Code and refactoring @Spy-es out.
All of that in an entertaining, dynamic and memorable session.
Clean Code - The Next Chapter
Clean Code - The Next ChapterVictor Rentea The document discusses clean code principles such as naming conventions, small functions, avoiding nulls and side effects, and using classes as containers for logic. It also emphasizes writing code for readability through techniques like extracting methods, renaming variables for clarity, and using comments to explain intentions rather than restate code. The presenter advocates for clean code as a way to improve code quality and maintainability over time.
The tests are trying to tell you [email protected]
The tests are trying to tell you [email protected]Victor Rentea If tests are hard to write, the production design is crappy - goes an old saying. Indeed, writing unit tests gives you one of the most comprehensive, yet brutal, feedback about the design of your production code, but if it comes too late, many developers can’t stand it anymore and they will either stop testing or test more superficially. At the other extreme, others struggle to write contrived, fragile tests full of mocks that end up frustrating more than helping them. This talk reviews the main hints that unit tests provide you, from the most obvious improvements to some of the most subtle design principles.
Clean Code
Clean CodeVictor Rentea How should a professional software developer behave in code? What guidelines should one follow? How should we name our constructs? What about OOP principles? What's their real use?
This classic training module in my training curricula is the cornerstone of my professionalism. These are my conduit guidelines at work. I've held this training > 10 times, including at Voxxed Days Bucharest 2016 and at a Bucharest Java User Group meetup.
Clean pragmatic architecture @ devflix
Clean pragmatic architecture @ devflixVictor Rentea Victor Rentea introduces himself as a Java Champion, trainer, and speaker who focuses on topics like Hibernate, Spring, Java 8/FP, architecture, clean code, unit testing, reactive programming, and Java performance. He advocates building a deep, rich domain model with value objects and entities that encapsulate logic and enforce invariants. The document provides guidance on applying principles like separating concerns with layers, dependency inversion, and avoiding anemic domain models in order to build flexible, testable systems that are decoupled from frameworks and external dependencies.
clean code book summary - uncle bob - English version
clean code book summary - uncle bob - English versionsaber tabatabaee The document provides guidance on writing clean code based on the book "Clean Code" by Robert Cecil Martin. Some of the key points discussed include:
- Functions should do one thing and do it well, with a single level of abstraction and no side effects. They should fit on a screen.
- Names should be meaningful, avoid abbreviations, and use consistent vocabulary. Class names should be nouns and method names should be verbs.
- Code formatting is important for readability. Classes should not exceed 200 lines, functions a single screen. Variables should be declared near use.
- Comments should only explain why unusual decisions were made, not what the code does. Avoid commented out code or redundant comments
Extreme Professionalism - Software Craftsmanship
Extreme Professionalism - Software CraftsmanshipVictor Rentea Decades ago, IT started as a single engineering practice, but as time passed by it got increasingly fragmented. Conflicts broke out between testers vs developers vs sysadmins vs DBAs vs many other roles. Recently, developers themselves split into many subspecialties like backend/frontend/iOS/Android/microservices/functions/etc. The overspecialization we face today causes huge communication overhead, a low bus factor, lack of responsibility, blaming, repeated isolated patching and fulminating costs. The software craftsmanship movement is rising in this post-agile world with professionals eager to take control of their careers and continuously learn in the pursuit of mastery. This talk will show you practical ways in which to seed a continuous learning culture in your team or company, and foster the enthusiasm of your developers.
Software Craftsmanship @Code Camp Festival 2022.pdf
Software Craftsmanship @Code Camp Festival 2022.pdfVictor Rentea Decades ago, IT started as a single engineering practice, but over the years it grew increasingly fragmented. The overspecialization we face today, in the context of a management-first agile transformation leads to a lack of responsibility, blaming games, repeated patching, painful communication overhead, and fulminating costs. The software craftsmanship movement is rising in this post-agile world with professionals that take control of their careers and continuously learn in the pursuit of mastery. But changing mindset requires determined team efforts and communities, especially when working remotely. What techniques and tricks can you use to grow such a culture of learning in your team? Find out from the founder and lead of one of the largest software craftsmanship communities in the world.
This talk is about technical culture and attitude.
Vertical Slicing Architectures
Vertical Slicing ArchitecturesVictor Rentea Throughout the years, the Concentric Architectures (Onion, Hexagonal, Clean-..) have grown into the undisputed leader among backend systems architectures. With the rise of Domain-Driven Design, keeping your Domain ring 'agnostic' to the outside world has become the norm today. But history proved that any 'norm' in software architectures will cause overengineering if applied without criticism.
After a brief recap of these architectures, their pitfalls, and weaknesses, we'll see two alternatives that segregate code not in 'layers' or 'rings' but in vertical slices: Feature Slicing and Modular Monolith.
[Feature Slicing](vertical Slice Architecture) (aka *UseCase) has its own pitfalls and weaknesses, that we'll briefly review. But this will just warm us up for the next style.
Modular Monolith (aka Modulith) is an architecture style that helped many companies break their legacy codebases, and smoothly move to microservices. Most of the techniques discussed here can also come handy when one single microservice grew big and needs to be broken down.
Even more, greenfield projects today opt for this architecture instead of microservices, to avoid paying the high cost of distributability. Imagine cohesive but decoupled modules living in the same code base & deployment, but on which different teams work in harmony, delivering more value much faster than an equivalent microservice ecosystem.🦄
On the agenda:
- patterns to break data structures
- how to protect Domains inside modules
- communication patterns between modules
- breaking cyclic dependencies
Evolving a Clean, Pragmatic Architecture - A Craftsman's Guide
Evolving a Clean, Pragmatic Architecture - A Craftsman's GuideVictor Rentea This document outlines an agenda and presentation on clean code architecture. It discusses modeling data with entities and value objects, organizing logic by extracting services and applying the onion architecture. It emphasizes testing to reduce fear, and protecting developers through simplicity and avoiding overengineering. The presentation emphasizes keeping data transfer objects lightweight and external to the domain.
Hexagonal architecture for java applications
Hexagonal architecture for java applicationsFabricio Epaminondas The document discusses hexagonal architecture, also known as ports and adapters architecture. It is an alternative to traditional multi-layer architectures that aims to decouple the application core from external influences like databases, web frameworks, and other dependencies. The core domain logic is separated from external influences by defining application programming interfaces (APIs) called "ports" that external "adapters" implement. This allows the core to be developed and tested in isolation. The document provides an example implementation of a ticket management system using this architecture.
Clean coding-practices
Clean coding-practicesJohn Ferguson Smart Limited The document discusses clean coding practices for Java developers. It covers topics such as choosing meaningful names for variables, methods, and classes; writing code that is easy for others to understand; breaking methods down into single logical steps; and using fluent APIs to make code more readable. The presentation provides examples of clean code and ways to refactor code to follow best practices.
Clean architecture - Protecting the Domain
Clean architecture - Protecting the DomainVictor Rentea The goal of architecture is to simplify the most complex parts of your logic. Any other goal should be secondary to this. The problem is that you can’t always anticipate where the complexity of your application will accumulate, especially when confronted with ever-changing requirements. The only way to keep your code simple is to gradually evolve the architecture without adding useless complexity up front, but always looking out for opportunities to break-down and refactor towards the most simple design that solves the problem. Drawing concepts from the Domain-Driven Development mindset, this talk summarizes the most important lessons learned designing and consulting many real-world projects. Along the way, you’ll hear about Value Objects and Entities, DTOs, Dependency Inversion Principle, Facades, the Onion Architecture and many pragmatic tips and tricks immediately applicable to your day-to-day work.
Clean Code I - Best Practices
Clean Code I - Best PracticesTheo Jungeblut All 3 Clean Code presentations provide great value by themselves, but taken together are designed to offer a holistic approach to successful software creation. This first session creates the foundation for the 2nd and 3rd Clean Code presentation on Dependency Injection, as it explains expected base knowledge. Why writing Clean Code makes us more efficient Over the lifetime of a product, maintaining the product is actually one - if not the most - expensive area(s) of the overall product costs.
Writing clean code can significantly lower these costs. However, writing clean code also makes you more efficient during the initial development time and results in more stable code. You will be presented design patterns and best practices which will make you write better and more easily maintainable code, seeing code in a holistic way.
You will learn how to apply them by using an existing implementation as the starting point of the presentation. Finally, patterns & practices benefits are explained. This presentation is based on C# and Visual Studio 2012. However, the demonstrated patterns and practice can be applied to every other programming language too.
Note: Moving forwards this presentation will be updated with the latest version of the slides for the last event I did the presentation instead of creating new separate slide decks here on SlideShare.
Presentation dates and locations:
2015-10-03 Silicon Valley Code Camp, San Jose, CA
2015-06-27 SoCal Code Camp - San Diego, CA
2014-11-14 SoCal Code Camp - Los Angeles, CA
2014-10-18 Desert Code Camp - Chandler, AZ
2014-10-11 Silicon Valley Code Camp, Los Altos Hills, CA
Clean code
Clean codeMahmoud Zizo The document discusses principles of clean code, beginning with definitions of clean code from various authors. It outlines key principles like the single responsibility principle and open/closed principle. It then covers sections on meaningful naming, functions, and classes. For functions, it recommends they be small, do one thing, avoid flag arguments, and have no side effects. For classes, it advocates for small size, encapsulation, high cohesion and low coupling following the single responsibility principle.
Clean code
Clean codeArturo Herrero My talk at OSOCO Dev Day and @madriagil about Robert C. Martin's book "Clean Code".
Dates:
28-04-2011
19-05-2011
Clean code and Code Smells
Clean code and Code SmellsMario Sangiorgio The document discusses principles and best practices for writing clean code, including using meaningful names, separating commands and queries, avoiding repetition, using exceptions instead of return codes, and following object-oriented principles like polymorphism instead of switch statements on objects. It provides examples of good and bad code for concepts like single responsibility, primitive obsession, and refused bequest. The overall goal is to write code that is readable, maintainable, and extendable.
The aggregate is dead! Long live the aggregate! - SpringIO.pdf
The aggregate is dead! Long live the aggregate! - SpringIO.pdfSara Pellegrini https://2023.springio.net/sessions/the-aggregate-is-dead-long-live-the-aggregate/
SARA PELLEGRINI - AXONIQ
MILAN SAVIC - AXONIQ
DDD’s definition of Aggregate may seem somewhat confusing - “An aggregate is a cluster of associated objects that we treat as a unit for the purpose of data changes.” Okay, let’s try to clarify - “You should consider your aggregate as a unit of consistency in your Domain.”. That doesn’t help either. As a matter of fact, while modeling our systems, we tend to group together events related to the same domain concept; we tend to define groups based on the nouns we find inside our events’ name: saying “this is our aggregate!”. According to the aggregate definition, we should instead ignore these nouns, and put together the data that change together. Easier said than done: in the modeling phase it is easy to make mistakes trying to identify the boundaries of our aggregates based on this rule. If we opt for saving the state of our aggregate as a series of events, we are in big trouble - any (serious) refactoring of the aggregate structure becomes close to impossible. The reason for this trouble is that we have to make a decision in the design phase for which we cannot be lenient. We are basically married to this decision forever. Due to the aforementioned reasons (and many others), people struggle with the Aggregate pattern. Some even say it is unnecessary, we are one of those. Let’s see whether we can model our business constraints without aggregates. Could we be more relaxed when consistency is in question? Join us to discover how!
Evolving a Clean, Pragmatic Architecture at JBCNConf 2019
Evolving a Clean, Pragmatic Architecture at JBCNConf 2019Victor Rentea Are you in a mood for a brainstorm? Join this critical review of the major decisions taken in a typical enterprise application architecture and learn to balance pragmatism with your design goals. Find out how to do just-in-time design to keep as much use-cases as simple as possible. The core purpose of this presentation is to learn to strike a **balance between pragmatism and maintainability** in your design. Without continuous refactoring, a simple design will inevitably degenerate into a Big Ball of Mud, under the assault of the new features and bugfixes. On the other hand, very highly-factored code can burden the take-off of the development and end up freezing the mindset in some rigid 'a-priori' design. The end goal of this talk is to challenge you to rethink critically the architecture of your own systems, and seek ways to simplify it to match your actual needs, with a pragmatic mindset. "Architecture is the art of postponing decisions", said Uncle Bob. This talk takes this idea further and explains an optimal mindset about designing enterprise applications: Evolving (Continuously Refactoring) a Pragmatic (Simple), Clean (aka Onion) Architecture, aiming to provide Developer Safety™️ and Comfort™️. It’s the philosophy that Victor distilled over the past 5 years, designing and implementing 9 applications as IBM Lead Architect, and delivering trainings and advises to many other companies. You’ll learn how to break data into pieces (Fit Entities, Value Objects, Data Transfer Objects), how to keep the logic simple (Facades, Domain Services, logic extraction patterns, Mappers, AOP), layering to enforce boundaries (keeping DTOs out of your logic, Dependency Inversion Principle), and many more, all in a dynamic, interactive and extremely entertaining session.
Clean architecture
Clean architectureandbed This document discusses clean architecture, which aims to separate an application into distinct layers. The core application logic is separated from the user interface and database access. This improves testability and flexibility. Some benefits of clean architecture include excellent testability since each component can be tested in isolation, clearly defined separation of concerns, and flexibility to change parts of the application independently. However, there are also costs like increased complexity with more classes and data conversions between layers.
Long running processes in DDD
Long running processes in DDDBernd Ruecker Talk given at DDDx London on 27th of April about how to implement long running processes in Domain Driven Design properly. Describes patterns like Process Manager and Saga.
Resilience4j with Spring Boot
Resilience4j with Spring BootKnoldus Inc. Resilience4j is a lightweight fault tolerance library that provides a variety of fault tolerance and stability patterns to a web application. In this knolx session, we'll learn how to use this library with a simple Spring Boot application.
Clean Code @Voxxed Days Cluj 2023 - opening Keynote
Clean Code @Voxxed Days Cluj 2023 - opening KeynoteVictor Rentea Clean Code principles have become a cornerstone of professional developer teams worldwide. But frameworks and languages have evolved, and so have the challenges we’re facing today while crafting modern applications. Single-page apps, extremely DRY code, microservices, excessive functional programming, and reactive flows have all taken their toll on our code quality. Hop aboard this roundtrip of the most damaging Code Smells as of 2023 and fill your toolbox with a load of practical tricks you can immediately apply to your day-to-day work. All in an entertaining show spiced with live-coding moments.
Functional Patterns with Java8 at Devoxx UK - Slides
Functional Patterns with Java8 at Devoxx UK - SlidesVictor Rentea The backing slides for my live coding session at Devoxx UK London 2018. Summarizing all the conclusions. A summary of how to apply clean code principles in Java8 code.
Clean Code with Java 8 - Functional Patterns and Best Practices
Clean Code with Java 8 - Functional Patterns and Best PracticesVictor Rentea My talk about how the Clean Code principles and techniques apply/change when you start using functional programming with Java 8. Presented in Paris at Devoxx FR 2018
More Related Content
What's hot (20)
Clean Code
Clean CodeVictor Rentea How should a professional software developer behave in code? What guidelines should one follow? How should we name our constructs? What about OOP principles? What's their real use?
This classic training module in my training curricula is the cornerstone of my professionalism. These are my conduit guidelines at work. I've held this training > 10 times, including at Voxxed Days Bucharest 2016 and at a Bucharest Java User Group meetup.
Clean pragmatic architecture @ devflix
Clean pragmatic architecture @ devflixVictor Rentea Victor Rentea introduces himself as a Java Champion, trainer, and speaker who focuses on topics like Hibernate, Spring, Java 8/FP, architecture, clean code, unit testing, reactive programming, and Java performance. He advocates building a deep, rich domain model with value objects and entities that encapsulate logic and enforce invariants. The document provides guidance on applying principles like separating concerns with layers, dependency inversion, and avoiding anemic domain models in order to build flexible, testable systems that are decoupled from frameworks and external dependencies.
clean code book summary - uncle bob - English version
clean code book summary - uncle bob - English versionsaber tabatabaee The document provides guidance on writing clean code based on the book "Clean Code" by Robert Cecil Martin. Some of the key points discussed include:
- Functions should do one thing and do it well, with a single level of abstraction and no side effects. They should fit on a screen.
- Names should be meaningful, avoid abbreviations, and use consistent vocabulary. Class names should be nouns and method names should be verbs.
- Code formatting is important for readability. Classes should not exceed 200 lines, functions a single screen. Variables should be declared near use.
- Comments should only explain why unusual decisions were made, not what the code does. Avoid commented out code or redundant comments
Extreme Professionalism - Software Craftsmanship
Extreme Professionalism - Software CraftsmanshipVictor Rentea Decades ago, IT started as a single engineering practice, but as time passed by it got increasingly fragmented. Conflicts broke out between testers vs developers vs sysadmins vs DBAs vs many other roles. Recently, developers themselves split into many subspecialties like backend/frontend/iOS/Android/microservices/functions/etc. The overspecialization we face today causes huge communication overhead, a low bus factor, lack of responsibility, blaming, repeated isolated patching and fulminating costs. The software craftsmanship movement is rising in this post-agile world with professionals eager to take control of their careers and continuously learn in the pursuit of mastery. This talk will show you practical ways in which to seed a continuous learning culture in your team or company, and foster the enthusiasm of your developers.
Software Craftsmanship @Code Camp Festival 2022.pdf
Software Craftsmanship @Code Camp Festival 2022.pdfVictor Rentea Decades ago, IT started as a single engineering practice, but over the years it grew increasingly fragmented. The overspecialization we face today, in the context of a management-first agile transformation leads to a lack of responsibility, blaming games, repeated patching, painful communication overhead, and fulminating costs. The software craftsmanship movement is rising in this post-agile world with professionals that take control of their careers and continuously learn in the pursuit of mastery. But changing mindset requires determined team efforts and communities, especially when working remotely. What techniques and tricks can you use to grow such a culture of learning in your team? Find out from the founder and lead of one of the largest software craftsmanship communities in the world.
This talk is about technical culture and attitude.
Vertical Slicing Architectures
Vertical Slicing ArchitecturesVictor Rentea Throughout the years, the Concentric Architectures (Onion, Hexagonal, Clean-..) have grown into the undisputed leader among backend systems architectures. With the rise of Domain-Driven Design, keeping your Domain ring 'agnostic' to the outside world has become the norm today. But history proved that any 'norm' in software architectures will cause overengineering if applied without criticism.
After a brief recap of these architectures, their pitfalls, and weaknesses, we'll see two alternatives that segregate code not in 'layers' or 'rings' but in vertical slices: Feature Slicing and Modular Monolith.
[Feature Slicing](vertical Slice Architecture) (aka *UseCase) has its own pitfalls and weaknesses, that we'll briefly review. But this will just warm us up for the next style.
Modular Monolith (aka Modulith) is an architecture style that helped many companies break their legacy codebases, and smoothly move to microservices. Most of the techniques discussed here can also come handy when one single microservice grew big and needs to be broken down.
Even more, greenfield projects today opt for this architecture instead of microservices, to avoid paying the high cost of distributability. Imagine cohesive but decoupled modules living in the same code base & deployment, but on which different teams work in harmony, delivering more value much faster than an equivalent microservice ecosystem.🦄
On the agenda:
- patterns to break data structures
- how to protect Domains inside modules
- communication patterns between modules
- breaking cyclic dependencies
Evolving a Clean, Pragmatic Architecture - A Craftsman's Guide
Evolving a Clean, Pragmatic Architecture - A Craftsman's GuideVictor Rentea This document outlines an agenda and presentation on clean code architecture. It discusses modeling data with entities and value objects, organizing logic by extracting services and applying the onion architecture. It emphasizes testing to reduce fear, and protecting developers through simplicity and avoiding overengineering. The presentation emphasizes keeping data transfer objects lightweight and external to the domain.
Hexagonal architecture for java applications
Hexagonal architecture for java applicationsFabricio Epaminondas The document discusses hexagonal architecture, also known as ports and adapters architecture. It is an alternative to traditional multi-layer architectures that aims to decouple the application core from external influences like databases, web frameworks, and other dependencies. The core domain logic is separated from external influences by defining application programming interfaces (APIs) called "ports" that external "adapters" implement. This allows the core to be developed and tested in isolation. The document provides an example implementation of a ticket management system using this architecture.
Clean coding-practices
Clean coding-practicesJohn Ferguson Smart Limited The document discusses clean coding practices for Java developers. It covers topics such as choosing meaningful names for variables, methods, and classes; writing code that is easy for others to understand; breaking methods down into single logical steps; and using fluent APIs to make code more readable. The presentation provides examples of clean code and ways to refactor code to follow best practices.
Clean architecture - Protecting the Domain
Clean architecture - Protecting the DomainVictor Rentea The goal of architecture is to simplify the most complex parts of your logic. Any other goal should be secondary to this. The problem is that you can’t always anticipate where the complexity of your application will accumulate, especially when confronted with ever-changing requirements. The only way to keep your code simple is to gradually evolve the architecture without adding useless complexity up front, but always looking out for opportunities to break-down and refactor towards the most simple design that solves the problem. Drawing concepts from the Domain-Driven Development mindset, this talk summarizes the most important lessons learned designing and consulting many real-world projects. Along the way, you’ll hear about Value Objects and Entities, DTOs, Dependency Inversion Principle, Facades, the Onion Architecture and many pragmatic tips and tricks immediately applicable to your day-to-day work.
Clean Code I - Best Practices
Clean Code I - Best PracticesTheo Jungeblut All 3 Clean Code presentations provide great value by themselves, but taken together are designed to offer a holistic approach to successful software creation. This first session creates the foundation for the 2nd and 3rd Clean Code presentation on Dependency Injection, as it explains expected base knowledge. Why writing Clean Code makes us more efficient Over the lifetime of a product, maintaining the product is actually one - if not the most - expensive area(s) of the overall product costs.
Writing clean code can significantly lower these costs. However, writing clean code also makes you more efficient during the initial development time and results in more stable code. You will be presented design patterns and best practices which will make you write better and more easily maintainable code, seeing code in a holistic way.
You will learn how to apply them by using an existing implementation as the starting point of the presentation. Finally, patterns & practices benefits are explained. This presentation is based on C# and Visual Studio 2012. However, the demonstrated patterns and practice can be applied to every other programming language too.
Note: Moving forwards this presentation will be updated with the latest version of the slides for the last event I did the presentation instead of creating new separate slide decks here on SlideShare.
Presentation dates and locations:
2015-10-03 Silicon Valley Code Camp, San Jose, CA
2015-06-27 SoCal Code Camp - San Diego, CA
2014-11-14 SoCal Code Camp - Los Angeles, CA
2014-10-18 Desert Code Camp - Chandler, AZ
2014-10-11 Silicon Valley Code Camp, Los Altos Hills, CA
Clean code
Clean codeMahmoud Zizo The document discusses principles of clean code, beginning with definitions of clean code from various authors. It outlines key principles like the single responsibility principle and open/closed principle. It then covers sections on meaningful naming, functions, and classes. For functions, it recommends they be small, do one thing, avoid flag arguments, and have no side effects. For classes, it advocates for small size, encapsulation, high cohesion and low coupling following the single responsibility principle.
Clean code
Clean codeArturo Herrero My talk at OSOCO Dev Day and @madriagil about Robert C. Martin's book "Clean Code".
Dates:
28-04-2011
19-05-2011
Clean code and Code Smells
Clean code and Code SmellsMario Sangiorgio The document discusses principles and best practices for writing clean code, including using meaningful names, separating commands and queries, avoiding repetition, using exceptions instead of return codes, and following object-oriented principles like polymorphism instead of switch statements on objects. It provides examples of good and bad code for concepts like single responsibility, primitive obsession, and refused bequest. The overall goal is to write code that is readable, maintainable, and extendable.
The aggregate is dead! Long live the aggregate! - SpringIO.pdf
The aggregate is dead! Long live the aggregate! - SpringIO.pdfSara Pellegrini https://2023.springio.net/sessions/the-aggregate-is-dead-long-live-the-aggregate/
SARA PELLEGRINI - AXONIQ
MILAN SAVIC - AXONIQ
DDD’s definition of Aggregate may seem somewhat confusing - “An aggregate is a cluster of associated objects that we treat as a unit for the purpose of data changes.” Okay, let’s try to clarify - “You should consider your aggregate as a unit of consistency in your Domain.”. That doesn’t help either. As a matter of fact, while modeling our systems, we tend to group together events related to the same domain concept; we tend to define groups based on the nouns we find inside our events’ name: saying “this is our aggregate!”. According to the aggregate definition, we should instead ignore these nouns, and put together the data that change together. Easier said than done: in the modeling phase it is easy to make mistakes trying to identify the boundaries of our aggregates based on this rule. If we opt for saving the state of our aggregate as a series of events, we are in big trouble - any (serious) refactoring of the aggregate structure becomes close to impossible. The reason for this trouble is that we have to make a decision in the design phase for which we cannot be lenient. We are basically married to this decision forever. Due to the aforementioned reasons (and many others), people struggle with the Aggregate pattern. Some even say it is unnecessary, we are one of those. Let’s see whether we can model our business constraints without aggregates. Could we be more relaxed when consistency is in question? Join us to discover how!
Evolving a Clean, Pragmatic Architecture at JBCNConf 2019
Evolving a Clean, Pragmatic Architecture at JBCNConf 2019Victor Rentea Are you in a mood for a brainstorm? Join this critical review of the major decisions taken in a typical enterprise application architecture and learn to balance pragmatism with your design goals. Find out how to do just-in-time design to keep as much use-cases as simple as possible. The core purpose of this presentation is to learn to strike a **balance between pragmatism and maintainability** in your design. Without continuous refactoring, a simple design will inevitably degenerate into a Big Ball of Mud, under the assault of the new features and bugfixes. On the other hand, very highly-factored code can burden the take-off of the development and end up freezing the mindset in some rigid 'a-priori' design. The end goal of this talk is to challenge you to rethink critically the architecture of your own systems, and seek ways to simplify it to match your actual needs, with a pragmatic mindset. "Architecture is the art of postponing decisions", said Uncle Bob. This talk takes this idea further and explains an optimal mindset about designing enterprise applications: Evolving (Continuously Refactoring) a Pragmatic (Simple), Clean (aka Onion) Architecture, aiming to provide Developer Safety™️ and Comfort™️. It’s the philosophy that Victor distilled over the past 5 years, designing and implementing 9 applications as IBM Lead Architect, and delivering trainings and advises to many other companies. You’ll learn how to break data into pieces (Fit Entities, Value Objects, Data Transfer Objects), how to keep the logic simple (Facades, Domain Services, logic extraction patterns, Mappers, AOP), layering to enforce boundaries (keeping DTOs out of your logic, Dependency Inversion Principle), and many more, all in a dynamic, interactive and extremely entertaining session.
Clean architecture
Clean architectureandbed This document discusses clean architecture, which aims to separate an application into distinct layers. The core application logic is separated from the user interface and database access. This improves testability and flexibility. Some benefits of clean architecture include excellent testability since each component can be tested in isolation, clearly defined separation of concerns, and flexibility to change parts of the application independently. However, there are also costs like increased complexity with more classes and data conversions between layers.
Long running processes in DDD
Long running processes in DDDBernd Ruecker Talk given at DDDx London on 27th of April about how to implement long running processes in Domain Driven Design properly. Describes patterns like Process Manager and Saga.
Resilience4j with Spring Boot
Resilience4j with Spring BootKnoldus Inc. Resilience4j is a lightweight fault tolerance library that provides a variety of fault tolerance and stability patterns to a web application. In this knolx session, we'll learn how to use this library with a simple Spring Boot application.
Clean Code @Voxxed Days Cluj 2023 - opening Keynote
Clean Code @Voxxed Days Cluj 2023 - opening KeynoteVictor Rentea Clean Code principles have become a cornerstone of professional developer teams worldwide. But frameworks and languages have evolved, and so have the challenges we’re facing today while crafting modern applications. Single-page apps, extremely DRY code, microservices, excessive functional programming, and reactive flows have all taken their toll on our code quality. Hop aboard this roundtrip of the most damaging Code Smells as of 2023 and fill your toolbox with a load of practical tricks you can immediately apply to your day-to-day work. All in an entertaining show spiced with live-coding moments.
Similar to Functional Patterns with Java8 @Bucharest Java User Group (20)
Functional Patterns with Java8 at Devoxx UK - Slides
Functional Patterns with Java8 at Devoxx UK - SlidesVictor Rentea The backing slides for my live coding session at Devoxx UK London 2018. Summarizing all the conclusions. A summary of how to apply clean code principles in Java8 code.
Clean Code with Java 8 - Functional Patterns and Best Practices
Clean Code with Java 8 - Functional Patterns and Best PracticesVictor Rentea My talk about how the Clean Code principles and techniques apply/change when you start using functional programming with Java 8. Presented in Paris at Devoxx FR 2018
Functional Programming Patterns with Java 8 (at Devoxx BE)
Functional Programming Patterns with Java 8 (at Devoxx BE)Victor Rentea The slides for my talk at Devoxx BE 2018.
Contents: Optional, method references over heavy lambdas, Passing-a-Block, Loan Pattern, Execute Around, Hiding Checked Exceptions, Method References on Enums.
This talk was rated #1 talk of the whole conference.
Functional Programming in Java - Code for Maintainability
Functional Programming in Java - Code for MaintainabilityMarcin Stepien Functional Programming is nothing new to the JVM. But with Java 8 it was the big change in paradigm for Java developers. Learn how switching from imperative to functional results in more maintainable code.
The presentation was given at tech meetup KrkDataLink, The missing link between Functional Programming and Data Science.
Functional Programming 101 for Java 7 Developers
Functional Programming 101 for Java 7 DevelopersJayaram Sankaranarayanan Introduction to Functional Programming and usage of basic constructs in Java 7 using Guava.
Further, the session introduces Reactive Systems architecture and design.
Functional Programming In Java Harnessing The Power Of Java 8 Lambda Expressi...
Functional Programming In Java Harnessing The Power Of Java 8 Lambda Expressi...coriehokitiw Functional Programming In Java Harnessing The Power Of Java 8 Lambda Expressions Venkat Subramaniam
Functional Programming In Java Harnessing The Power Of Java 8 Lambda Expressions Venkat Subramaniam
Functional Programming In Java Harnessing The Power Of Java 8 Lambda Expressions Venkat Subramaniam
Beyond PITS, Functional Principles for Software Architecture
Beyond PITS, Functional Principles for Software ArchitectureJayaram Sankaranarayanan This talk introduces the core concepts of functional programming, why it matters now and how these principles are adopted for programming.
Beyond the usage of the functional principles for programming in the small, their applicability to the design of components and further on to the architecture of software systems is also explored along with relevant examples.
The code samples used in the talk are in Haskell / Java 8 / Scala / Elm and JavaScript, but deep understanding of any of these languages are not a pre-requisite.
A Functional Approach to Java: Augmenting Object-Oriented Java Code with Func...
A Functional Approach to Java: Augmenting Object-Oriented Java Code with Func...romergalbowx A Functional Approach to Java: Augmenting Object-Oriented Java Code with Functional Principles 1st Edition Ben Weidig
A Functional Approach to Java: Augmenting Object-Oriented Java Code with Functional Principles 1st Edition Ben Weidig
A Functional Approach to Java: Augmenting Object-Oriented Java Code with Functional Principles 1st Edition Ben Weidig
Designing function families and bundles with java's behaviors parameterisatio...
Designing function families and bundles with java's behaviors parameterisatio...Alain Lompo User requirements are sinking sands: should we care or should we leave it to the business managers? Java’8 behaviours parameterization and lambdas help shift paradigms from business to design: here the audience will learn how to efficiently deal with the issue and make their customers smile.
Refactoring Games - 15 things to do after Extract Method
Refactoring Games - 15 things to do after Extract MethodVictor Rentea In our quest against increasing complexity, Extract Method is probably the most important refactoring technique in our hands. We use it a dozen times per day as a first-level weapon, and very often it leads to us to deeper design insights. Let’s look at several such further actions you might take after pulling some code out in a separate method:
* Reorder Parameters
* Remove parameters by including more lines in what you extract (Ctrl-Z)
* Add parameters for reuse by extract/inline variable at call site (Ctrl-Z)
* Move method to object (for Feature Envy)
* Encapsulate conditionals (great with Java8)
* Inline back
* Distill switch expressions: the 3 Clean Switch Rules
* Introduce Method Object for heavy logic
* Early return errors
* Extract static util functions
* Spawn smart Value Object vs logic in Utils
* Extract’n-test then mock away, leading to Separation by Layers of Abstraction
* Command-Query Separation: mind the side effects
* Extract again - boolean vs SRP
* Wrap call to safely add more code (Open-Closed)
Do you even Function? Guiding Through Functional Interfaces
Do you even Function? Guiding Through Functional InterfacesDmitry Vinnik The document discusses functional programming concepts in Java including streams, optional, high order functions like predicate and supplier. It covers designing for functional programming through principles like immutable data and lazy evaluation. Examples show imperative vs declarative styles and how to use method references and custom functional interfaces. Common use cases like error handling and multi-dimensional data are demonstrated. Finally, antipatterns of functional programming are mentioned.
Scala: functional programming for the imperative mind
Scala: functional programming for the imperative mindSander Mak (@Sander_Mak) Scala is a programming language that runs on the JVM and fuses functional and object-oriented paradigms. It aims to provide functional programming for programmers with an imperative mindset. Key features include functions as first-class values, pattern matching, traits for composition, and seamless interoperability with Java. While some features appear to be language features, many are actually implemented via libraries. The Scala community is growing with adoption by companies and increasing support in tools and publications.
Java and effective programming. Is it possible? - IAESTE Case Week 2016
Java and effective programming. Is it possible? - IAESTE Case Week 2016Łukasz Koniecki Probably most of use read book "Effective Java" by Joshua Blooch. But what "effective" programming really means? We will go through some real-life problems and talk about possible, effective solutions.
Effective programming in Java - Kronospan Job Fair 2016
Effective programming in Java - Kronospan Job Fair 2016Łukasz Koniecki Probably most of use read book "Effective Java" by Joshua Blooch. But what "effective" programming really means? We will go through some real-life problems and talk about possible, effective solutions.
What is Pure Functional Programming, and how it can improve our application t...
What is Pure Functional Programming, and how it can improve our application t...Luca Molteni Pure functional programming is helping developers developing more robust and simpler programs, but it also helps them testing the behaviour of their application in a more predictable way. There are many different approaches to testing and verification of code, and we're constantly reconsidering the best approach to make our code solid, by leveraging concepts like referential transparency and purity to help us avoiding bugs. We explore the meaning of testing, by starting from the simple unit test, moving on to the property based testing and encoding our program invariants in types, with an introduction of some advanced type system concepts such as dependent types.
About Functional Programming
About Functional ProgrammingAapo Kyrölä My presentation at Sulake (www.sulake.com) about functional programming languages and how to adopt a functional-style in Java development. I argue that functional programs are more robust than imperative ones.
Functional programming with Java 8
Functional programming with Java 8Talha Ocakçı Functional programming in Java 8 allows for:
1) The use of lambda expressions and streams for a more declarative programming style without iteration.
2) Functional interfaces like Function, Predicate, and Consumer along with lambda expressions enable function composition and chaining.
3) Features like immutable collections help reduce mutability and side effects, important aspects of functional programming.
Thinking Functionally
Thinking FunctionallyPiyush Katariya This document provides an opinionated guide to thinking functionally as a software architect. It recommends starting with Racket to learn functional programming concepts like recursion, higher order functions, and avoiding mutations. Some key aspects of functional programming discussed are using functions as first-class citizens, favoring recursion over iteration, laziness with streams, expressions over statements, and composition over inheritance. The document also mentions concepts like closures, pattern matching, currying, and persistent data structures. It recommends resources for learning more about functional programming in Racket, Lisp, Haskell, F#, OCaml, and Idris.
Clean Code Principles And Patterns A Software Practitioners Handbook 1 No Cov...
Clean Code Principles And Patterns A Software Practitioners Handbook 1 No Cov...politomuqeem Clean Code Principles And Patterns A Software Practitioners Handbook 1 No Cover Petri Siln
Clean Code Principles And Patterns A Software Practitioners Handbook 1 No Cover Petri Siln
Clean Code Principles And Patterns A Software Practitioners Handbook 1 No Cover Petri Siln
Definitive Guide to Working With Exceptions in Java
Definitive Guide to Working With Exceptions in JavaVictor Rentea Exceptions have been with us for 25 years in Java but have we learned to use them properly? Are checked exceptions a mistake? Should you use throw runtime or checked exceptions? And what to do with a checked exception, when you get one? And how to slay the boss of all exceptions: the NullPointerException.
Let’s put these old questions in the context of Java8+ lambdas, Vavr monads, Lombok, Spring, JAX-RS and other modern frameworks, and see the best practices of handling errors in Java today.Let’s put these old questions in the context of Java8+ lambdas, Vavr monads, Lombok, Spring, JAX-RS and other modern frameworks, and see the best practices of handling errors in Java today.
Ad
More from Victor Rentea (20)
Top REST API Desgin Pitfalls @ Devoxx 2024
Top REST API Desgin Pitfalls @ Devoxx 2024Victor Rentea An entertaining tour of the most common mistakes in designing an API (with examples): Domain Leakage, Sensitive Data Exposure, Performance issues, CQRS, PUT overload, and breaking changes. Collected with love from over 150 companies.
- DM leak
- Privacy Leak
- Performance: Lazy, N+1
- CQRS
- PUT overload / ISP
- SemVer
The Joy of Testing - Deep Dive @ Devoxx Belgium 2024
The Joy of Testing - Deep Dive @ Devoxx Belgium 2024Victor Rentea We spend half of our coding time reading, writing or fixing tests. But who likes that? To quickly fix this chore, we often copy-cat older tests or write new ones without paying much attention to their quality. This deep-dive walks you through a variety of practical testing techniques and tricks you must have in your toolbox to write expressive tests with a higher signal/noise ratio. In the agenda: test structure & naming, mutation testing (vs AI-gen tests), ObjectMother, why never to use assertEquals, nested fixtures, parameterized use/abuse, Gherkin, plus a few surprises. All this through an entertaining and interactive session that puts the joy back into testing.
Finding Java's Hidden Performance Traps @ DevoxxUK 2024
Finding Java's Hidden Performance Traps @ DevoxxUK 2024Victor Rentea Tracing the root cause of a performance issue requires a lot of patience, experience, and focus. It’s so hard that we sometimes attempt to guess by trying out tentative fixes, but that usually results in 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.
About authorWith two decades of experience, Victor is a Java Champion working as a trainer for top companies in Europe. Five thousands developers in 120 companies attended his workshops, so he gets to debate every week the challenges that various projects struggle with. In return, Victor summarizes key points from these workshops in conference talks and online meetups for the European Software Crafters, the world’s largest developer community around architecture, refactoring, and testing. Discover how Victor can help you on victorrentea.ro : company training catalog, consultancy and YouTube playlists.
Modular Monolith - a Practical Alternative to Microservices @ Devoxx UK 2024
Modular Monolith - a Practical Alternative to Microservices @ Devoxx UK 2024Victor Rentea The microservices honeymoon is over. When starting a new project or revamping a legacy monolith, teams started looking for alternatives to microservices. The Modular Monolith, or 'Modulith', is an architecture that reaps the benefits of (vertical) functional decoupling without the high costs associated with separate deployments. This talk will delve into the advantages and challenges of this progressive architecture, beginning with exploring the concept of a 'module', its internal structure, public API, and inter-module communication patterns. Supported by spring-modulith, the talk provides practical guidance on addressing the main challenges of a Modultith Architecture: finding and guarding module boundaries, data decoupling, and integration module-testing. You should not miss this talk if you are a software architect or tech lead seeking practical, scalable solutions.
About the author
With two decades of experience, Victor is a Java Champion working as a trainer for top companies in Europe. Five thousands developers in 120 companies attended his workshops, so he gets to debate every week the challenges that various projects struggle with. In return, Victor summarizes key points from these workshops in conference talks and online meetups for the European Software Crafters, the world’s largest developer community around architecture, refactoring, and testing. Discover how Victor can help you on victorrentea.ro : company training catalog, consultancy and YouTube playlists.
Microservice Resilience Patterns @VoxxedCern'24
Microservice Resilience Patterns @VoxxedCern'24Victor Rentea The network is reliable, 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!
Distributed Consistency.pdf
Distributed Consistency.pdfVictor Rentea One of the many challenges of a distributed architecture is preserving the consistency of data across different systems. During this one-hour presentation, we are going to explore a number of strategies for maintaining consistency, going from the most basic options up to an automated recovery mechanism using compensations and reservations - what’s commonly referred to as a “saga” pattern. Our journey will be based on a hypothetical food delivery application on which we will analyze various decisions and their tradeoffs. The discussion will stay at an abstract, architectural level for the most part, with only a few code examples.
In the agenda:
- Idempotency and Retries
- 2 Phase Commit
- Eventual Consistency
- Compensations
- Reservations
- The Saga Pattern
Testing Microservices @DevoxxBE 23.pdf
Testing Microservices @DevoxxBE 23.pdfVictor Rentea Testing strategies for modern software architectures are evolving. As we transition from monolithic structures to team-sized microservices with crisp APIs aligned to bounded contexts, we encounter more stable testing surfaces. This shift leads many high-performing teams to favor integration tests over fine-grained, brittle unit tests. These integration tests, which are closer to the functional requirements, prove more trustworthy and are more resilient to internal refactoring, though they may come with a higher cost. In a vivid and engaging style, this talk addresses the primary challenges of integration testing in the microservices era: cognitive overload, test isolation, and test execution speed. Join the testing revolution and discover how to enhance your team's testing efficiency and effectiveness.
From Web to Flux @DevoxxBE 2023.pptx
From Web to Flux @DevoxxBE 2023.pptxVictor Rentea Ready for a deep dive into the world's most challenging programming paradigm? Reactive programming can simplify asynchronous and event-driven applications, but without a strong understanding, it can lead to frustration, recurring patchwork, missed deadlines, and costly bugs.
In this intensive three-hour session, we'll transition a traditional Spring application to WebFlux, revealing patterns and aanti-patterns when working with repositories, REST APIs, queues, and legacy libraries. You'll gain a clear understanding of often overlooked but critical aspects like subscribe signal, errors, cancellation, and signal loss. As a bonus, we'll debate the future of Reactive vs Virtual Threads, production-ready in Java 21.
This session is crucial for developers already working with reactive programming or those intending to make the leap.
Test-Driven Design Insights@DevoxxBE 2023.pptx
Test-Driven Design Insights@DevoxxBE 2023.pptxVictor Rentea Testing is fundamental in software development. Quality gates demand high coverage levels, pull requests need sufficient tests, leading to teams spending considerable time writing and maintaining them. But are we using our tests to their full potential?
'If code is hard to test, the design can be improved'. Starting from this mantra, this deep-dive session unveils hints to simplify code, break-down complexity, and effectively use functional programming. We'll delve into topics like fixture creep, partial mocks, onion architecture, and pure functions, providing numerous best practices and practical tips for your testing.
Be warned: This session may significantly disrupt your work routine and will likely change how you see testing. Attend at your own risk.
Profiling your Java Application
Profiling your Java ApplicationVictor Rentea The biggest challenge in performance tuning is identifying the root cause of the bottleneck. Once you find it, the fix often becomes trivial. However, this detective work takes patience, skills, and effort, so we often attempt to guess the cause, by trying out tentative fixes. The result: messy code, waste of time and money, and frustration. During this talk you will learn how to correctly zoom in on the bottleneck using three levels of profiling: distributed tracing with Zipkin, metrics with Micrometer, and profiling with the Java Flight Recorder already built into your JVM. We’ll focus on the latter and learn how to read a flame graph to trace some common issues of backend systems like connection/thread pool starvation, time-consuming aspects, hot methods, and lock contention, even if these occur in library code you did not write.
OAuth in the Wild
OAuth in the WildVictor Rentea Slides for my presentation about OAuth, going in depth in the details of the Authorization Code Grant and PKCE, also describing several security threats to OAuth
Unit testing - 9 design hints
Unit testing - 9 design hintsVictor Rentea Tests are hard to write if the production design is crappy - goes an old saying. Indeed, writing unit tests gives you one of the most comprehensive, yet brutal, feedback about the design of your production code, but if it comes too late, many developers can’t take it and they will either stop testing or test superficially. At the other end, others struggle to write contrieved, 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.
Refactoring blockers and code smells @jNation 2021
Refactoring blockers and code smells @jNation 2021Victor Rentea The only way to survive in a codebase is by refactoring continuously. We know that since the Extreme Programming days. But what stops us from doing so today? In this talk, Victor summarizes what he learned discussing Clean Code and Refactoring with hundreds of teams throughout the world. You'll find ideas to tackle a broad spectrum of factors: technical, cultural, psychological, emotional, social, and even political. Using these you might unlock the freedom to refactor for you and your colleagues.
After this roundtrip, the talk briefly overviews several of the most dangerous code smells in the projects today: God Class, Duplicated Code vs Divergent Code, Temporal Coupling, Middle Man, Speculative Generality, Mutable Long-Lived State, Comments, and more. For each of them we’ll discuss a typical workaround, plus several subtleties and variations.
Hibernate and Spring - Unleash the Magic
Hibernate and Spring - Unleash the MagicVictor Rentea This document provides an overview of several Java technologies:
- JPA Auditing for tracking entity creation/modification dates and users
- Domain Events in DDD for triggering processing across aggregates
- javax.validation for validating entities before database writes
- Spring Data Repos for implementing repositories with query methods and custom logic
It also briefly discusses JPA auditing implementation, domain event publishing, custom validators, and the @NonNullApi annotation for preventing null returns from repositories.
Integration testing with spring @JAX Mainz
Integration testing with spring @JAX MainzVictor Rentea Our sleep is better with longer-scoped tests. Our life is brighter if we don’t rely heavily on fine-grained tests that break whenever we refactor even the smallest detail. I’m talking about tilting the balance towards more integration than unit testing. And for that, let’s look at the testing features offered by the most used Java Framework today. We’ll see how to write fake test implementations, how to mock an unwanted Spring bean, what a Transactional Test is, and if and how to test your web endpoints. Along the way, we’ll also see Flaky tests, and discuss best practices about integration testing – all in an entertaining live coding session.
Your takeaways from this talk will be a lot of good practices and techniques directly applicable to your day-to-day project.
The Proxy Fairy and the Magic of Spring @JAX Mainz 2021
The Proxy Fairy and the Magic of Spring @JAX Mainz 2021Victor Rentea You can only claim you know Spring if you fully understand the Proxy design pattern and how the framework uses it to do its magic. Join this live coding session to explore 6 ways of intercepting method calls that you can use to cast your own spells and dramatically simplify your codebase.
Grab a strong coffee and prepare yourself for a whirlwind of **live-coding**, interwoven with **deep theoretical concepts and implementation details** that you need to master if you are using the Spring Framework. We’ll start from a Decorator pattern implementation, proving 2 ways to wire it with Spring, then move to bare-hands interface proxies, concrete classes proxies, @Aspect applied to custom annotations, plus some standard off-the-shelf Spring aspects.
Join this talk and learn real-world best practices to use with Aspects, design hints, under-the-hood implementation details, debugging tips, and performance impact of aspects. All in an interactive, entertaining, and extremely dynamic session.
Pure functions and immutable objects @dev nexus 2021
Pure functions and immutable objects @dev nexus 2021Victor Rentea aaaaThis presentation focuses on two of the most advanced design tools in your toolbox, whatever the language or framework you might be using. After understanding the basics, we'll see how these concepts can be used in real-world scenarios to simplify those several most complex use-cases in your application. At the end of a mix of slides and live-coding, you'll finally understand the power of these ideas and become prepared to apply them in your day-to-day work.
Along the way, we'll introduce concepts like Side Effects, Idempotency, Referential Transparency, Pure Functions and Deep/Shallow Immutability. Also, we'll talk about the powerful Functional Code / Imperative Shell architecture that you can use for your complex workflows.
Prepare for an entertaining, highly interactive session that will answer all your questions.
Written in Java and spoken in English.
TDD Mantra
TDD MantraVictor Rentea This document describes Victor Rentea, an independent trainer and founder of the Bucharest Software Craftsmanship Community who has provided technical training to over 2000 developers over 8 years. It promotes Victor Rentea's training services on topics like Hibernate, Spring, Java performance, reactive programming, design patterns, clean code, refactoring, and unit testing in any language. The document also provides brief summaries of test-driven development and the three rules of TDD according to Uncle Bob, as well as a definition of code golf.
Definitive Guide to Working With Exceptions in Java - takj at Java Champions ...
Definitive Guide to Working With Exceptions in Java - takj at Java Champions ...Victor Rentea A Pragmatic approach to work with exceptions in Java. Talk recording: https://www.youtube.com/watch?v=LRwCE7GreSM&feature=youtu.be
Discussing checked exceptions, Vavr, Lombok, and JooL library, Spring Framework and many more.
Supporting in-depth article series: https://victorrentea.ro/blog/exception-handling-guide-in-java/
Pure Functions and Immutable Objects
Pure Functions and Immutable ObjectsVictor Rentea First, what are they? And why they are important? What do they allow us to do, and what problems do they shield us from?
After this talk, you'll inevitably fall in love with pure functions and immutable objects. We'll see how to implement them in Java, in the most geek ways possible, concerned about long-term maintainability of the code. Oh, and we'll also have Lombok and records along the way, plus lots of fun while tasting a bit of "a senior developer's night-life".
Given at jLove Dec 2020
Ad
Recently uploaded (20)
Milwaukee Marketo User Group June 2025 - Optimize and Enhance Efficiency - Sm...
Milwaukee Marketo User Group June 2025 - Optimize and Enhance Efficiency - Sm...BradBedford3 Inspired by the Adobe Summit hands-on lab, Optimize Your Marketo Instance Performance, review the recording from June 5th to learn best practices that can optimize your smart campaign and smart list processing time, inefficient practices to try to avoid, and tips and tricks for keeping your instance running smooth!
You will learn:
How smart campaign queueing works, how flow steps are prioritized, and configurations that slow down smart campaign processing.
Best practices for smart list and smart campaign configurations that yield greater reliability and processing efficiencies.
Generally recommended timelines for reviewing instance performance: walk away from this session with a guideline of what to review in Marketo and how often to review it.
This session will be helpful for any Marketo administrator looking for opportunities to improve and streamline their instance performance. Be sure to watch to learn best practices and connect with your local Marketo peers!
Software Testing & it’s types (DevOps)
Software Testing & it’s types (DevOps)S Pranav (Deepu) NTRODUCTION TO SOFTWARE TESTING
• Definition:
• Software testing is the process of evaluating and
verifying that a software application or system meets
specified requirements and functions correctly.
• Purpose:
• Identify defects and bugs in the software.
• Ensure the software meets quality standards.
• Validate that the software performs as intended in
various scenarios.
• Importance:
• Reduces risks associated with software failures.
• Improves user satisfaction and trust in the product.
• Enhances the overall reliability and performance of
the software
Agentic Techniques in Retrieval-Augmented Generation with Azure AI Search
Agentic Techniques in Retrieval-Augmented Generation with Azure AI SearchMaxim Salnikov Discover how Agentic Retrieval in Azure AI Search takes Retrieval-Augmented Generation (RAG) to the next level by intelligently breaking down complex queries, leveraging full conversation history, and executing parallel searches through a new LLM-powered query planner. This session introduces a cutting-edge approach that delivers significantly more accurate, relevant, and grounded answers—unlocking new capabilities for building smarter, more responsive generative AI applications.
Traditional Retrieval-Augmented Generation (RAG) pipelines work well for simple queries—but when users ask complex, multi-part questions or refer to previous conversation history, they often fall short. That’s where Agentic Retrieval comes in: a game-changing advancement in Azure AI Search that brings LLM-powered reasoning directly into the retrieval layer.
This session unveils how agentic techniques elevate your RAG-based applications by introducing intelligent query planning, subquery decomposition, parallel execution, and result merging—all orchestrated by a new Knowledge Agent. You’ll learn how this approach significantly boosts relevance, groundedness, and answer quality, especially for sophisticated enterprise use cases.
Key takeaways:
- Understand the evolution from keyword and vector search to agentic query orchestration
- See how full conversation context improves retrieval accuracy
- Explore measurable improvements in answer relevance and completeness (up to 40% gains!)
- Get hands-on guidance on integrating Agentic Retrieval with Azure AI Foundry and SDKs
- Discover how to build scalable, AI-first applications powered by this new paradigm
Whether you're building intelligent copilots, enterprise Q&A bots, or AI-driven search solutions, this session will equip you with the tools and patterns to push beyond traditional RAG.
Making significant Software Architecture decisions
Making significant Software Architecture decisionsBert Jan Schrijver Presented at the iSAQB Software Architecture Community NL meetup on 12-6-2025
Open Source Software Development Methods
Open Source Software Development MethodsVICTOR MAESTRE RAMIREZ Open Source Software Development Methods
IBM Rational Unified Process For Software Engineering - Introduction
IBM Rational Unified Process For Software Engineering - IntroductionGaurav Sharma IBM Rational Unified Process For Software Engineering
DevOps for AI: running LLMs in production with Kubernetes and KubeFlow
DevOps for AI: running LLMs in production with Kubernetes and KubeFlowAarno Aukia Presented by Aarno Aukia on June 4th, 2025, at Kubernetes Community Days KCD New York
FME as an Orchestration Tool - Peak of Data & AI 2025
FME as an Orchestration Tool - Peak of Data & AI 2025Safe Software Processing huge amounts of data through FME can have performance consequences, but as an orchestration tool, FME is brilliant! We'll take a look at the principles of data gravity, best practices, pros, cons, tips and tricks. And of course all spiced up with relevant examples!
What is data visualization and how data visualization tool can help.pdf
What is data visualization and how data visualization tool can help.pdfVarsha Nayak An open source data visualization tool enhances this process by providing flexible, cost-effective solutions that allow users to customize and scale their visualizations according to their needs. These tools enable organizations to make data-driven decisions with complete freedom from proprietary software limitations. Whether you're a data scientist, marketer, or business leader, understanding how to utilize an open source data visualization tool can significantly improve your ability to communicate insights effectively.
Automated Migration of ESRI Geodatabases Using XML Control Files and FME
Automated Migration of ESRI Geodatabases Using XML Control Files and FMESafe Software Efficient data migration is a critical challenge in geospatial data management, especially when working with complex data structures. This presentation explores an automated approach to migrating ESRI Geodatabases using FME and XML-based control files. A key advantage of this method is its adaptability: changes to the data model are seamlessly incorporated into the migration process without requiring modifications to the underlying FME workflow. By separating data model definitions from migration logic, this approach ensures flexibility, reduces maintenance effort, and enhances scalability.
Code and No-Code Journeys: The Coverage Overlook
Code and No-Code Journeys: The Coverage OverlookApplitools Explore practical ways to expand visual and functional UI coverage without deep coding or heavy maintenance in this session. Session recording and more info at applitools.com
OpenTelemetry 101 Cloud Native Barcelona
OpenTelemetry 101 Cloud Native BarcelonaImma Valls Bernaus A brief introduction to OpenTelemetry, with a practical example of auto-instrumenting a Java web application with the Grafana stack (Loki, Grafana, Tempo, and Mimir).
Shell Skill Tree - LabEx Certification (LabEx)
Shell Skill Tree - LabEx Certification (LabEx)VICTOR MAESTRE RAMIREZ Shell Skill Tree - LabEx Certification (LabEx)
Smadav Pro 2025 Rev 15.4 Crack Full Version With Registration Key
Smadav Pro 2025 Rev 15.4 Crack Full Version With Registration Keyjoybepari360 ➡️ 🌍📱👉COPY & PASTE LINK👉👉👉
https://crackpurely.site/smadav-pro-crack-full-version-registration-key/
Agile Software Engineering Methodologies
Agile Software Engineering MethodologiesGaurav Sharma Software Engineering Process, Notation & Tools Introduction
Async-ronizing Success at Wix - Patterns for Seamless Microservices - Devoxx ...
Async-ronizing Success at Wix - Patterns for Seamless Microservices - Devoxx ...Natan Silnitsky In a world where speed, resilience, and fault tolerance define success, Wix leverages Kafka to power asynchronous programming across 4,000 microservices. This talk explores four key patterns that boost developer velocity while solving common challenges with scalable, efficient, and reliable solutions:
1. Integration Events: Shift from synchronous calls to pre-fetching to reduce query latency and improve user experience.
2. Task Queue: Offload non-critical tasks like notifications to streamline request flows.
3. Task Scheduler: Enable precise, fault-tolerant delayed or recurring workflows with robust scheduling.
4. Iterator for Long-running Jobs: Process extensive workloads via chunked execution, optimizing scalability and resilience.
For each pattern, we’ll discuss benefits, challenges, and how we mitigate drawbacks to create practical solutions
This session offers actionable insights for developers and architects tackling distributed systems, helping refine microservices and adopting Kafka-driven async excellence.
Smart Financial Solutions: Money Lender Software, Daily Pigmy & Personal Loan...
Smart Financial Solutions: Money Lender Software, Daily Pigmy & Personal Loan...Intelli grow Explore innovative tools tailored for modern finance with our Money Lender Software Development, efficient Daily Pigmy Collection Software, and streamlined Personal Loan Software. This presentation showcases how these solutions simplify loan management, boost collection efficiency, and enhance customer experience for NBFCs, microfinance firms, and individual lenders.
Application Modernization with Choreo - The AI-Native Internal Developer Plat...
Application Modernization with Choreo - The AI-Native Internal Developer Plat...WSO2 In this slide deck, we explore the challenges and best practices of application modernization. We also deep dive how an internal developer platform as a service like Choreo can fast track your modernization journey with AI capabilities and end-to-end workflow automation.
Functional Patterns with Java8 @Bucharest Java User Group
- 1. #DevoxxUK @victorrentea Functional Programming Patterns with Java 8 - live coding marathon - Victor Rentea IBM Lead Architect & Independent Trainer [email protected] www.VictorRentea.ro All the commits will be pushed to https://github.com/victorrentea/functional-patterns-bjug-2018.git
- 3. Victor Rentea 13 years of Java Lead Architect at IBM Tech Team Lead and Consultant Clean Code Evangelist [email protected] www.VictorRentea.ro Moscow Paris London Krakow Vienna Sofia Casablanca Bucharest Belgrade Kiew Barcelona
- 4. victorrentea.ro @victorrentea Spring Hibernate Clean Code, Architectures Java 8, Design Patterns Unit Testing Java Performance Scala & more... Independent Technical Trainer & Coach [email protected] VictorRentea.ro 1000+ devs 5 years tough clients:
- 9. victorrentea.ro @victorrentea Let's CODE !! 9 I'll push everything here: https://github.com/victorrentea/functional-patterns-devoxx-uk
- 11. victorrentea.ro @victorrentea The Clean Code Rules Applied to Java 8 11
- 12. victorrentea.ro @victorrentea Descriptive Names Best Lambdas are fit, thin one-liners Extract heavy lambdas into named ::methods in the same class in the item class as static methods -> {a-nonymous functions 12 Lambdas
- 13. victorrentea.ro @victorrentea Stream Wrecks 1 usecase = 1 single chain of 30 function calls. Don't do that ! We beg you ! We have children, families,… Break them using explanatory variables Small Methods Five Lines 13
- 14. victorrentea.ro @victorrentea Optional Instead: thatOpt.map(myFunction) No NullableParameters Avoid Returning Null,Throw Ex … or return an Optional PS: don't be afraid of Orcs, Monads, or .flatMap 14
- 15. victorrentea.ro @victorrentea Passing-a-Block Pass logic to your function The Funeral of Template Method™ 15
- 16. victorrentea.ro @victorrentea Loan Pattern You work with a resource that is managed for you Decouples real logic from infra code 16
- 17. victorrentea.ro @victorrentea Execute Around Pattern Explicit AOP ~ Proxy™ or Decorator™ 17
- 18. victorrentea.ro @victorrentea Avoid Checked Exceptions java.util.function interfaces don't declare any throws Which is good ! You must suffer if you work with non-Runtime Exceptions! But if you insist: - Define throwing functional interfaces - Use libraries: jool, vavr... 18
- 19. victorrentea.ro @victorrentea Type-specific Logic switch Switch Hunt Day® Hope to find them all: JDD Simplest to Read 1 switch = 1 method case XX: return … OOP Extends is BAD ONE Shot Children90Movie enum Isolated Logic In enum methods Logic with Dependencies Function references on enums (bean passed as param) 19
- 20. victorrentea.ro @victorrentea Thank You! 20 Disclaimer: The use of ® or ™ is the slides is only anecdotic. So good we can ask more explanations after the Pizza What was that??
- 21. victorrentea.ro @victorrentea Thank You! 21 Disclaimer: The use of ® or ™ is the slides is only anecdotic. [email protected] www.VictorRentea.ro Let's Chat:
- 22. victorrentea.ro @victorrentea Thank You! I'm available a statement of seniority I use both hemispheres Tough meetings? Abused estimates? Purpose of code: 1. Maintainable -- Uncle Bob Functional Party Activist Stay into The Light I brought you some Motivational Stickers In-house/remote training or coaching? What do You want us to do the second hour? (after the Pizza) victorrentea.ro/vote.html Dissect some examples Basic Java8 Tutorial (Slow-motion) Mocking Kata TDD Kata Spring @Transactional [email protected] www.VictorRentea.ro