zakirullin/cognitive-load

Features

• Cognitive Load Reducers - Provides a comprehensive framework for minimizing the mental effort required to understand and maintain source code.
• Cognitive Load Reduction - Provides a comprehensive framework for reducing the mental effort required to understand and maintain source code.
• System Architectures - Provides a comprehensive framework for simplifying system architecture by replacing heavy layers with dependency inversion.
• Software-Defined Architectures - Defines module boundaries based on the business person or user they serve to minimize side effects.
• Early Return Patterns - Implements early return patterns to flatten nested logic and focus on the successful execution path.
• Abstraction Layers - Minimizes the use of architectural layers to prevent fragmenting stack traces and increasing indirection.
• Indirection Minimization - Minimizes layered abstractions and architectural indirection to reduce the mental effort of tracing execution.
• Architectural Indirection Reducers - Provides strategies to minimize architectural indirection and eliminate superfluous abstraction layers.
• Stakeholder-Aligned Boundaries - Aligns module boundaries with business stakeholders to prevent unexpected architectural ripple effects.
• Clean Coding Standards - Provides a set of clean coding standards for reducing nesting and simplifying complex logic.
• Abstraction Cost Balancers - Provides guidance on balancing the cost of abstraction against the risk of tight coupling.
• Coupling-Reducing Duplication - Prioritizes moderate code duplication over shared abstractions to prevent tight coupling between unrelated components.
• Code Readability Optimizations - Suggests using intermediate variables with descriptive names to simplify complex conditional logic.
• Composition-Based Modeling - Replaces deep class hierarchies with object composition to prevent behavior from being obscured across multiple parent classes.
• Code Maintainability Principles - Establishes maintainability principles focused on reducing the mental effort of code comprehension.
• Distributed Service Architectures - Provides strategies for balancing service granularity to avoid the complexity of distributed monoliths.
• Module-to-Service Extractions - Balances service size by favoring isolated modules over overly granular services to reduce network complexity.
• Isolated Monolithic Modules - Groups related functionality into isolated modules within a monolith to avoid the complexity of distributed services.
• Guard Clauses - Employs early return patterns via guard clauses to handle preconditions and maintain linear execution paths.
• Over-Abstraction Preventers - Prevents tight coupling between unrelated components by permitting moderate code duplication over shared abstractions.
• Dependency Inversion Patterns - Utilizes dependency inversion to flatten architectural layers and reduce the indirection of request tracing.
• Service Granularity Optimization - Prevents the creation of too many shallow services to reduce the cognitive load of managing distributed systems.
• Software Architecture Design - Applies architectural design principles to reduce system complexity and avoid distributed monoliths.
• Domain-Driven Designs - Applies domain-driven design to establish a shared language and module boundaries aligned with the problem space.
• Layered Architectures - Reduces the number of jumps required to trace a request by avoiding excessive architectural layering.
• Layer Reduction - Removes superfluous horizontal abstraction layers in favor of dependency inversion to simplify debugging.
• Decoupled Architectures - Accepts minor code duplication to avoid unnecessary abstractions and tight coupling.
• Composition Over Inheritance - Provides guidance on favoring object composition over deep inheritance hierarchies to reduce cognitive load.
• Logic Decoupling - Wraps framework-specific infrastructure around a core business logic layer to decouple domain rules from the platform.
• Coupling and Dependency Management - Balances the drive for code reuse with the need to avoid tight coupling between unrelated components.
• Coupling Management - Prioritizes decoupling over code reuse to ensure components can be modified without unintended side effects.
• Single Responsibility Principles - Applies single responsibility principles by aligning module boundaries with specific business stakeholders.
• Software Engineering Principles - Collects fundamental software engineering principles designed to minimize the mental effort of maintenance.
• Stakeholder-Based Module Partitioning - Defines module boundaries by assigning responsibility to the specific business actor or user the code serves.
• Stakeholder-Based Responsibility Mapping - Defines module responsibilities based on the specific business actors they serve to minimize ripple effects.
• Ubiquitous Languages - Employs a shared ubiquitous language between developers and stakeholders to align mental models of the problem space.
• Readability-Focused Logic Simplifiers - Simplifies complicated boolean logic by using descriptive intermediate variables to reduce mental load.
• Feature Restrictions - Restricts the use of obscure or redundant language features to maximize code readability.
• Readability Restrictions - Provides guidelines for restricting complex language features to ensure code remains readable and easy to maintain.
• API Error Handling Patterns - Implements API error design by using self-describing strings instead of numeric status codes.
• Branching Depth Reducers - Uses early return patterns to handle edge cases first, reducing the depth of branching logic.
• Indirection Reduction - Provides a system for reducing architectural indirection by minimizing abstraction layers and favoring dependency inversion.
• Conditional Logic Simplifiers - Simplifies multifaceted conditional statements by introducing intermediate variables with descriptive names.
• Early-Return Patterns - Employs early-return patterns to flatten nested logic and focus on the primary execution path.
• Service Consolidation - Promotes grouping related functionality into larger services to avoid the overhead of managing a distributed monolith.
• Self-Describing Error Strings - Promotes using self-describing strings instead of numeric status codes to remove external mapping overhead.
• Granularity Optimization - Guides the balance of service granularity to avoid the cognitive overhead of overly fragmented distributed systems.
• Modular Monolith Strategies - Encourages delaying network layer introduction in favor of isolated modules until independent deployment is strictly required.
• Microservices Design Patterns - Outlines design patterns for balancing microservice granularity to prevent distributed monolith overhead.
• Modular Monoliths - Advocates for modular monoliths to avoid the complexity and network overhead of distributed monoliths.
• Service Architectures - Balances service granularity to ensure changes do not necessitate updates across numerous separate units.
• Deep Module Design - Promotes the design of deep modules that hide internal complexity behind stable interfaces.
• Software Architecture Patterns - Implements software architecture patterns that prioritize simplification and the removal of superfluous layers.
• Maintainability Principles - Improves maintainability by reducing architectural indirection and unnecessary abstraction layers.
• Container Nesting - Uses guard clauses and early returns to eliminate deeply nested if-statements.
• Code Quality - Strategies for reducing mental effort when reading code.

Star history