Clean Code Principles and Patterns: A Software Practitioner’s Handbook

About the Author
Introduction
Architectural Principles
    Software Hierarchy
    Single Responsibility Principle
    Uniform Naming Principle
    Encapsulation Principle
    Service Aggregation Principle
    High Cohesion, Low Coupling Principle
    Library Composition Principle
    Avoid Duplication Principle
    Externalized Service Configuration Principle
        Environment Variables
        Kubernetes ConfigMaps
        Kubernetes Secrets
    Service Substitution Principle
    Inter-Service Communication Methods
        Synchronous Communication Method
        Asynchronous Communication Method
        Shared Data Communication Method
    Domain-Driven Architectural Design Principle
        Design Example 1: Mobile Telecom Network Analytics Software System
        Design Example 2: Banking Software System
    Autopilot Microservices Principle
        Stateless Microservices Principle
        Resilient Microservices Principle
        Horizontally Autoscaling Microservices Principle
        Highly-Available Microservices Principle
        Observable Microservices Principle
    Software Versioning Principles
        Use Semantic Versioning Principle
        Avoid Using 0.x Versions Principle
        Don’t Increase Major Version Principle
        Implement Security Patches and Bug Corrections to All Major Versions Principle
        Avoid Using Non-LTS Versions in Production Principle
    Git Version Control Principle
        Feature Branch
        Feature Toggle
    Architectural Patterns
        Event Sourcing Pattern
        Command Query Responsibility Segregation (CQRS) Pattern
        Distributed Transaction Patterns
            Saga Orchestration Pattern
            Saga Choreography Pattern
    Preferred Technology Stacks Principle
Object-Oriented Design Principles
    SOLID Principles
        Single Responsibility Principle
        Open-Closed Principle
        Liskov’s Substitution Principle
        Interface Segregation and Multiple Inheritance Principle
        Program Against Interfaces Principle (Generalized Dependency Inversion Principle)
    Clean Microservice Design Principle
    Uniform Naming Principle
        Naming Interfaces and Classes
        Naming Functions
            Preposition in Function Name
            Example 1: Renaming JavaScript Array Methods
            Example 2: Renaming C++ Casting Expressions
            Naming Method Pairs
            Naming Boolean Functions (Predicates)
            Naming Builder Methods
            Naming Methods with Implicit Verbs
            Naming Property Getter Functions
            Naming Lifecycle Methods
            Naming Function Parameters
    Encapsulation Principle
        Immutable Objects
        Don’t Leak Modifiable Internal State Outside an Object Principle
        Don’t Assign From a Method Parameter to a Modifiable Field
        Real-life Example of Encapsulation Violation: React Class Component’s State
    Object Composition Principle
    Domain-Driven Design Principle
        Domain-Driven Design Example: Data Exporter Microservice
        Domain-Driven Design Example: Anomaly Detection Microservice
    Design Patterns
        Design Patterns for Creating Objects
            Factory Pattern
            Abstract Factory Pattern
            Factory Method Pattern
            Builder Pattern
            Singleton Pattern
            Prototype Pattern
            Object Pool Pattern
        Structural Design Patterns
            Composite Pattern
            Facade Pattern
            Bridge Pattern
            Strategy Pattern
            Adapter Pattern
            Proxy Pattern
            Decorator Pattern
            Flyweight Pattern
        Behavioral Design Patterns
            Chain of Responsibility Pattern
            Observer Pattern
            Command/Action Pattern
            Iterator Pattern
            State Pattern
            Mediator Pattern
            Template Method Pattern
            Memento Pattern
            Visitor Pattern
            Null Object Pattern
    Don’t Ask, Tell Principle
    Law of Demeter
    Avoid Primitive Type Obsession Principle
    Dependency Injection (DI) Principle
    Avoid Code Duplication Principle
    Inheritance in Cascading Style Sheets (CSS)
Coding Principles
    Uniform Variable Naming Principle
        Naming Integer Variables
        Naming Floating-Point Number Variables
        Naming Boolean Variables
        Naming String Variables
        Naming Enum Variables
        Naming Collection (Array, List, and Set) Variables
        Naming Map Variables
        Naming Pair and Tuple Variables
        Naming Object Variables
        Naming Optional Variables
        Naming Function Variables (Callbacks)
        Naming Class Properties
        General Naming Rules
            Use Short, Common Names
            Pick One Name And Use It Consistently
            Avoid Obscure Abbreviations
            Avoid Too Short Or Meaningless Names
    Uniform Source Code Repository Structure Principle
        Java Source Code Repository Structure
        C++ Source Code Repository Structure
        JavaScript/TypeScript Source Code Repository Structure
    Domain-Based Source Code Structure Principle
    Avoid Comments Principle
        Name Things Properly
        Single Return Of Named Value At The End Of Function
        Return Type Aliasing
        Extract Constant for Boolean Expression
        Extract Named Constant or Enumerated Type
        Extract Function
        Name Anonymous Function
        Avoiding Comments in Bash Shell Scripts
    Function Single Return Principle
    Prefer a Statically Typed Language for Production Code Principle
        Function Arguments Might Be Given in Wrong Order
        Function Argument Might Be Given with Wrong Type
        Not All Function Arguments Are Given
        Function Return Value Type Might Be Misunderstood
        Forced to Write Public API Comments
        Type Errors Are Not Found in Testing
    Refactoring Principle
        Rename
        Extract Method
        Extract Constant
        Replace Conditionals with Polymorphism
        Introduce Parameter Object
        Invert If Statement
    Static Code Analysis Principle
        Common Static Code Analysis Issues
    Error/Exception Handling Principle
        Handling Checked Exceptions in Java
        Returning Errors
            Returning Failure Indicator
            Returning an Optional Value
            Returning an Error Object
            Adapt to Wanted Error Handling Mechanism
            Asynchronous Function Error Handling
            Functional Exception Handling
            Stream Error Handling
    Don’t Pass or Return Null Principle
    Avoid Off-By-One Errors Principle
    Be Critical When Googling Principle
    Optimization Principle
        Optimization Patterns
            Optimize Busy Loops Only Pattern
            Remove Unnecessary Functionality Pattern
            Copy Memory in Chunks Pattern (C++)
            Object Pool Pattern
            Replace Virtual Methods with Non-Virtual Methods Pattern (C++)
            Inline Methods Pattern (C++)
            Use Unique Pointer Pattern (C++)
            Share Identical Objects a.k.a Flyweight Pattern
Testing Principles
    Functional Testing Principles
        Unit Testing Principle
            Test-Driven Development (TDD)
            Naming Conventions
            Mocking
            UI Component Unit Testing
        Software Component Integration Testing Principle
            UI Integration Testing
            Setting Up Integration Testing Environment
        End-to-End (E2E) Testing Principle
    Non-Functional Testing Principle
        Performance Testing
        Data Volume Testing
        Stability Testing
        Reliability Testing
        Stress and Scalability Testing
        Security Testing
        Other Non-Functional Testing
            Visual Testing
Security First Principle
    Threat Modelling
        Decompose Application
        Determine and Rank Threats
        Determine Countermeasures and Mitigation
    Security Features
        Authentication and Authorization
            OpenID Connect Authentication and Authorization in Frontend
            OAuth2 Authorization in Backend
        Password Policy
        Cryptography
        Denial-of-service (DoS) Prevention
        SQL Injection Prevention
        Security Configuration
        Automatic Vulnerability Scanning
        Integrity
        Error Handling
        Audit Logging
        Input Validation
            Validating Numbers
            Validating Strings
            Validating Arrays
            Validating Objects
            Validation Library Example
API Design Principles
    Frontend Facing API Design Principles
        JSON-RPC API Design Principle
        REST API Design Principle
            Creating a Resource
            Reading Resources
            Updating Resources
            Deleting Resources
            Executing Non-CRUD Actions on Resources
            Resource Composition
            HTTP Status Codes
            HATEOAS and HAL
            Versioning
            Documentation
            Implementation Example
        GraphQL API Design
        Subscription-Based API Design
            Server-Sent Events (SSE)
            GraphQL Subscriptions
            WebSocket Example
    Inter-Microservice API Design Principles
        Synchronous API Design Principle
        Asynchronous API Design Principle
            Request-Only Asynchronous API Design
            Request-Response Asynchronous API Design
Databases And Database Principles
    Relational Databases
        Structure of Relational Database
        Use Object Relational Mapper (ORM) Principle
        Entity/Table Relationships
            One-To-One/Many Relationships
            Many-To-Many Relationships
        Use Parameterized SQL Statements Principle
        Normalization Rules
            First Normal Form (1NF)
            Second Normal Form (2NF)
            Third Normal Form (3NF)
    Document Database Principle
    Key-Value Database Principle
    Wide-Column Database Principle
    Search Engine Principle
Concurrent Programming Principles
    Threading Principle
        Parallel Algorithms
    Thread Safety Principle
        Synchronization Directive
        Atomic Variables
        Concurrent Collections
        Mutexes
        Spinlocks
Teamwork Principles
    Use Agile Framework Principle
    Define the Done Principle
    You Write Code for Other People Principle
    Avoid Technical Debt Principle
    Software Component Documentation Principle
    Code Review Principle
        Focus on Object-Oriented Design
        Focus on Proper and Uniform Naming
        Don’t Focus on Premature Optimization
        Detect Possible Malicious Code
    Uniform Code Formatting Principle
    Highly Concurrent Development Principle
        Dedicated Microservices and Microlibraries
        Dedicated Domains
        Follow Open-Closed Principle
    Pair Programming Principle
    Well-Defined Development Team Roles Principle
        Product Owner
        Scrum Master
        Software Developer
        Test Automation Developer
        DevOps Engineer
        UI Designer
DevSecOps
    SecOps Lifecycle
    DevOps Lifecycle
        Plan
        Code
        Build and Test
        Release
            Example Dockerfile
            Example Kubernetes Deployment
            Example CI/CD Pipeline
        Deploy
        Operate
        Monitor
            Logging
            OpenTelemetry Log Data Model
            PrometheusRule Example
Appendix A