New! Effective Coding Principles and Patterns in Java

Do you want to write code that is easy to read and test? Develop real-world Java applications that are easy to maintain? Move fast without compromising quality?

Then this course is for you.

During this intensive and practical 2-day workshop, you will learn how to develop modern, clean, and maintainable applications using the latest Java best practices. This is not a trivial Java 15 course for complete beginners. Here you'll learn real-world stuff from class design and unit testing to large-scale architecture, controlling quality, and getting out of technical debt.

1. Effective code design

• Finding the right level of abstraction
• Using cognitive load as a driver for refactoring
• Balancing use vs. reuse paradox
• Understanding reification
• Avoid Hasty Abstractions (AHA)
• Do or Die Principle (DoD)
• KISS, SOLID, DRY, ABS, YAGNI
• Just-enough design and Lean code

 2. Effective functions

• Are lambdas always a good choice?
• Nulls vs. optionals
• SLAP principle
• The Step-down rule
• Command-query separation
• Replacing getters with queries
• Replacing setters with domain-driven methods
• Making conditional easy to read

3. Effective class design

• Stateful objects or pure functions?
• Objects or data classes?
• Anemic or rich domain model?
• Designing entities
• Designing value objects
• Designing domain events / event bus
• Designing exception class hierarchy

4. Effective service layer

• What is a service layer and why we need it?
• What's the relation with the domain model?
• Two approaches to services: procedures and commands
• Implementing services with PipelinR library
• Commands / Handlers / Pipelines
• Cross-cutting concerns (logging, transactions, resilience)
• Offloading and scheduling work

5. Effective packaging

• How to group classes?
• How much layering is needed?
• Packages vs. modules
• First Guess Principle
• Minimum Visibility Principle
• Common Closure Principle
• Modularity patterns
• Dependency management
• Balancing coupling and cohesion

6. Effective persistence

• DAOs
• Repositories
• Unit of Work pattern
• Transaction management
• Transactional queue / outbox
• ACID, locking, and isolation modes
• CQRS and denormalization
• Designing Aggregate Roots
• Combining Hibernate and jOOQ

7. Effective validation

• Secure by design
• Simple validation
• Business rule validation
• Why Bean Validation sucks
• Bean Validation vs. Fluent Validator
• Implementing a small validation library

8. Effective testing

• What is a unit?
• Qualities of a good unit test
• How to make (finally) TDD work
• How to test integrations, APIs, concurrency, async code
• How to test architecture rules and constraints
• Libraries that simplify testing (Spock, Testcontainers...)

9. Effective resilienc

• Fault tolerance patterns
• Retries
• Timeouts
• Bulkheads
• Rate limiting
• Circuit breakers
• Hystrix vs. Resilience4j vs. Failsafe

You will get a list of books, videos, GitHub projects to learn from, and lifetime support from Eduards.