awesome-repositories.com
Blog
awesome-repositories.com

Entdecke die besten Open-Source-Repositories mit KI-gestützter Suche.

EntdeckenKuratierte SuchenOpen-Source-AlternativenSelf-hosted SoftwareBlogSitemap
ProjektÜber unsRanking-MethodikPresseMCP-Server
RechtlichesDatenschutzAGB
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
JuanCrg90 avatar

JuanCrg90/Clean-Code-Notes

0
View on GitHub↗
6,119 Stars·841 Forks·8 Aufrufe

Clean Code Notes

Clean-Code-Notes ist ein Studienleitfaden für Clean Code und eine Sammlung detaillierter Notizen, die auf professionellen Standards der Softwareentwicklung basieren. Es dient als Dokumentation für Codierungsstandards und als Referenz für das Schreiben wartbaren Quellcodes.

Das Projekt bietet technische Zusammenfassungen für objektorientiertes Design und Software-Entwurfsmuster. Es enthält Richtlinien für die Organisation von Klassen und Schnittstellen zur Reduzierung der Kopplung, zur Isolierung von Implementierungsdetails und zur Implementierung architektonischer Muster wie Dependency Injection und Interface-Abstraktion.

Die Ressource fungiert zudem als Implementierungsleitfaden für Test-Driven Development (TDD) und konzentriert sich auf die Erstellung schneller, unabhängiger und wiederholbarer Unit-Tests. Darüber hinaus deckt sie Standards für Namenskonventionen, Fehlerbehandlung und Code-Formatierung ab, um die langfristige Lesbarkeit zu verbessern.

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.

KI-Suche

Entdecke weitere awesome Repositories

Beschreibe in einfachen Worten, was du brauchst — die KI bewertet tausende kuratierte Open-Source-Projekte nach Relevanz.

Start searching with AI
  • 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-Verlauf

    Star-Verlauf für juancrg90/clean-code-notesStar-Verlauf für juancrg90/clean-code-notes

    Open-Source-Alternativen zu Clean Code Notes

    Ähnliche Open-Source-Projekte, sortiert nach der Anzahl der gemeinsamen Funktionen mit Clean Code Notes.
    • alexeymezenin/laravel-best-practicesAvatar von alexeymezenin

      alexeymezenin/laravel-best-practices

      12,299Auf GitHub ansehen↗

      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

      Auf GitHub ansehen↗12,299
    • zakirullin/cognitive-loadAvatar von zakirullin

      zakirullin/cognitive-load

      12,288Auf GitHub ansehen↗

      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 objec

      Auf GitHub ansehen↗12,288
    • labs42io/clean-code-typescriptAvatar von labs42io

      labs42io/clean-code-typescript

      9,764Auf GitHub ansehen↗

      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

      TypeScriptbest-practicesclean-architectureclean-code
      Auf GitHub ansehen↗9,764
    • zedr/clean-code-pythonAvatar von zedr

      zedr/clean-code-python

      4,816Auf GitHub ansehen↗

      This project is a Python clean code guide and refactoring resource. It provides a collection of software craftsmanship principles and examples designed to improve the readability and maintainability of Python source code. The resource focuses on optimizing variable naming to remove mental mapping and breaking functions into single-purpose units. It provides guidelines for reducing code duplication and organizing logic to ensure components remain easy to extend and maintain. The content covers software architecture and design quality, including the implementation of SOLID principles and indus

      Python
      Auf GitHub ansehen↗4,816
    Alle 30 Alternativen zu Clean Code Notes anzeigen→

    Häufig gestellte Fragen

    Was macht juancrg90/clean-code-notes?

    Clean-Code-Notes ist ein Studienleitfaden für Clean Code und eine Sammlung detaillierter Notizen, die auf professionellen Standards der Softwareentwicklung basieren. Es dient als Dokumentation für Codierungsstandards und als Referenz für das Schreiben wartbaren Quellcodes.

    Was sind die Hauptfunktionen von juancrg90/clean-code-notes?

    Die Hauptfunktionen von juancrg90/clean-code-notes sind: Clean Coding Standards, Implementation Isolation, Abstract Data Types, Coding Best Practices, Interface-Based Decoupling, Code Maintainability Principles, Software Architecture Patterns, Contract and Abstraction Patterns.

    Welche Open-Source-Alternativen gibt es zu juancrg90/clean-code-notes?

    Open-Source-Alternativen zu juancrg90/clean-code-notes sind unter anderem: alexeymezenin/laravel-best-practices — This project is a comprehensive guide to architectural standards and coding patterns for developing maintainable… zakirullin/cognitive-load — This project is a collection of software engineering principles and architectural design patterns designed to minimize… labs42io/clean-code-typescript — This project is a set of software engineering standards and architectural patterns for writing maintainable and… zedr/clean-code-python — This project is a Python clean code guide and refactoring resource. It provides a collection of software craftsmanship… ryanmcdermott/clean-code-javascript — This project is a collection of engineering guidelines and best practices for writing readable and maintainable… ryanmcdermott/3rs-of-software-architecture — This project is a comprehensive guide to software architecture, providing a framework for designing maintainable,…