Clean Code Principles and Patterns, 2nd Edition: A Software Practitioner’s Handbook

enter site 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