Clean Architecture and SOLID Principles

This project is a collection of engineering guidelines and best practices for writing readable and maintainable JavaScript source code. It serves as a clean code guide and refactoring manual to help developers improve the structure of their codebases. The repository provides a reference for applying SOLID principles to reduce coupling and enable extensions without modifying existing logic. It includes a naming convention standard for using explicit, searchable identifiers and a guide for asynchronous patterns to replace nested callbacks with clearer execution flows. The guidelines cover soft

This is a Go backend template that structures a web service into domain, usecase, controller, and repository layers with strict dependency inversion. It provides a foundation for building maintainable and testable REST APIs by separating business logic from transport and data access concerns. The project implements JWT-based authentication, issuing access and refresh tokens for user signup, login, and protected endpoint access. It uses the Gin HTTP framework to build a Docker-packaged REST API with public and private route groups, request validation, and middleware-based authentication. Depen

This project is a boilerplate and template for Go applications implementing Clean Architecture. It provides a standardized project structure designed to organize code into decoupled layers, ensuring that core business logic remains independent of databases, frameworks, and user interfaces. The implementation focuses on a domain-driven design that utilizes dependency injection and the repository pattern to abstract data storage. It enforces architectural boundaries through internal package encapsulation and layer-based dependency inversion. The project includes a development toolchain that au

This project is a comprehensive library of reference implementations and patterns for building web applications using the Go Fiber framework. It provides curated templates and implementation guides for creating REST APIs, web servers, and structured backend services. The repository serves as a practical resource for applying architectural patterns, including Clean and Hexagonal architectures, as well as port-and-adapter decoupling. It offers detailed examples for integrating common web features such as OAuth2 authentication, JWT verification, WebSockets for real-time communication, and server

EquinoxProject is an ASP.NET 9 web application template and reference implementation for building enterprise software. It provides a structural boilerplate centered on clean architecture, domain-driven design, and the separation of read and write operations through a command query responsibility segregation framework. The project incorporates event sourcing to track the history of business entities as a sequence of events for auditing and state reconstruction. It utilizes a layered approach to decouple business logic from external dependencies and frameworks. The system includes capabilities

This project is a PHP clean code guide and software architecture reference. It provides a set of standards, naming conventions, and design patterns intended to improve the long-term maintainability and readability of PHP codebases. The guide emphasizes a structured approach to refactoring and system design, focusing on the application of SOLID principles to reduce coupling and increase extensibility. It advocates for object-oriented design through the use of composition over inheritance, the use of final classes to prevent unexpected overrides, and the implementation of strict type declaratio

This is a reference implementation of Uncle Bob's clean architecture for Android, structured into distinct domain, data, and presentation layers. The project demonstrates how to organize an Android application around business use cases, keeping domain logic and entities free from framework dependencies. The architecture enforces dependency inversion through layered separation, where inner domain layers define interfaces that outer layers implement. This approach enables repository abstractions for data source switching, presenter-view separation for testable UI logic, and use-case composition

This project provides a standardized architectural framework for building scalable, full-stack enterprise applications. It serves as a foundational boilerplate that enforces clean architecture principles, ensuring that business logic remains isolated from infrastructure concerns and external data persistence details. By organizing code into feature-based modules rather than technical roles, the framework simplifies navigation and maintenance within large, complex codebases. The architecture distinguishes itself through a mediator-based communication model that decouples application layers and

This project is a backend framework built with TypeScript that implements clean architecture and SOLID principles to support scalable server-side development. It provides a structured environment for building applications that require secure user authentication, role-based access control, and interactive data collection workflows. The framework distinguishes itself by enforcing a strict separation of business logic from infrastructure concerns through a layered design and dependency injection. It utilizes a schema-first approach to expose application functionality simultaneously through REST

CleanArchitecture is a project template for ASP.NET Core designed to establish a standardized foundation for enterprise applications. It enforces architectural boundaries by separating core business logic from infrastructure and external dependencies, ensuring that the domain remains independent of technical concerns. The project provides scaffolding that supports both multi-project solutions for complex systems and single-project vertical slices for simpler requirements. By organizing code around business entities and aggregates, it facilitates modular development where distinct parts of a s

Clean-Code-Notes is a clean code study guide and a collection of detailed notes based on professional software development standards. It serves as documentation for coding standards and a reference for writing maintainable source code. The project provides technical summaries for object oriented design and software design patterns. It includes guidelines for organizing classes and interfaces to reduce coupling, isolating implementation details, and implementing architectural patterns such as dependency injection and interface abstraction. The resource also functions as an implementation guid

This project is a set of software engineering standards and architectural patterns for writing maintainable and refactorable TypeScript code. It provides a comprehensive guide for implementing clean code principles, focusing on the application of SOLID design and structural patterns to build decoupled systems. The framework prioritizes composition over inheritance and utilizes dependency inversion to reduce system coupling. It establishes standards for strict static typing and the use of read-only modifiers to ensure type safety and eliminate runtime errors. The guidance covers a broad range

This project is a TypeScript-based architectural framework designed to implement domain-driven design and hexagonal architecture in enterprise applications. It provides a structured boilerplate that isolates core business logic from infrastructure concerns, ensuring that domain entities, use cases, and external technology adapters remain decoupled and maintainable. The framework distinguishes itself by enforcing strict architectural boundaries and dependency inversion, preventing unauthorized access to core logic from external layers. It utilizes a command-query responsibility segregation pat

This project is a reference implementation of Domain-Driven Design, Clean Architecture, and Command Query Responsibility Segregation (CQRS) patterns using the Go programming language. It serves as a sample application to demonstrate how to decouple core domain rules from infrastructure and delivery mechanisms. The system is built as a gRPC microservices architecture, utilizing type-safe communication and service contracts. It implements an event-driven architecture to manage eventual consistency and asynchronous processing, specifically employing the Outbox pattern to ensure reliable messagin

The CppCoreGuidelines is a comprehensive software engineering standard that provides a curated framework of coding conventions and design principles for C++. It serves as an authoritative guide for writing safe, efficient, and maintainable code by establishing high-level architectural patterns and organizational principles for large-scale projects. The guidelines emphasize the use of a strong, static type system to ensure memory safety and enforce consistent resource management patterns. The project distinguishes itself by promoting the zero-overhead abstraction principle, ensuring that high-

This project is a reference implementation for structuring Java applications using clean architecture and domain-driven design principles. It provides a template for organizing code into concentric layers, ensuring that core business rules and domain entities remain entirely independent of external frameworks, databases, and delivery mechanisms. The architecture relies on the dependency inversion principle to decouple business logic from infrastructure. By defining abstract interfaces for data access and external services, the system allows for the replacement of underlying technologies witho

This project provides a structural pattern for organizing React and TypeScript applications by decoupling business logic from user interface components and external infrastructure. It implements a layered architecture that isolates core domain rules, ensuring that the application remains independent of specific frameworks, libraries, or external service implementations. The architecture relies on dependency injection and inversion principles to manage service implementations, allowing for modularity and easier testing. By utilizing a functional core and imperative shell, the system separates

This project serves as a reference implementation for applying clean architecture principles within a C# environment. It demonstrates how to structure enterprise applications by organizing code into concentric, independent layers that isolate core business logic from external infrastructure, frameworks, and database concerns. The codebase illustrates the application of domain-driven design to center software logic around business entities and rules. It utilizes interface-based decoupling and dependency inversion to ensure that high-level policies remain unaware of low-level implementation det

This project provides a structured template for building enterprise-grade applications using domain-driven design principles. It serves as a foundational scaffold for web services, enforcing a strict separation of concerns by isolating core business logic from infrastructure, data access layers, and external frameworks. The architecture is built around a modular design that utilizes request pipelining and dependency inversion to maintain loose coupling. It distinguishes itself through a centralized command and query handling system, which routes requests through a unified interface, and a dom

This project provides a structured boilerplate for building Node.js REST APIs, implementing clean architecture principles to isolate business logic from external frameworks and data sources. It serves as a template for organizing complex backend services by enforcing a strict separation of concerns between domain entities, infrastructure, and interface layers. The architecture distinguishes itself through a modular, plugin-based server design built on the Hapi.js framework. It utilizes a dependency injection container to decouple business logic from concrete implementations, ensuring that ser

Clean React is a frontend development framework and application template designed to provide a structured foundation for building scalable web applications. It serves as a boilerplate that organizes complex user interface logic into decoupled, testable layers using TypeScript. The project distinguishes itself by enforcing a strict clean architecture and interface-driven design, which separates high-level business rules from low-level framework details. It integrates a dependency injection container and reactive state management primitives to ensure that system components remain interchangeabl

This project provides a structured boilerplate for building Go web applications based on clean architecture principles. It serves as a template for organizing codebases to ensure that core business logic remains isolated from external frameworks, database layers, and delivery mechanisms. The implementation prioritizes domain-driven design by centering the application around pure business entities that contain no references to infrastructure concerns. It utilizes layered dependency inversion and interface-based port adaptation to decouple the internal logic from external dependencies, allowing

This project provides a structured template for building enterprise applications using a modular monolith architecture. It demonstrates how to organize complex business logic into independent, domain-specific modules that remain contained within a single deployment unit. The architecture enforces strict boundaries between components to minimize coupling and complexity. It utilizes domain-driven design principles to map software components directly to real-world business concepts, ensuring that logic remains independent of infrastructure concerns. Communication between these isolated modules i