Clean Architecture and SOLID Principles

This project is an ASP.NET Core solution template and boilerplate that implements a clean architecture pattern for building enterprise applications and web API backends. It provides a standardized project scaffold designed to separate business logic from infrastructure and user interfaces to ensure high testability and low coupling. The project features a database agnostic structure that allows for switching persistence providers without altering core business logic. It includes a command line tool for enterprise application bootstrapping, enabling the automated generation of project structures with selectable frontend frameworks and database providers. The architecture is organized into decoupled layers using dependency inversion and a domain-centric design. This structural approach separates concerns through the use of repository patterns for data access and a service layer to coordinate data flow between domain models and external presentation interfaces.

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 for stateless token authentication to secure API endpoints and a fluent validation pipeline to enforce data integrity. It further supports the unit of work pattern for atomic transactions and automated architecture testing to verify structural boundaries and dependency rules.

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 is handled through asynchronous domain events, while a centralized bus pattern decouples request handling from core business logic. The codebase incorporates practices for maintaining long-term technical strategies, including the use of architectural decision records to document significant design choices. By utilizing persistence-ignorant modeling and internal access modifiers, the framework ensures that domain entities remain testable and protected from cross-module dependency leakage.

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 system can be built, tested, and maintained independently. The template incorporates principles such as dependency inversion, interface segregation, and inversion of control to manage object lifecycles and decouple components. This structure promotes a persistence-ignorant domain, allowing business logic to operate on plain objects without direct awareness of database schemas or data access technologies.

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 pattern to separate state-changing operations from data-retrieval queries, simplifying complex business logic and enabling independent scaling of models. By leveraging aggregate-based state management and event-driven communication, the system maintains data consistency across modules without creating direct dependencies. The platform includes a comprehensive suite of tools for managing the full application lifecycle, including repository-based persistence, atomic transaction management, and automated project scaffolding. It supports robust development practices through integrated testing suites, including support for human-readable feature files, and enforces strict type safety and modular code organization to ensure consistency across large-scale codebases. The repository provides a standardized foundation for building enterprise-grade systems, complete with built-in utilities for request validation, error handling, and infrastructure abstraction.

ABP is an opinionated architectural framework for building enterprise software solutions using .NET and ASP.NET Core. It serves as a structural toolkit for implementing domain-driven design and microservices patterns, providing a modular enterprise architecture where functionality is organized into independent, pluggable modules. The platform is specifically designed to support multi-tenant SaaS architectures, isolating data and configurations for multiple independent customers within a single application instance. It provides enterprise boilerplate infrastructure and pre-configured templates to accelerate the bootstrapping of large-scale solutions. The framework covers a broad set of capabilities including identity and access management, background job execution, and the automation of cross-cutting concerns such as localization, auditing, and global exception handling. It also includes tools for generating REST APIs and web pages, as well as a command line interface for automating project operations.

This project is a collection of software engineering principles and architectural design patterns designed to minimize the mental effort required to understand and maintain source code. It serves as a guide for implementing clean code methodologies and architectural simplification to reduce the overall cognitive load on developers. The framework emphasizes aligning module boundaries and ubiquitous language with business stakeholders to prevent architectural ripple effects. It advocates for balancing service granularity to avoid the overhead of distributed monoliths and suggests favoring object composition over deep class hierarchies to keep behavior transparent. The project covers a broad range of capabilities, including code readability optimization through the flattening of nested logic and the simplification of complex conditionals. It also provides guidance on software architecture design, focusing on the reduction of architectural indirection and the removal of superfluous abstraction layers. Additionally, it addresses API error design by promoting the use of self-describing strings over numeric status codes.

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 of capabilities, including project organization through standardized source file layouts and path aliases, function design based on single responsibility, and the management of immutable state. It also defines patterns for asynchronous logic management and the creation of independent, repeatable unit tests.

This project is a comprehensive guide and set of engineering standards for writing readable, maintainable, and scalable JavaScript code. It provides a framework for software architecture, refactoring patterns, and clean coding practices designed to improve codebase health and longevity. The guide emphasizes the application of SOLID principles and architectural strategies such as dependency inversion and the separation of concerns. It focuses on transforming complex conditional logic through polymorphism and refactoring, while promoting a transition from imperative loops to declarative functional programming patterns. The project covers a wide range of capabilities including object design through composition and encapsulation, asynchronous flow management using promises, and immutable state management. It also establishes standards for naming conventions, function design, and error handling, alongside strategies for creating testable code and maintaining consistent formatting.

QFramework is a Unity game architecture framework designed to separate presentation, system, and data logic. It implements a layered software architecture to manage complex game states and provides a game engine utility library to reduce boilerplate code. The framework is centered on the Command Query Responsibility Segregation pattern, which separates data modification commands from data retrieval queries. It utilizes a dependency injection container to manage the lifecycles and resolution of singletons and modular components, alongside an event-driven system for state synchronization to prevent circular dependencies. The project covers a broad range of capabilities, including asset lifecycle management via reference counting, memory optimization through object pooling, and UI management with automated component binding and panel navigation stacks. It also includes tools for sequential action coordination, audio playback control, and live code reloading.

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 declarations to eliminate bugs associated with dynamic typing. The framework covers broader capability areas including software quality and class design. It provides techniques for simplifying control flow through early returns, managing side effects via dedicated service layers, and enhancing readability by standardizing naming conventions and removing redundant logic.

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 software design capabilities including function optimization, the removal of code duplication, and the implementation of object-oriented patterns. It also addresses code hygiene, error management, and the minimization of side effects through immutable data patterns.

Guice is a Java dependency injection framework and component container. It automates object wiring by mapping interfaces to implementations via a central injector, removing the need for manual factory patterns and constructor calls. The framework provides specialized support for aspect-oriented programming, allowing for the interception and modification of method execution to implement shared cross-cutting concerns. It also functions as a persistence manager to coordinate transaction boundaries and manage the lifecycle of entity managers within a dependency-injected environment. Its core capabilities include a type-safe binding registry, support for named and multi-instance dependencies, and hybrid instantiation strategies that combine automatic injection with manual factory arguments. It further handles external framework coordination to share resources across different environment specifications.

This project is a shared technical specification and standard interface for dependency injection containers in PHP. It defines a common set of interfaces for retrieving services and dependencies, ensuring that different container implementations remain interoperable across the PHP ecosystem. By establishing a standardized API for dependency retrieval, the project allows developers to create libraries that function with any compliant container. This prevents vendor lock-in and enables different container implementations to be swapped without requiring changes to the application code. The specification covers the standardization of container interfaces and the definition of a uniform method for service resolution. This provides a consistent foundation for building custom service containers and developing interoperable packages.

This project is a comprehensive guide to architectural standards and coding patterns for developing maintainable applications within the Laravel framework. It focuses on clean code standards, applying the single responsibility and DRY principles to ensure codebase predictability and consistency. The guide emphasizes decoupling components by moving business logic into service layers and shifting input validation into dedicated request classes to keep controllers lean. It advocates for the use of a service container and dependency injection to reduce class coupling and improve testability. The project covers a broad range of capabilities, including database optimization through eager loading and chunked processing, the use of object-relational mapping for data persistence, and the standardization of naming conventions. It also provides strategies for managing application configuration and localization by externalizing environment variables and text strings.

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-side HTML rendering. The collection covers a wide range of capabilities, including SQL and NoSQL database integration, object storage management, and the generation of OpenAPI specifications. It also includes deployment examples for various cloud environments and serverless platforms, as well as utilities for middleware execution and request validation.

This project provides a set of development guidelines and architectural recommendations for building iOS applications. It focuses on structuring Swift applications to decouple business logic from the user interface to improve testability and maintenance. The project covers specific implementation standards for security, such as using keychain storage for sensitive data and TLS certificate pinning for network traffic. It also defines patterns for code quality enforcement through static analysis and compiler configurations, as well as strategies for asset and localization management. The guidelines extend to operational areas including deployment and DevOps, server-side receipt validation for in-app purchases, and the integration of crash reporting and user analytics. It further details methods for managing project structure, dependency injection, and the creation of adaptive layouts.

Awilix is a JavaScript dependency injection framework and inversion of control container. It provides a centralized system for registering and resolving services, decoupling application components by automating how dependencies are created and passed to the functions or classes that require them. The framework features an automatic module loader that scans the filesystem using glob patterns to register dependencies based on filenames and exports. It supports parameter-name-based injection and proxy-based resolution to manage how dependencies are delivered to constructors and functions. The system manages object lifecycles through singleton and transient patterns, including hierarchical container scoping for request-specific state. It includes capabilities for resource disposal, dependency lifetime validation, and registration verification to ensure resolution correctness.

Fx is a dependency injection framework and application lifecycle manager for Go. It functions as a component model container that automates the instantiation and connection of components by analyzing constructor parameters and return values to resolve complex dependency graphs. The framework distinguishes itself through module-based component bundling, which encapsulates related constructors into reusable units to manage visibility and logic. It provides advanced resolution capabilities, including mapping concrete types to interfaces for decoupling, resolving dependency ambiguities via unique naming, and aggregating multiple instances of the same type into named or typed groups. Beyond dependency resolution, the system orchestrates the startup and shutdown sequences of singletons and background processes. It handles the bootstrapping of interlocking dependencies and provides mechanisms for blocking execution until stop signals trigger cleanup operations. The project includes integration for custom logging to capture and format internal operational events of the dependency system.

This project is a comprehensive educational resource and programming course covering C++ language semantics and features from C++03 through C++26. It provides structured tutorials and technical guides focused on modern C++ development. The material offers specialized instruction on template metaprogramming, including the use of type traits and compile-time computations. It features detailed guides on concurrency and parallelism for multi-core execution, as well as a reference for software design applying SOLID principles and RAII. Additionally, it covers build performance optimization to reduce compilation times and binary sizes. The content spans a broad capability surface, including software hardening, object-oriented programming, and low-level memory management. It provides guidance on using the standard library for containers, filesystem operations, and range algorithms, while also addressing monitoring and observability through profiling and static analysis. The resource is delivered as a structured educational course and technical reference.