Screaming Architecture: A Guide To Feature-Driven Folder Structures

2025-02-12

When designing software, the architecture should clearly reflect the problem it solves. This concept, known as “Screaming Architecture,” emphasizes that your folder structure and code files should immediately convey the purpose of the application. For instance, a health care system should scream “Health Care System,” not just “ASPNET Core.”

Technical Folder Structure (Bad):

❌ Technical
📂 Controllers
📂 Entities
📂 Exceptions
📂 Services

Feature-Driven Folder Structure (Good):

✅ Use case driven
📂 Apartments
📂 Bookings
📂 Payments
📂 Disputes

This approach not only makes the codebase easier to navigate but also increases the cohesion of your components. Below are some practical commands and code snippets to implement a feature-driven folder structure in a Linux environment using common development tools.

Practical Commands and Code Snippets

1. Creating a Feature-Driven Folder Structure in Linux:

mkdir -p src/{Apartments,Bookings,Payments,Disputes}

2. Navigating Through the Folder Structure:

cd src/Apartments

3. Initializing a New .NET Project:

dotnet new webapi -n ApartmentSystem

4. Adding a New Feature Folder:

mkdir -p src/Apartments/Features/Booking

Creating a New Controller in the Booking Feature:

touch src/Apartments/Features/Booking/BookingController.cs

Adding a New Service in the Payments Feature:

touch src/Payments/Services/PaymentService.cs

7. Running the Application:

dotnet run --project src/ApartmentSystem

8. Checking the Folder Structure:

tree src

What Undercode Say

Screaming Architecture is a powerful concept that can significantly improve the maintainability and readability of your codebase. By organizing your files and folders around features rather than technical concerns, you make it easier for developers to understand and navigate the code. This approach is particularly useful in large projects where the complexity can quickly become overwhelming.

In a Linux environment, you can leverage commands like mkdir, cd, and `dotnet` to create and manage a feature-driven folder structure. For instance, using `mkdir -p src/{Apartments,Bookings,Payments,Disputes}` allows you to quickly set up a directory structure that reflects the features of your application. Similarly, `dotnet new webapi -n ApartmentSystem` initializes a new .NET project, while `dotnet run –project src/ApartmentSystem` runs the application.

To further enhance your development workflow, consider using version control systems like Git to manage changes in your feature-driven structure. Commands like git init, git add ., and `git commit -m “Initial commit”` can help you keep track of modifications and collaborate more effectively with your team.

For more advanced scenarios, you might want to explore containerization with Docker. Commands like `docker build -t apartment-system .` and `docker run -p 8080:80 apartment-system` can help you deploy your application in a consistent environment.

In conclusion, adopting a feature-driven folder structure not only aligns with the principles of Screaming Architecture but also enhances the overall development experience. By using Linux commands and .NET tools, you can efficiently implement this approach and create a codebase that is both maintainable and scalable.

For further reading, you can visit the following URLs:
– Screaming Architecture
– .NET Documentation
– Linux Command Line Basics
– Docker Documentation