Sources for ST2-M1 milestone as an Overview for AI-based Tools

This page provides an overview of the sources for the ST2-M1 milestone, which can be used as a reference for AI-based tools. It includes links to the relevant repositories, documentation, and other resources that are essential for completing the milestone successfully. This page is supposed to be a starting point for studentic projects, bachelor and master theses which deal with the task of building RAG and/or agentic AI-based chatbots for students in the ST2 course. It is not intended to be a comprehensive guide, but rather a collection of resources that can be used to get started with the milestone.

• Videos (Primary Sources)
  • What are Aggregates?
  • Six Rules for Aggregates
  • SOLID Principles
  • Single Responsibility Principle
  • Open-Closed Principle
  • Dependency Inversion Principle
  • Clean Code Rules
• Podcasts
  • Clean Coding – a Question of Good Software Architecture (DEV-METAL Podcast)
• Videos (Secondary Sources)
  • Four Books You REALLY Should Have
• Information Pages
  • Spring Framework and Spring Data JPA
  • Clean Code and SOLID Principles
  • Domain-Driven Design (DDD)
• Sample Code Repositories

Videos (Primary Sources)

The videos in this section directly explain the tasks to be done in that milestone M1, which is the focus of this page. All the videos below are in German but have been provided with chapter markings and a quality-checked English translation available as subtitles.

(NOTE: the chapter markings are work in progress!)

What are Aggregates?

This video attempts a definition of what aggregates are and what role they can play in software design. The transition from the concept of aggregates to a specific module structure and software is explained in the video.

Six Rules for Aggregates

This video presents six practical rules for designing aggregates in Domain-Driven Design. It covers guidelines on aggregate sizing, and how recognize aggregate boundaries.

SOLID Principles

This video gives an overview of the five SOLID principles of object-oriented design: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. It explains why these principles matter and how they contribute to maintainable, flexible software architectures.

Single Responsibility Principle

This video dives deeper into the Single Responsibility Principle (SRP), explaining that each class or module should have only one reason to change. It discusses how to identify violations and refactor code accordingly.

Open-Closed Principle

This video explains the Open-Closed Principle (OCP), which states that software entities should be open for extension but closed for modification. It demonstrates how to achieve this through abstraction and polymorphism.

Dependency Inversion Principle

This video covers the Dependency Inversion Principle (DIP), explaining that high-level modules should not depend on low-level modules, but both should depend on abstractions. It shows how applying DIP leads to more decoupled and testable architectures. It also explains the specific role that the DIP can play in resolving cyclic dependencies in a codebase.

Clean Code Rules

This video presents essential clean code rules and best practices for writing readable, maintainable code. It covers naming conventions, function design, code structure, and other guidelines that help teams produce high-quality software.

Podcasts

There is one podcast entirely in German with no translation available and no chapter markings.

Clean Coding – a Question of Good Software Architecture (DEV-METAL Podcast)

This podcast episode discusses how clean coding practices and software architecture are deeply intertwined. It explores why writing clean code is not just about aesthetics but a fundamental aspect of building sustainable and well-architected software systems.

Videos (Secondary Sources)

The following videos are useful as a background and a recap for students who need to understand concepts that are mentioned in this milestone, especially with regard to logical data models (LDM).

Four Books You REALLY Should Have

This video presents four essential books that every software developer should read. It covers classics like “Clean Code” by Robert C. Martin, Vaughn Vernon’s “Red Book”, “Domain-Driven Design” by Eric Evans (the “blue book”), and “Refactoring” by Martin Fowler. The video explains why these books are important and how they can help developers improve their skills and understanding of software design principles.

Information Pages

Spring Framework and Spring Data JPA

Anti-Patterns in Spring Data JPA

Anti-Patterns bei "DDD mit Spring JPA"

In the ST2 lab course, we frequently encounter the following anti-patterns and errors. If you want to implement a DDD architecture with Spring JPA, you should avoid these. If you are not quite sure what is meant by "anti-patterns", then watch the video about it. The following list can help you avoid commonly occurring errors. The following patterns do not lead to errors in the code, but to bad code. The anti-patterns have no priority order; this is an unordered collection.

Frequent Mistakes in Spring Data JPA

Häufige Fehler bei der Verwendung von Spring

In the ST2 lab course, we frequently encounter the following errors. If you want to implement a DDD architecture with Spring JPA, you should avoid these. The following errors typically cause a Spring application to stop running, for example throwing the ever-popular `Failed to load Application Context` exception. The listed errors have no priority order; this is an unordered collection - without claiming to be complete. If you notice an error that is not listed here, feel free to write it up!

Implementing Aggregates with Spring Data JPA

Implementing Aggregates using Spring JPA

When you implement DDD Aggregates using just "regular" Spring JPA (not e.g. Spring Modulith), there are a number of practical tips to consider

Clean Code and SOLID Principles

Checklist for Clean Code and SOLID Principles

Checkliste für Clean Code und SOLID-Prinzipien

Here you will find a (subjective) compilation of what we consider the most important and practical aspects of Clean Code and the SOLID principles. You can use the list as a checklist for your own code to identify refactoring needs. The list is also suitable for code reviews.

PMD Plugin Static Code Analysis in Java

IntelliJ PMD Plugin für den PMD Source Code Analyzer

Here you will find a brief installation and usage guide for the [PMD Plugin for IntelliJ](https://plugins.jetbrains.com/plugin/1137-pmd).

Resolving Cyclic Dependencies with the Dependency Inversion Principle (DIP)

Zykel auflösen mittels Dependency Inversion Principle

When implementing a Domain-Driven Design with Spring JPA, certain patterns help that can be used repeatedly. If you are not quite sure what is meant by "patterns", then watch the video about it.

Domain-Driven Design (DDD)

DDD Glossary of Key Terms

Glossary of Key DDD Terms

Domain-Driven Design (DDD) contains a consistent set of concepts and terms, which need to be understood in order to apply DDD successfully. This glossary provides a brief overview of the most important terms. Rather than providing some own wording, the main DDD authors will speak for themselves.

DDD Literature

Commented Literature and Online Sources for DDD

This list provides a (subjective) list of articles, books, and online sources for DDD.

Package Conventions in Domain-Driven Design (DDD)

Aggregate Design Rules according to Vaughn Vernon’s “Red Book”

Aggregate Design Rules according to Vaughn Vernon's "Red Book"

In Vaughn Vernon's "Red Book," aggregates are defined as clusters of domain objects that are treated as a single unit for data changes. They are used to enforce consistency and encapsulate the business rules within a domain model. Aggregates often consist of an aggregate root entity, which is the primary entry point for accessing and modifying the data within the aggregate, along with other related entities and value objects. Aggregates are conceptionally bound to Domain Events, which are used to communicate changes to the outside world. Together, both concepts form the core of an event-driven architecture.

Sample Code Repositories

(to be done)