Clean Code with Java 

Course & Training

Learn to write clean, elegant and maintainable code in Java.

A two or three day workshop where we explore the principles and practices of Clean Code with Java. We focus on design strategies, abstraction levels, and combining object-oriented with functional programming. Learn how to write elegant, expressive code and effectively use modern Java features.

In-House Course:

We are happy to conduct tailored courses for your team - on-site, remotely or in our course rooms.

Request In-House Course

   

Content:


Clean Code is a crucial aspect of software development that ensures our code remains understandable, modifiable, and extensible. In this course, we learn the principles of Clean Code and how to apply them in Java. The focus is on design strategies, finding the right level of abstraction, and writing elegant, expressive code.

The workshop includes the following topics:

– Introduction to Clean Code
... - Overview of Clean Code and expectations for the workshop
... - Why Clean Code matters and how to avoid perfectionism

– Effective Naming and Abstraction
... - The art of naming
... - Identifying the right level of abstraction

– Refactoring and Lean Code
... - Cognitive load as a driver for refactoring
... - Lean Code and Just-Enough-Design

– Design Strategies and Principles
... - Balance between specific and abstract code
... - Reification
... - Avoiding premature abstractions (AHA and WET principles)

– OOP & Functional Programming
... - Combining OOP with functional programming
... - Do or Die Principle (DOD)
... - SOLID, DRY, YAGNI and Law of Demeter

– Null-safe Programming and the Stepdown Rule
... - Null-safe programming
... - The Stepdown Rule

– Elegant and Expressive Code
... - Replace getters with Queries, setters with Domain Methods
... - Flatten conditionals with Monads

– Object Design and Primitive Obsession
... - Elegant Objects
... - Primitive Obsession and Value Objects

– Exception Handling and Data Classes
... - Pluggable exception handling strategies
... - Design of data classes (Lombok, Immutables, pure Java)

– Extended Collections and Dependency Injection
... - Extended Java Collections (Guava, Vavr)
... - Memoization and advanced Dependency Injection patterns (Spring)

– Test Driven Development (TDD)
... - Test-driven components

You will not only get to know these concepts but also apply them practically.


Disclaimer: The actual course content may vary from the above, depending on the trainer, implementation, duration and constellation of participants.

Whether we call it training, course, workshop or seminar, we want to pick up participants at their point and equip them with the necessary practical knowledge so that they can apply the technology directly after the training and deepen it independently.

Goal:

By the end of this course, learners will gain a comprehensive understanding of how to write clean, elegant, and maintainable code in Java. They will know how to choose the right level of abstraction, combine functional concepts with OOP, and effectively use modern Java.


Duration:

 2 Days (Is individually adapted for in-house courses.)


Form:

A proven mix of concepts, workshop simulation, live coding and exercises.


Target Audience:

You are a Software Engineer or Software Architect and want to improve your skills in:
- Applying Clean Code principles in Java
- Design strategies and finding the right level of abstraction
- Combining OOP with functional programming
- Elegant Objects and Value Objects
- Modern Java features and libraries (Lombok, Guava, Vavr)
- Test Driven Development with Java


Requirements:

Basic knowledge in software engineering and Java


Preparation:

Each participant receives a questionnaire and installation instructions after registration. Depending on the course, we provide a suitable laboratory environment.

Request In-House Course:

In-House Kurs Anfragen

Waitinglist for public course:

Sign up for the waiting list for more public course dates. Once we have enough people on the waiting list, we will determine a date that suits everyone as much as possible and schedule a new session. If you want to participate directly with two colleagues, we can even plan a public course specifically for you.

Waiting List Request

(If you already have 3 or more participants, we will discuss your preferred date directly with you and announce the course.)

More about Clean Code with Java



Clean Code in Java goes beyond mere formatting – it encompasses design strategies, abstraction levels, and combining object-oriented with functional programming. This course teaches principles like SOLID, DRY, YAGNI, and the Law of Demeter with a focus on elegant, maintainable Java solutions.




History


The term "Clean Code" was popularized by Robert C. Martin (Uncle Bob), who published the book of the same name in 2008. The principles are based on decades of software development and were shaped by pioneers like Kent Beck, Martin Fowler, and others.


For Java, Joshua Bloch's "Effective Java" and the functional programming movement have become particularly relevant. Modern Java versions (from Java 8 onwards) bring functional concepts like lambdas and streams directly into the language.


Today, Clean Code is a recognized standard in professional software development. Combining it with functional programming, Value Objects, and modern libraries like Lombok, Guava, and Vavr enables elegant, expressive Java solutions.