Core Domain vs Core Layer

The concept of Core Modules/Layers is central to many software architectures, but it’s often conflated with Domain-Driven Design’s “Core Domain.” Let’s clarify its definition, historical roots, and where to dive deeper.

---

What Are Core Modules/Layers?

Core Modules/Layers refer to the part of a software system that contains the essential business logic, decoupled from technical implementation details like databases, UIs, or external services. They serve as the “heart” of the application, focusing on how the system works rather than how it interacts with the outside world.

Key Characteristics:

1. Business Logic: Rules, workflows, and domain models (e.g., Order, User).
2. Decoupled Design: Independent of infrastructure (e.g., databases, APIs) or presentation layers (e.g., UI).
3. Reusable: Designed to remain stable even if external technologies change.

Example:

// Core Module (Domain Layer)  
public class PaymentService {  
    public PaymentResult processPayment(PaymentRequest request) {  
        validate(request);  
        applyBusinessRules(request); // Core logic  
        return result;  
    }  
}  
 
// Infrastructure Layer (External Payment Gateway)  
public class StripePaymentGateway implements PaymentGateway {  
    public void charge(CreditCard card, BigDecimal amount) { ... }  
}  

---

Origins and Evolution

The idea of separating core business logic from infrastructure has roots in several architectural patterns:

1. Layered Architecture (1990s)

• First Defined: Popularized in the 1990s as part of the Three-Tier Architecture:
  • Presentation Layer: UI.
  • Business Layer: Core logic (the “core module”).
  • Data Layer: Database interactions.
• Key Source: The concept was formalized in software engineering literature, such as Pattern-Oriented Software Architecture (Buschmann et al., 1996).

2. Hexagonal Architecture (Ports and Adapters)

• Pioneered By: Alistair Cockburn (2005).
• Core Concept: The application’s core logic sits at the center, with “ports” (interfaces) and “adapters” (implementations) for external systems.
• Core Modules: The inner hexagon contains domain entities and use cases.

3. Onion Architecture

• Popularized By: Jeffrey Palermo (2008).
• Core Concept: Layers radiate outward from the domain core, with dependencies flowing inward.
• Core Modules: The innermost layer holds domain models and business rules.

4. Clean Architecture

• Defined By: Robert C. Martin (2012).
• Core Concept: The “Entities” and “Use Cases” layers form the core, shielded from frameworks and databases.

---

Core Modules/Layers vs. Core Domain (DDD)

While related, these concepts address different concerns:

Aspect	Core Modules/Layers	Core Domain (DDD)
Focus	Technical structure and separation of concerns	Business uniqueness and strategic value
Scope	Entire domain logic (generic + unique)	Only the unique, business-critical logic
Primary Goal	Maintainability, testability	Competitive advantage
Example	OrderService with validation rules	Proprietary algorithm for dynamic pricing

---

Further Exploration

To deepen your understanding of Core Modules/Layers and their role in architecture:

1. Foundational Readings

• Books:

  • Pattern-Oriented Software Architecture (Buschmann et al., 1996) – Introduces layered architecture.
  • Domain-Driven Design (Eric Evans, 2003) – Explores the domain layer (though focused on DDD).
  • Clean Architecture (Robert C. Martin, 2017) – Details decoupling core logic from infrastructure.

• Articles:

  • Hexagonal Architecture – Alistair Cockburn’s original post.
  • Onion Architecture – Jeffrey Palermo’s blog series.
  • The Clean Architecture – Robert C. Martin’s breakdown.

2. Case Studies and Frameworks

• Spring Framework: Uses a layered approach with @Service (core) and @Repository (infrastructure).
• DDD Sample Projects: Explore GitHub repos like the IDDD Samples to see core modules in practice.
• Microservices: Read Building Microservices (Sam Newman, 2015) to see how core logic is isolated in services.

3. Practical Guides

• Martin Fowler’s Blog:
  • Layered Architecture
  • Ports and Adapters
• Microsoft’s Architecture Guides:
  • Architecture styles

---

Why This Matters

Understanding Core Modules/Layers helps you:

1. Build Maintainable Systems: Isolate volatile infrastructure code from stable business logic.
2. Accelerate Development: Reuse core modules across projects (e.g., a shared PaymentService).
3. Simplify Testing: Test business rules without databases or APIs.

---

Final Thought

The concept of Core Modules/Layers is timeless—whether you’re building monoliths or microservices, the principle of isolating business logic remains critical. By studying its origins and applying modern patterns like Hexagonal or Clean Architecture, you’ll create systems that are both robust and adaptable.