JuanCrg90/Clean-Code-Notes
Clean Code Notes
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 guide for test driven development, focusing on the creation of fast, independent, and repeatable unit tests. Additionally, it covers standards for naming conventions, error handling, and code formatting to improve long-term readability.
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.
