Do you want to write code that your teammates will admire? 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 14 course for 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.
- ⚡ Warning: After this course, your Java code will never be the same again.
- The course is based on real-world project code, stories and examples.
- The course demos are built using real-world libraries such as Spring, Hibernate, and Guava.
- The course includes practical Lab work and an optional homework assignment.
- The course is updated to support Java 14 additions and functional programming idioms (but is relevant for apps that run on older Java versions).
- You will get a list of books, videos, GitHub projects to learn from, and lifetime support from Eduards.
What's under the hood?
(1/9) Effective code design
- Understanding use-reuse paradox
- Understanding reification
- Avoid Hasty Abstractions (AHA)
- Do or Die Principle (DoD)
- How to find the right level of abstraction
- How to use cognitive load as a driver for refactoring
- KISS, SOLID, DRY, ABS, YAGNI
- Just-enough design and Lean code
(2/9) Effective functions
- Are lambdas always a good choice?
- Nulls vs. optionals
- SLAP principle
- Step-down rule
- Eliminating getters or setters
- Command-query separation
- Making conditional easy to read
- Comments vs. smart annotations
(3/9) 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/9) 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/9) 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/9) Effective persistence
- Unit of Work pattern
- Transaction management
- Transactional queue / outbox
- Consistency modes
- Denormalization (when / why / how)
- Aggregate roots
- Hibernate / jOOQ combination
(7/9) Effective validation
- Secure by design
- Simple validation
- Business rule validation
- Why Bean Validation sucks
- Bean Validation vs. Yavi vs. Fluent Validator
- Implementing a small validation library
(8/9) 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/9) Effective resilience
- Fault tolerance patterns
- Rate limiting
- Circuit breakers
- Hystrix vs. Resilience4j vs. Failsafe
Ready to upgrade your coding skills? Join in!
Java developers, architects and team leaders willing to significantly improve their Java skills, productivity and career opportunities.
You earn a Certificate of Accomplishment after completing an exam. Use it to boost your CV and LinkedIn profile.
The course runs in a diverse international group and is taught in English.