TDD Mantra
•
0 likes•507 views
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.
Report
Share
Report
Share
Download to read offline
Recommended
Clean Code - The Next Chapter
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.
Extreme Professionalism - Software Craftsmanship
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 is a rich source of communication overhead, a low bus factor, lack of responsibility, blaming, repeated isolated patching and fulminating costs. More than a ‘full-stack’ developer, a software craftsperson distinguishes oneself by acting professionally and taking responsibility for as many aspects of one’s work. Jump on this never-ending journey of continuous improvement and decide what’s the next level for your own case.
For a company/individual training, check out my website: victorrentea.ro
Functional Patterns with Java8 @Bucharest Java User Group
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.
Clean Code
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.
Refactoring blockers and code smells @jNation 2021
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.
The Proxy Fairy, and The Magic of Spring Framework
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 have to master if you are using the Spring Framework. During this session, Victor will share one of the best parts of his Design Patterns training, applied to Spring. You'll hear about the Decorator pattern plus 2 ways to wire it with Spring, bare-hands interface proxies, concrete classes proxies, @Aspect applied to custom annotations, plus some of the most common standard off-the-shelf Spring aspects. Come and learn from a hands-on practitioner real-world best practices of using Aspects, design hints, under-the-hood implementation details, debugging tips, performance impact of aspects, all in an interactive, entertaining and extremely dynamic session.
- Talk held at JPoint 2019, Moscow
Functional Patterns with Java8 at Devoxx UK - Slides
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.
Extreme Professionalism - Software Craftsmanship
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.
Recommended
Clean Code - The Next Chapter
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.
Extreme Professionalism - Software Craftsmanship
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 is a rich source of communication overhead, a low bus factor, lack of responsibility, blaming, repeated isolated patching and fulminating costs. More than a ‘full-stack’ developer, a software craftsperson distinguishes oneself by acting professionally and taking responsibility for as many aspects of one’s work. Jump on this never-ending journey of continuous improvement and decide what’s the next level for your own case.
For a company/individual training, check out my website: victorrentea.ro
Functional Patterns with Java8 @Bucharest Java User Group
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.
Clean Code
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.
Refactoring blockers and code smells @jNation 2021
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.
The Proxy Fairy, and The Magic of Spring Framework
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 have to master if you are using the Spring Framework. During this session, Victor will share one of the best parts of his Design Patterns training, applied to Spring. You'll hear about the Decorator pattern plus 2 ways to wire it with Spring, bare-hands interface proxies, concrete classes proxies, @Aspect applied to custom annotations, plus some of the most common standard off-the-shelf Spring aspects. Come and learn from a hands-on practitioner real-world best practices of using Aspects, design hints, under-the-hood implementation details, debugging tips, performance impact of aspects, all in an interactive, entertaining and extremely dynamic session.
- Talk held at JPoint 2019, Moscow
Functional Patterns with Java8 at Devoxx UK - Slides
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.
Extreme Professionalism - Software Craftsmanship
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.
Clean Pragmatic Architecture - Avoiding a Monolith
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
Clean Code with Java 8 - Functional Patterns and Best Practices
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
A Tale About the Evil Partial Mock and Separation by Layers of Abstractions
We'll see that every partial mock is a wasted opportunity: instead of dropping a spy in there, think a bit about redesigning the system on finer-grained level of abstractions. Instead of mocking a method in your class, think of extracting it away in another class instead, and use a 'regular' mock.
These are the slides from my quickie session at Devoxx Poland 2017: https://youtu.be/pYG0jhCfT2A
Clean Lambdas at JBCNConf by Victor Rentea
This document discusses clean code practices for using lambdas in Java. It recommends encapsulating predicates and filter logic in local variables and helper methods to make code more readable and expressive. It also promotes techniques like pair programming and code reviews to help apply these principles to legacy code. Additional resources include a screencast of a workshop on clean lambdas and the presenter's tweets.
The Art of Clean code
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)
Functional Programming Patterns with Java 8 (at Devoxx BE)
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.
Don't Be Mocked by your Mocks - Best Practices using Mocks
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
Refactoring Games - 15 things to do after Extract Method
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)
Clean pragmatic architecture @ devflix
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 architecture - Protecting the Domain
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.
Engaging Isolation - What I've Learned Delivering 250 Webinar Hours during CO...
In this workshop I will share my experience as a full-time trainer since the COVID-19 outbreak, discussing the techniques I tried, what failed, and what worked, how delivering workshops changed, and what must you do to adapt to today's savage training environment. This is not a sales pitch, but I really want to help you during these times.
Agenda:
- Impactful content type
- Ideal group size
- Ways to adjust the content to remote audiences
- Engaging techniques that really work
- Critical Timing: tricks for better time-use
- The art of asking for questions
- Ways to persist your impact after the session
- Building trust that Online Does Work!
- When and How to gather significant feedback?
- Marketing your webinar
Target Audience: The discussion is not technical (doesn't involve many programming concepts), so anyone interesting in delivering, facilitating or contracting effective online training sessions is invited. Also those preparing to deliver a talk at a conference can benefit from many ideas
Refactoring Asynchronous TypeScript Code
Talk Slides at Voxxed Days Frontend, Bucharest 2019.
Abstract:
You send a request, then you wait for the response. And so it begins… After you get back A, you request B, then C, but only after you also receive D and the user clicks ”OK” in a modal dialog. Sounds familiar? So you know the pain! Asynchronism is probably the most difficult mental leap Single-Page Apps forced us to take, especially if you want to write clean, maintainable code. Join this live-coding session to see us refactoring TypeScript code from callback-hell to promises and then Observables, pair programming and discussing lots of best practices we established for our projects at IBM.
As we go, we will intentionally avoid any framework-specific intelligence: there will be a minimal Angular7 app, but our focus will remain on paradigms and principles. And at the end, we also prepared a tiny surprise for you: a way to avoid your client/server data structures to ever go out of sync again.
Clean Code summary
Presentation I held before my colleagues about the book Clean Code (http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882).
It contains the highlights of several chapters and hint/guidelines a developer should know.
How we tested our code "Google way"
The document discusses how the speaker's team at Playtika tests their code at different levels, from unit to integration tests. Small unit tests are run quickly on continuous integration and aim to achieve high code quality. Medium tests are also run on CI and test services in slightly more depth. Large integration tests were improved to run faster without Docker and test end-to-end scenarios. The team aims to continue improving testing by running more tests automatically and gathering better test results.
Tdd is not about testing
Why should we use TDD to develop in Elixir? When we are applying it correctly? What are the differences that we can find in a code developed with TDD and in code not developed with it? Is it TDD about testing? Really? In this talk, I'll show what is TDD and how can be used it in functional programming like Elixir to design the small and the big parts of your system, showing what are the difference and the similarities between an OOP and FP environment. Showing what is the values of applying a technique like TDD in Elixir and what we should obtain applying it.
Tdd
The document discusses test-driven development (TDD) with Swift. It outlines the rules of TDD, which state that code can only be written to pass a failing unit test and no more production code than needed. The red-green-refactor process is also summarized, where a failing test is written, then code to pass it, then refactoring. Benefits of unit testing like fast feedback, catching edge cases, and preventing regressions are listed. Advantages of TDD like automatic testability, modularity, coverage and living documentation are provided. Some drawbacks like initial slower speed and learning curve are also noted.
XPDays Ukraine: Legacy
This document discusses refactoring legacy code projects. It begins by introducing the author and their experience with legacy projects. It then describes different types of legacy projects using nicknames. It discusses whether a project should be rewritten or refactored. It lists requirements needed for refactoring a legacy project. It compares a developer and customer perspective. It then provides examples of techniques that can be used when refactoring like building procedures, inversion of control, regular expressions, transaction management, and integrating incremental changes. The overall message is that refactoring legacy projects requires an open mindset, establishing trust between developers and customers, and taking problems step-by-step through small incremental changes.
Code Quality Practice and Tools
The document discusses code quality and its importance. It defines code quality as code that works functionally, is testable, and is easy to maintain. It identifies good practices such as writing testable code, avoiding complexity, and following principles like DRY. Tools like test frameworks, code coverage tools, static analysis tools, and integrated tools like Sonar can help ensure code quality and catch issues early.
API World 2016 - A five-sided prism polarizing Web API development
In this session, Jerome Louvel, Restlet's Chief Geek, highlights different approaches to Web API development, along with their pros & cons. Whether you're starting with code, a contract, tests, documentation, or data, you'll get a glimpse of light into the tasty book of API development recipes.
How To Become A Good C# Programmer
In this whitepaper, LearnItFirst founder Scott Whigham talks about how you can become a good (or better) C# programmer. This whitepaper is long - 15 pages - but it includes both a step-by-step system to follow as well as an in-depth discussion of each step.
If you follow this 13-step system (with a bonus 14th step), you can’t help but become a good C# developer!
A journey to_be_a_software_craftsman
Why should we practice XP engineering practices?
What kind of engineering practices should we practices?
How do we practice XP engineering practices?
Test driven development_continuous_integration
This document discusses test-driven development (TDD) and continuous integration (CI). It explains that TDD involves writing tests before code to drive the design. The key steps of TDD are design, test, implement, and test again. CI involves integrating code changes frequently, usually daily, to catch errors early. TDD and CI work well together as the tests from TDD can be run automatically through CI to provide rapid feedback. The document provides an overview of how to implement TDD and CI using tools like Jenkins.
More Related Content
What's hot
Clean Pragmatic Architecture - Avoiding a Monolith
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
Clean Code with Java 8 - Functional Patterns and Best Practices
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
A Tale About the Evil Partial Mock and Separation by Layers of Abstractions
We'll see that every partial mock is a wasted opportunity: instead of dropping a spy in there, think a bit about redesigning the system on finer-grained level of abstractions. Instead of mocking a method in your class, think of extracting it away in another class instead, and use a 'regular' mock.
These are the slides from my quickie session at Devoxx Poland 2017: https://youtu.be/pYG0jhCfT2A
Clean Lambdas at JBCNConf by Victor Rentea
This document discusses clean code practices for using lambdas in Java. It recommends encapsulating predicates and filter logic in local variables and helper methods to make code more readable and expressive. It also promotes techniques like pair programming and code reviews to help apply these principles to legacy code. Additional resources include a screencast of a workshop on clean lambdas and the presenter's tweets.
The Art of Clean code
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)
Functional Programming Patterns with Java 8 (at Devoxx BE)
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.
Don't Be Mocked by your Mocks - Best Practices using Mocks
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
Refactoring Games - 15 things to do after Extract Method
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)
Clean pragmatic architecture @ devflix
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 architecture - Protecting the Domain
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.
Engaging Isolation - What I've Learned Delivering 250 Webinar Hours during CO...
In this workshop I will share my experience as a full-time trainer since the COVID-19 outbreak, discussing the techniques I tried, what failed, and what worked, how delivering workshops changed, and what must you do to adapt to today's savage training environment. This is not a sales pitch, but I really want to help you during these times.
Agenda:
- Impactful content type
- Ideal group size
- Ways to adjust the content to remote audiences
- Engaging techniques that really work
- Critical Timing: tricks for better time-use
- The art of asking for questions
- Ways to persist your impact after the session
- Building trust that Online Does Work!
- When and How to gather significant feedback?
- Marketing your webinar
Target Audience: The discussion is not technical (doesn't involve many programming concepts), so anyone interesting in delivering, facilitating or contracting effective online training sessions is invited. Also those preparing to deliver a talk at a conference can benefit from many ideas
Refactoring Asynchronous TypeScript Code
Talk Slides at Voxxed Days Frontend, Bucharest 2019.
Abstract:
You send a request, then you wait for the response. And so it begins… After you get back A, you request B, then C, but only after you also receive D and the user clicks ”OK” in a modal dialog. Sounds familiar? So you know the pain! Asynchronism is probably the most difficult mental leap Single-Page Apps forced us to take, especially if you want to write clean, maintainable code. Join this live-coding session to see us refactoring TypeScript code from callback-hell to promises and then Observables, pair programming and discussing lots of best practices we established for our projects at IBM.
As we go, we will intentionally avoid any framework-specific intelligence: there will be a minimal Angular7 app, but our focus will remain on paradigms and principles. And at the end, we also prepared a tiny surprise for you: a way to avoid your client/server data structures to ever go out of sync again.
Clean Code summary
Presentation I held before my colleagues about the book Clean Code (http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882).
It contains the highlights of several chapters and hint/guidelines a developer should know.
How we tested our code "Google way"
The document discusses how the speaker's team at Playtika tests their code at different levels, from unit to integration tests. Small unit tests are run quickly on continuous integration and aim to achieve high code quality. Medium tests are also run on CI and test services in slightly more depth. Large integration tests were improved to run faster without Docker and test end-to-end scenarios. The team aims to continue improving testing by running more tests automatically and gathering better test results.
Tdd is not about testing
Why should we use TDD to develop in Elixir? When we are applying it correctly? What are the differences that we can find in a code developed with TDD and in code not developed with it? Is it TDD about testing? Really? In this talk, I'll show what is TDD and how can be used it in functional programming like Elixir to design the small and the big parts of your system, showing what are the difference and the similarities between an OOP and FP environment. Showing what is the values of applying a technique like TDD in Elixir and what we should obtain applying it.
Tdd
The document discusses test-driven development (TDD) with Swift. It outlines the rules of TDD, which state that code can only be written to pass a failing unit test and no more production code than needed. The red-green-refactor process is also summarized, where a failing test is written, then code to pass it, then refactoring. Benefits of unit testing like fast feedback, catching edge cases, and preventing regressions are listed. Advantages of TDD like automatic testability, modularity, coverage and living documentation are provided. Some drawbacks like initial slower speed and learning curve are also noted.
XPDays Ukraine: Legacy
This document discusses refactoring legacy code projects. It begins by introducing the author and their experience with legacy projects. It then describes different types of legacy projects using nicknames. It discusses whether a project should be rewritten or refactored. It lists requirements needed for refactoring a legacy project. It compares a developer and customer perspective. It then provides examples of techniques that can be used when refactoring like building procedures, inversion of control, regular expressions, transaction management, and integrating incremental changes. The overall message is that refactoring legacy projects requires an open mindset, establishing trust between developers and customers, and taking problems step-by-step through small incremental changes.
Code Quality Practice and Tools
The document discusses code quality and its importance. It defines code quality as code that works functionally, is testable, and is easy to maintain. It identifies good practices such as writing testable code, avoiding complexity, and following principles like DRY. Tools like test frameworks, code coverage tools, static analysis tools, and integrated tools like Sonar can help ensure code quality and catch issues early.
API World 2016 - A five-sided prism polarizing Web API development
In this session, Jerome Louvel, Restlet's Chief Geek, highlights different approaches to Web API development, along with their pros & cons. Whether you're starting with code, a contract, tests, documentation, or data, you'll get a glimpse of light into the tasty book of API development recipes.
How To Become A Good C# Programmer
In this whitepaper, LearnItFirst founder Scott Whigham talks about how you can become a good (or better) C# programmer. This whitepaper is long - 15 pages - but it includes both a step-by-step system to follow as well as an in-depth discussion of each step.
If you follow this 13-step system (with a bonus 14th step), you can’t help but become a good C# developer!
What's hot (20)
Clean Pragmatic Architecture - Avoiding a Monolith
Clean Pragmatic Architecture - Avoiding a Monolith
Clean Code with Java 8 - Functional Patterns and Best Practices
Clean Code with Java 8 - Functional Patterns and Best Practices
A Tale About the Evil Partial Mock and Separation by Layers of Abstractions
A Tale About the Evil Partial Mock and Separation by Layers of Abstractions
Functional Programming Patterns with Java 8 (at Devoxx BE)
Functional Programming Patterns with Java 8 (at Devoxx BE)
Don't Be Mocked by your Mocks - Best Practices using Mocks
Don't Be Mocked by your Mocks - Best Practices using Mocks
Refactoring Games - 15 things to do after Extract Method
Refactoring Games - 15 things to do after Extract Method
Engaging Isolation - What I've Learned Delivering 250 Webinar Hours during CO...
Engaging Isolation - What I've Learned Delivering 250 Webinar Hours during CO...
API World 2016 - A five-sided prism polarizing Web API development
API World 2016 - A five-sided prism polarizing Web API development
Similar to TDD Mantra
A journey to_be_a_software_craftsman
Why should we practice XP engineering practices?
What kind of engineering practices should we practices?
How do we practice XP engineering practices?
Test driven development_continuous_integration
This document discusses test-driven development (TDD) and continuous integration (CI). It explains that TDD involves writing tests before code to drive the design. The key steps of TDD are design, test, implement, and test again. CI involves integrating code changes frequently, usually daily, to catch errors early. TDD and CI work well together as the tests from TDD can be run automatically through CI to provide rapid feedback. The document provides an overview of how to implement TDD and CI using tools like Jenkins.
Test Driven Development and Automation
This document discusses test driven development (TDD) and automation for PHP projects. It covers what TDD is, why it should be done, where tests should run, who should adopt TDD, and why unit testing, code coverage, code sniffing and Selenium are important. It also discusses tools for PHP TDD like Xdebug, PHPUnit, PHP_CodeSniffer and IDEs. The document provides examples of writing test cases with the red-green-refactor process and integrating TDD into a build system with automated testing on every code change.
Hibernate and Spring - Unleash the Magic
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.
TDD Dojo - Test Driven Development Coding Dojo
Slide of the T.D.D. Coding Dojo (programming language neutral version)
T.D.D. Dojo Agenda (3 hours):
05' Welcome and Dojo rules.
15' T.D.D. in a very small nutshell (slides)
05' Q&A
20' TDD Sempai demo (I will show how to use TDD to solve a simple kata)
10' Choose the kata
25' Kata first round
05' break
25' Kata second round
05' break
25' Kata third round
05' break
30' Lesson learned: code sharing
Introduction to test_driven_development
This is the slides of my talk @ Taiwan Java User Group on 2011/07/09.
You can watch the video here (in Chinese):
http://vimeo.com/26538602
Test Driven Design - GDG DevFest Istanbul 2016
TDD is the elengant way of designing software. People scares from it so much, because software design is hard and it requires discipline. In this talk, I tried to describe what TDD is from software design perspective.
Test Driven Design
The document discusses test-driven development (TDD) and its relationship to software design. It states that the source code is the real software design and that testing is part of refining the design. Well-designed code has high cohesion and low coupling, which TDD helps achieve by writing tests before code and refactoring along the way. The design process is iterative, with programming, testing, refactoring, and verification all contributing to the evolving design captured in the source code.
Continuous delivery from the trenches
A presentation form Integration Stockholm where we shared our collected thoughts on how to implement Continuous Delivery in mainly Enterprise organisations. What has worked for us and what did not work and how to approach CI/CD and succeed...
Test Driven Development
Testing is not something that traditional PHP developers are being familiar with. This session introduces the needs and means for testing, and the test-driven development model to create rock-solid PHP applications.
DevOps in an Embedded World
Talk presented at DevOpsDays in Auckland (2017) discussing how DevOps applies to Embedded Software Development. This talk discusses the approaches Navico have taken in the past and are planning to do going forward.
Software reengineering for Developers
A presentation I made to the Buenos Aires Microsoft User Group on Jan 3 2012 on how to reengineerin existing legacy systems.
TDD with BizTalk
This is a presentation that I gave on doing TDD with BizTalk. It was part of a series of pre-TechEd presentations.
Anita ThakurCV
This document contains a resume for Anita Thakur seeking a position as a Software Engineer. She has over 1 year of experience developing Java applications using Hibernate and Galileo frameworks. Her most recent role involved application development, testing, bug fixing, and code deployment for a client at Credit Agricole Corporate and Investment Bank. She is proficient in technologies like Java, SQL, Hibernate, XML, and Linux/Unix. Anita holds a B.Tech in Computer Science and has additional training in areas like Oracle, SQL, and financial markets.
Test driven development and react js application go hand in hand
Test-driven development (TDD) is an important approach for React application development. TDD involves writing tests before writing code to ensure features are well-specified and code works as intended. Some key benefits of TDD for React include high test coverage, exceptional code quality, reduced costs from fewer bugs, and convenient debugging. Popular tools for TDD with React are Jest for tests, Enzyme for mounting components, and Cypress for end-to-end testing. Developers should follow best practices like single responsibility components and maximizing code reuse. Overall, TDD helps produce robust, maintainable React applications.
examkiller 000-938
The three parameters required when configuring an Email Reader service in IBM Tivoli Netcool Impact are:
1. Mail Server
2. Mailbox
3. Mail Protocol
Test Driven Development
TDD is a software development practice where tests are written before production code to define requirements. It follows three rules: 1) Write a test that fails without production code. 2) Write just enough production code to pass the test. 3) Refactor code without changing external behavior. This ensures code is properly tested and reduces bugs through frequent integration and refactoring enabled by the test suite. TDD results in testable, loosely coupled code and faster delivery times.
Apex triggers i
This document provides an overview of Apex triggers in Salesforce. It discusses what Apex triggers are, how they can be used to support record management and build process-driven logic. The document compares triggers to process builders and explains the order of execution. It also covers sandbox and developer environments, the developer console for debugging, and includes an Apex trigger demo.
Android Test Driven Development
This document discusses test driven development for mobile applications. It compares the traditional development cycle to a test driven development cycle. It also discusses how using the Robolectric framework allows testing Android applications outside of an emulator, improving the speed of test driven development. Key benefits of test driven development mentioned include delivering functionality faster, improving code quality and confidence, and allowing more time for cleaning code and learning new tools.
End-end tests as first class citizens - SeleniumConf 2020
My talk at SeleniumConf 2020 Virtual on how to treat your end-end tests and framework as first class citizens.
Similar to TDD Mantra (20)
Test driven development and react js application go hand in hand
Test driven development and react js application go hand in hand
End-end tests as first class citizens - SeleniumConf 2020
End-end tests as first class citizens - SeleniumConf 2020
More from Victor Rentea
Finding Java's Hidden Performance Traps @ DevoxxUK 2024
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
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
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
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
Clean Code @Voxxed Days Cluj 2023 - opening Keynote
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.
Testing Microservices @DevoxxBE 23.pdf
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
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
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
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
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
The tests are trying to tell you something@VoxxedBucharest.pptx
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.
Vertical Slicing Architectures
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
Software Craftsmanship @Code Camp Festival 2022.pdf
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.
Unit testing - 9 design hints
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.
Integration testing with spring @JAX Mainz
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
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.
Integration testing with spring @snow one
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.
Pure functions and immutable objects @dev nexus 2021
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.
Definitive Guide to Working With Exceptions in Java - takj at Java Champions ...
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
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
More from Victor Rentea (20)
Finding Java's Hidden Performance Traps @ DevoxxUK 2024
Finding Java's Hidden Performance Traps @ DevoxxUK 2024
Modular Monolith - a Practical Alternative to Microservices @ Devoxx UK 2024
Modular Monolith - a Practical Alternative to Microservices @ Devoxx UK 2024
Clean Code @Voxxed Days Cluj 2023 - opening Keynote
Clean Code @Voxxed Days Cluj 2023 - opening Keynote
The tests are trying to tell you something@VoxxedBucharest.pptx
The tests are trying to tell you something@VoxxedBucharest.pptx
Software Craftsmanship @Code Camp Festival 2022.pdf
Software Craftsmanship @Code Camp Festival 2022.pdf
The Proxy Fairy and the Magic of Spring @JAX Mainz 2021
The Proxy Fairy and the Magic of Spring @JAX Mainz 2021
Pure functions and immutable objects @dev nexus 2021
Pure functions and immutable objects @dev nexus 2021
Definitive Guide to Working With Exceptions in Java - takj at Java Champions ...
Definitive Guide to Working With Exceptions in Java - takj at Java Champions ...
Recently uploaded
Top 9 Trends in Cybersecurity for 2024.pptx
Security and risk management (SRM) leaders face disruptions on technological, organizational, and human fronts. Preparation and pragmatic execution are key for dealing with these disruptions and providing the right cybersecurity program.
Artificia Intellicence and XPath Extension Functions
The purpose of this presentation is to provide an overview of how you can use AI from XSLT, XQuery, Schematron, or XML Refactoring operations, the potential benefits of using AI, and some of the challenges we face.
Enums On Steroids - let's look at sealed classes !
These are slides for my session"Enums On Steroids - let's look at sealed classes !" - delivered among others, on Devoxx UK 2024 conference
WWDC 2024 Keynote Review: For CocoaCoders Austin
Overview of WWDC 2024 Keynote Address.
Covers: Apple Intelligence, iOS18, macOS Sequoia, iPadOS, watchOS, visionOS, and Apple TV+.
Understandable dialogue on Apple TV+
On-device app controlling AI.
Access to ChatGPT with a guest appearance by Chief Data Thief Sam Altman!
App Locking! iPhone Mirroring! And a Calculator!!
Need for Speed: Removing speed bumps from your Symfony projects ⚡️
No one wants their application to drag like a car stuck in the slow lane! Yet it’s all too common to encounter bumpy, pothole-filled solutions that slow the speed of any application. Symfony apps are not an exception.
In this talk, I will take you for a spin around the performance racetrack. We’ll explore common pitfalls - those hidden potholes on your application that can cause unexpected slowdowns. Learn how to spot these performance bumps early, and more importantly, how to navigate around them to keep your application running at top speed.
We will focus in particular on tuning your engine at the application level, making the right adjustments to ensure that your system responds like a well-oiled, high-performance race car.
316895207-SAP-Oil-and-Gas-Downstream-Training.pptx
316895207-SAP-Oil-and-Gas-Downstream-Training.pptx
Hand Rolled Applicative User Validation Code Kata
Could you use a simple piece of Scala validation code (granted, a very simplistic one too!) that you can rewrite, now and again, to refresh your basic understanding of Applicative operators <*>, <*, *>?
The goal is not to write perfect code showcasing validation, but rather, to provide a small, rough-and ready exercise to reinforce your muscle-memory.
Despite its grandiose-sounding title, this deck consists of just three slides showing the Scala 3 code to be rewritten whenever the details of the operators begin to fade away.
The code is my rough and ready translation of a Haskell user-validation program found in a book called Finding Success (and Failure) in Haskell - Fall in love with applicative functors.
Requirement Traceability in Xen Functional Safety
Using OpenFastTrace to trace requirements in Xen functional safety
Microservice Teams - How the cloud changes the way we work
A lot of technical challenges and complexity come with building a cloud-native and distributed architecture. The way we develop backend software has fundamentally changed in the last ten years. Managing a microservices architecture demands a lot of us to ensure observability and operational resiliency. But did you also change the way you run your development teams?
Sven will talk about Atlassian’s journey from a monolith to a multi-tenanted architecture and how it affected the way the engineering teams work. You will learn how we shifted to service ownership, moved to more autonomous teams (and its challenges), and established platform and enablement teams.
E-commerce Development Services- Hornet Dynamics
For any business hoping to succeed in the digital age, having a strong online presence is crucial. We offer Ecommerce Development Services that are customized according to your business requirements and client preferences, enabling you to create a dynamic, safe, and user-friendly online store.
8 Best Automated Android App Testing Tool and Framework in 2024.pdf
Regarding mobile operating systems, two major players dominate our thoughts: Android and iPhone. With Android leading the market, software development companies are focused on delivering apps compatible with this OS. Ensuring an app's functionality across various Android devices, OS versions, and hardware specifications is critical, making Android app testing essential.
zOS Mainframe JES2-JES3 JCL-JECL Differences
Document which explains the difference between Jes2 and Jes3
原版定制美国纽约州立大学奥尔巴尼分校毕业证学位证书原版一模一样
原版一模一样【微信：741003700 】【美国纽约州立大学奥尔巴尼分校毕业证学位证书】【微信：741003700 】学位证，留信认证（真实可查，永久存档）offer、雅思、外壳等材料/诚信可靠,可直接看成品样本，帮您解决无法毕业带来的各种难题！外壳，原版制作，诚信可靠，可直接看成品样本。行业标杆！精益求精，诚心合作，真诚制作！多年品质 ,按需精细制作，24小时接单,全套进口原装设备。十五年致力于帮助留学生解决难题，包您满意。
本公司拥有海外各大学样板无数，能完美还原海外各大学 Bachelor Diploma degree, Master Degree Diploma
1:1完美还原海外各大学毕业材料上的工艺：水印，阴影底纹，钢印LOGO烫金烫银，LOGO烫金烫银复合重叠。文字图案浮雕、激光镭射、紫外荧光、温感、复印防伪等防伪工艺。材料咨询办理、认证咨询办理请加学历顾问Q/微741003700
留信网认证的作用:
1:该专业认证可证明留学生真实身份
2:同时对留学生所学专业登记给予评定
3:国家专业人才认证中心颁发入库证书
4:这个认证书并且可以归档倒地方
5:凡事获得留信网入网的信息将会逐步更新到个人身份内，将在公安局网内查询个人身份证信息后，同步读取人才网入库信息
6:个人职称评审加20分
7:个人信誉贷款加10分
8:在国家人才网主办的国家网络招聘大会中纳入资料，供国家高端企业选择人才
Top Benefits of Using Salesforce Healthcare CRM for Patient Management.pdf
Salesforce Healthcare CRM, implemented by VALiNTRY360, revolutionizes patient management by enhancing patient engagement, streamlining administrative processes, and improving care coordination. Its advanced analytics, robust security, and seamless integration with telehealth services ensure that healthcare providers can deliver personalized, efficient, and secure patient care. By automating routine tasks and providing actionable insights, Salesforce Healthcare CRM enables healthcare providers to focus on delivering high-quality care, leading to better patient outcomes and higher satisfaction. VALiNTRY360's expertise ensures a tailored solution that meets the unique needs of any healthcare practice, from small clinics to large hospital systems.
For more info visit us https://valintry360.com/solutions/health-life-sciences
Odoo ERP Vs. Traditional ERP Systems – A Comparative Analysis
When it is all about ERP solutions, companies typically meet their needs with common ERP solutions like SAP, Oracle, and Microsoft Dynamics. These big players have demonstrated that ERP systems can be either simple or highly comprehensive. This remains true today, but there are new factors to consider, including a promising new contender in the market that’s Odoo. This blog compares Odoo ERP with traditional ERP systems and explains why many companies now see Odoo ERP as the best choice.
What are ERP Systems?
An ERP, or Enterprise Resource Planning, system provides your company with valuable information to help you make better decisions and boost your ROI. You should choose an ERP system based on your company’s specific needs. For instance, if you run a manufacturing or retail business, you will need an ERP system that efficiently manages inventory. A consulting firm, on the other hand, would benefit from an ERP system that enhances daily operations. Similarly, eCommerce stores would select an ERP system tailored to their needs.
Because different businesses have different requirements, ERP system functionalities can vary. Among the various ERP systems available, Odoo ERP is considered one of the best in the ERp market with more than 12 million global users today.
Odoo is an open-source ERP system initially designed for small to medium-sized businesses but now suitable for a wide range of companies. Odoo offers a scalable and configurable point-of-sale management solution and allows you to create customised modules for specific industries. Odoo is gaining more popularity because it is built in a way that allows easy customisation, has a user-friendly interface, and is affordable. Here, you will cover the main differences and get to know why Odoo is gaining attention despite the many other ERP systems available in the market.
Everything You Need to Know About X-Sign: The eSign Functionality of XfilesPr...
Wondering how X-Sign gained popularity in a quick time span? This eSign functionality of XfilesPro DocuPrime has many advancements to offer for Salesforce users. Explore them now!
GreenCode-A-VSCode-Plugin--Dario-Jurisic
Presentation about a VSCode plugin from Dario Jurisic at the GSD Community Stage meetup
J-Spring 2024 - Going serverless with Quarkus, GraalVM native images and AWS ...
Presented at NLJUG's J-Spring 2024.
KuberTENes Birthday Bash Guadalajara - Introducción a Argo CD
Charla impartida en el evento de "KuberTENes Birthday Bash Guadalajara" para celebrar el 10mo. aniversario de Kubernetes #kuberTENes #celebr8k8s #k8s
Recently uploaded (20)
Artificia Intellicence and XPath Extension Functions
Artificia Intellicence and XPath Extension Functions
Enums On Steroids - let's look at sealed classes !
Enums On Steroids - let's look at sealed classes !
Need for Speed: Removing speed bumps from your Symfony projects ⚡️
Need for Speed: Removing speed bumps from your Symfony projects ⚡️
316895207-SAP-Oil-and-Gas-Downstream-Training.pptx
316895207-SAP-Oil-and-Gas-Downstream-Training.pptx
Microservice Teams - How the cloud changes the way we work
Microservice Teams - How the cloud changes the way we work
8 Best Automated Android App Testing Tool and Framework in 2024.pdf
8 Best Automated Android App Testing Tool and Framework in 2024.pdf
Top Benefits of Using Salesforce Healthcare CRM for Patient Management.pdf
Top Benefits of Using Salesforce Healthcare CRM for Patient Management.pdf
Odoo ERP Vs. Traditional ERP Systems – A Comparative Analysis
Odoo ERP Vs. Traditional ERP Systems – A Comparative Analysis
Everything You Need to Know About X-Sign: The eSign Functionality of XfilesPr...
Everything You Need to Know About X-Sign: The eSign Functionality of XfilesPr...
J-Spring 2024 - Going serverless with Quarkus, GraalVM native images and AWS ...
J-Spring 2024 - Going serverless with Quarkus, GraalVM native images and AWS ...
KuberTENes Birthday Bash Guadalajara - Introducción a Argo CD
KuberTENes Birthday Bash Guadalajara - Introducción a Argo CD
TDD Mantra
- 1. Victor Rentea Blog, Talks, Goodies on VictorRentea.ro Independent Trainer Founder of Bucharest Software Craftsmanship Community Java Champion ❤️ Simple Design, Refactoring, Unit Testing ❤️
- 2. Technical Training 400 days (100+ online) 2000 devs 8 years Training for you or your company: VictorRentea.ro 40 companies Posting Good Stuff on: Hibernate Spring Functional Prog Java Performance Reactive Design Patterns Clean Code Refactoring Unit Testing any lang
- 3. 128 © VictorRentea.ro a training by A discipline in which you grow software in small increments for which you write the tests before the implementation Test-Driven Development Credited to Kent Beck, 2003
- 4. 129 © VictorRentea.ro a training by 1. Write prod code only to fix a failing test - Although we often foresee the implementation 2. Write 1 test for a feature not yet implemented - It must fail with grace 3. Write just enough prod code to pass the test The 3 Rules of TDD--Uncle Bob Code Golf Fewest keystrokes to make it pass few