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 16 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.
- The course is based on real-world project codebases, 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 16 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
- 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/9) 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/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
- ACID, locking, and isolation modes
- CQRS and denormalization
- Designing Aggregate Roots
- Combining Hibernate and jOOQ
(7/9) 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/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 eager to improve their Java coding, design and architecture skills.
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.