JuanCrg90/Clean-Code-Notes

Features

• Clean Coding Standards - Provides professional standards and guidelines for writing readable, maintainable, and consistent source code.
• Implementation Isolation - Guides the use of abstract classes and interfaces to prevent client code from depending on concrete implementation details.
• Abstract Data Types - Implements data abstractions by hiding internal implementation details using abstract interfaces.
• Coding Best Practices - Provides implementation-level guidelines and patterns for writing maintainable and readable software code.
• Interface-Based Decoupling - Explains how to rely on abstract interfaces rather than concrete implementations to reduce coupling between components.
• Code Maintainability Principles - Shares design principles focused on managing abstraction layers to improve overall code maintainability.
• Software Architecture Patterns - Summarizes structural strategies like dependency injection and data transfer objects to separate system construction from runtime.
• Contract and Abstraction Patterns - Provides patterns for using interfaces and abstraction layers to decouple implementation details from consumption logic.
• Object Oriented Design - Provides principles for organizing classes and interfaces to decouple components and isolate implementation details.
• Single Responsibility Principles - Provides detailed notes on applying the single responsibility principle to create focused and maintainable components.
• Software Design Patterns - Provides a reference for implementing architectural patterns like interface abstraction and dependency injection.
• Software Design Principles - Offers summaries of fundamental rules and clean coding practices for improving long-term code maintainability.
• Naming Conventions - Provides curated guidelines for choosing intention-revealing and searchable names for variables, functions, and classes.
• Error Handling - Provides structured guidelines for managing exceptions and avoiding null values to keep business logic clean.
• Test-Driven Development Resources - Serves as an implementation guide for test-driven development, emphasizing the write-failing-test-first methodology.
• Code Refactoring Tools - Guidelines for restructuring and organizing existing code through better naming and formatting to reduce technical debt.
• Data Transfer Objects - Implements data transfer objects to move raw information between system boundaries without adding logic.
• Coding Standards - Offers standards for code formatting and consistent spacing to improve visual hierarchy and readability.
• Explicit Dependency-Injection Wiring - Details the use of explicit dependency-injection wiring to separate system construction from runtime execution logic.
• Boundary-Based Wrappers - Provides guidelines on wrapping external libraries in custom interfaces to isolate the core application from breaking changes.
• Library Isolation Wrappers - Provides strategies for wrapping external libraries in custom interfaces to isolate the application from breaking changes.
• Object and Data Structure Distinction - Explains the balance between using data-hiding objects and data-exposing structures to optimize for adding new functionality.
• Law of Demeter - Describes the Law of Demeter to restrict module interactions and minimize coupling.
• Learning Tests - Explains how to write learning tests against external packages to identify breaking changes in new releases.
• Learning Tests - Guides the creation of learning tests against third-party packages to document behavior and detect breaking changes.
• Maintainable Test Design - Guidelines for designing fast and independent unit tests to ensure reliable and repeatable results.
• Clean Code and Principles - Comprehensive notes on applying clean code principles.

Star history