Clean Code Cookbook

Kup polskie wydanie:

Spis treści książki

• Foreword
• Preface
  • Who This Book Is For
  • How This Book Is Organized
  • What You Need to Use This Book
  • Access This Book in Digital Format
  • Conventions Used in This Book
  • Using Code Examples
  • OReilly Online Learning
  • How to Contact Us
  • Acknowledgments
• 1. Clean Code
  • 1.1. What Is a Code Smell?
  • 1.2. What Is Refactoring?
  • 1.3. What Is a Recipe?
  • 1.4. Why Clean Code?
  • 1.5. Readability, Performance, or Both
  • 1.6. Software Types
  • 1.7. Machine-Generated Code
  • 1.8. Naming Considerations Throughout the Book
  • 1.9. Design Patterns
  • 1.10. Programming Language Paradigms
  • 1.11. Objects Versus Classes
  • 1.12. Changeability
• 2. Setting Up the Axioms
  • 2.0. Introduction
  • 2.1. Why Is It a Model?
  • 2.2. Why Is It Abstract?
  • 2.3. Why Is It Programmable?
  • 2.4. Why Is It Partial?
  • 2.5. Why Is It Explanatory?
  • 2.6. Why Is It About Reality?
  • 2.7. Inferring the Rules
  • 2.8. The One and Only Software Design Principle
• 3. Anemic Models
  • 3.0. Introduction
  • 3.1. Converting Anemic Objects to Rich Objects
  • 3.2. Identifying the Essence of Your Objects
  • 3.3. Removing Setters from Objects
  • 3.4. Removing Anemic Code Generators
  • 3.5. Removing Automatic Properties
  • 3.6. Removing DTOs
  • 3.7. Completing Empty Constructors
  • 3.8. Removing Getters
  • 3.9. Preventing Object Orgy
  • 3.10. Removing Dynamic Properties
• 4. Primitive Obsession
  • 4.0. Introduction
  • 4.1. Creating Small Objects
  • 4.2. Reifying Primitive Data
  • 4.3. Reifying Associative Arrays
  • 4.4. Removing String Abuses
  • 4.5. Reifying Timestamps
  • 4.6. Reifying Subsets as Objects
  • 4.7. Reifying String Validations
  • 4.8. Removing Unnecessary Properties
  • 4.9. Creating Date Intervals
• 5. Mutability
  • 5.0. Introduction
  • 5.1. Changing var to const
  • 5.2. Declaring Variables to Be Variable
  • 5.3. Forbidding Changes in the Essence
  • 5.4. Avoiding Mutable const Arrays
  • 5.5. Removing Lazy Initialization
  • 5.6. Freezing Mutable Constants
  • 5.7. Removing Side Effects
  • 5.8. Preventing Hoisting
• 6. Declarative Code
  • 6.0. Introduction
  • 6.1. Narrowing Reused Variables
  • 6.2. Removing Empty Lines
  • 6.3. Removing Versioned Methods
  • 6.4. Removing Double Negatives
  • 6.5. Changing Misplaced Responsibilities
  • 6.6. Replacing Explicit Iterations
  • 6.7. Documenting Design Decisions
  • 6.8. Replacing Magic Numbers with Constants
  • 6.9. Separating What and How
  • 6.10. Documenting Regular Expressions
  • 6.11. Rewriting Yoda Conditions
  • 6.12. Removing Comedian Methods
  • 6.13. Avoiding Callback Hell
  • 6.14. Generating Good Error Messages
  • 6.15. Avoiding Magic Corrections
• 7. Naming
  • 7.0. Introduction
  • 7.1. Expanding Abbreviations
  • 7.2. Renaming and Breaking Helpers and Utils
  • 7.3. Renaming MyObjects
  • 7.4. Renaming Result Variables
  • 7.5. Renaming Variables Named After Types
  • 7.6. Renaming Long Names
  • 7.7. Renaming Abstract Names
  • 7.8. Correcting Spelling Mistakes
  • 7.9. Removing Class Names from Attributes
  • 7.10. Removing the First Letter from Classes and Interfaces
  • 7.11. Renaming Basic / Do Functions
  • 7.12. Converting Plural Classes to Singular
  • 7.13. Removing Collection from Names
  • 7.14. Removing Impl Prefix/Suffix from Class Names
  • 7.15. Renaming Arguments According to Role
  • 7.16. Removing Redundant Parameter Names
  • 7.17. Removing Gratuitous Context from Names
  • 7.18. Avoiding Data Naming
• 8. Comments
  • 8.0. Introduction
  • 8.1. Removing Commented Code
  • 8.2. Removing Obsolete Comments
  • 8.3. Removing Logical Comments
  • 8.4. Removing Getter Comments
  • 8.5. Converting Comments to Function Names
  • 8.6. Removing Comments Inside Methods
  • 8.7. Replacing Comments with Tests
• 9. Standards
  • 9.0. Introduction
  • 9.1. Following Code Standards
  • 9.2. Standardizing Indentations
  • 9.3. Unifying Case Conventions
  • 9.4. Writing Code in English
  • 9.5. Unifying Parameter Order
  • 9.6. Fixing Broken Windows
• 10. Complexity
  • 10.0. Introduction
  • 10.1. Removing Repeated Code
  • 10.2. Removing Settings/Configs and Feature Toggles
  • 10.3. Changing State as Properties
  • 10.4. Removing Cleverness from Code
  • 10.5. Breaking Multiple Promises
  • 10.6. Breaking Long Chains of Collaborations
  • 10.7. Extracting a Method to an Object
  • 10.8. Looking After Array Constructors
  • 10.9. Removing Poltergeist Objects
• 11. Bloaters
  • 11.0. Introduction
  • 11.1. Breaking Too Long Methods
  • 11.2. Reducing Excess Arguments
  • 11.3. Reducing Excess Variables
  • 11.4. Removing Excessive Parentheses
  • 11.5. Removing Excess Methods
  • 11.6. Breaking Too Many Attributes
  • 11.7. Reducing Import Lists 
  • 11.8. Breaking And Functions
  • 11.9. Breaking Fat Interfaces
• 12. YAGNI
  • 12.0. Introduction
  • 12.1. Removing Dead Code
  • 12.2. Using Code Instead of Diagrams
  • 12.3. Refactoring Classes with One Subclass
  • 12.4. Removing One-Use Interfaces
  • 12.5. Removing Design Pattern Abuses
  • 12.6. Replacing Business Collections
• 13. Fail Fast
  • 13.0. Introduction
  • 13.1. Refactoring Reassignment of Variables
  • 13.2. Enforcing Preconditions
  • 13.3. Using Stricter Parameters
  • 13.4. Removing Default from Switches
  • 13.5. Avoiding Modifying Collections While Traversing
  • 13.6. Redefining Hash and Equality
  • 13.7. Refactoring Without Functional Changes
• 14. Ifs
  • 14.0. Introduction
  • 14.1. Replacing Accidental Ifs with Polymorphism
  • 14.2. Renaming Flag Variables for Events
  • 14.3. Reifying Boolean Variables
  • 14.4. Replacing Switch/Case/Elseif Statements
  • 14.5. Replacing Hardcoded If Conditions with Collections
  • 14.6. Changing Boolean to Short-Circuit Conditions
  • 14.7. Adding Implicit Else
  • 14.8. Rewriting Conditional Arrow Code
  • 14.9. Avoiding Short-Circuit Hacks
  • 14.10. Rewriting Nested Arrow Code
  • 14.11. Preventing Return Boolean Values for Condition Checks
  • 14.12. Changing Comparison Against Booleans
  • 14.13. Extracting from Long Ternaries
  • 14.14. Converting Nonpolymorphic Functions to Polymorphic
  • 14.15. Changing Equal Comparison
  • 14.16. Reifying Hardcoded Business Conditions
  • 14.17. Removing Gratuitous Booleans
  • 14.18. Rewriting Nested Ternaries
• 15. Null
  • 15.0. Introduction
  • 15.1. Creating Null Objects
  • 15.2. Removing Optional Chaining
  • 15.3. Converting Optional Attributes to a Collection
  • 15.4. Using Real Objects for Null
  • 15.5. Representing Unknown Locations Without Using Null
• 16. Premature Optimization
  • 16.0. Introduction
  • 16.1. Avoiding IDs on Objects
  • 16.2. Removing Premature Optimization
  • 16.3. Removing Bitwise Premature Optimizations
  • 16.4. Reducing Overgeneralization
  • 16.5. Changing Structural Optimizations
  • 16.6. Removing Anchor Boats
  • 16.7. Extracting Caches from Domain Objects
  • 16.8. Removing Callback Events Based on Implementation
  • 16.9. Removing Queries from Constructors
  • 16.10. Removing Code from Destructors
• 17. Coupling
  • 17.0. Introduction
  • 17.1. Making Hidden Assumptions Explicit
  • 17.2. Replacing Singletons
  • 17.3. Breaking God Objects
  • 17.4. Breaking Divergent Change
  • 17.5. Converting 9999 Special Flag Values to Normal
  • 17.6. Removing Shotgun Surgery
  • 17.7. Removing Optional Arguments
  • 17.8. Preventing Feature Envy
  • 17.9. Removing the Middleman
  • 17.10. Moving Default Arguments to the End
  • 17.11. Avoiding the Ripple Effect
  • 17.12. Removing Accidental Methods on Business Objects
  • 17.13. Removing Business Code from the User Interface
  • 17.14. Changing Coupling to Classes
  • 17.15. Refactoring Data Clumps
  • 17.16. Breaking Inappropriate Intimacy
  • 17.17. Converting Fungible Objects
• 18. Globals
  • 18.0. Introduction
  • 18.1. Reifying Global Functions
  • 18.2. Reifying Static Functions
  • 18.3. Replacing GoTo with Structured Code
  • 18.4. Removing Global Classes
  • 18.5. Changing Global Date Creation
• 19. Hierarchies
  • 19.0. Introduction
  • 19.1. Breaking Deep Inheritance
  • 19.2. Breaking Yo-Yo Hierarchies
  • 19.3. Breaking Subclassification for Code Reuse
  • 19.4. Replacing is-a Relationship with Behavior
  • 19.5. Removing Nested Classes
  • 19.6. Renaming Isolated Classes
  • 19.7. Making Concrete Classes Final
  • 19.8. Defining Class Inheritance Explicitly
  • 19.9. Migrating Empty Classes
  • 19.10. Delaying Premature Classification
  • 19.11. Removing Protected Attributes
  • 19.12. Completing Empty Implementations
• 20. Testing
  • 20.0. Introduction
  • 20.1. Testing Private Methods
  • 20.2. Adding Descriptions to Assertions
  • 20.3. Migrating assertTrue to Specific Assertions
  • 20.4. Replacing Mocks with Real Objects
  • 20.5. Refining Generic Assertions
  • 20.6. Removing Flaky Tests
  • 20.7. Changing Float Number Assertions
  • 20.8. Changing Test Data to Realistic Data
  • 20.9. Protecting Tests Violating Encapsulation
  • 20.10. Removing Irrelevant Test Information
  • 20.11. Adding Coverage for Every Merge Request
  • 20.12. Rewriting Tests Depending on Dates
  • 20.13. Learning a New Programming Language
• 21. Technical Debt
  • 21.0. Introduction
  • 21.1. Removing Production-Dependent Code
  • 21.2. Removing Defect Trackers
  • 21.3. Removing Warning/Strict Off
  • 21.4. Preventing and Removing ToDos and FixMes
• 22. Exceptions
  • 22.0. Introduction
  • 22.1. Removing Empty Exception Blocks
  • 22.2. Removing Unnecessary Exceptions
  • 22.3. Rewriting Exceptions for Expected Cases
  • 22.4. Rewriting Nested Try/Catches
  • 22.5. Replacing Return Codes with Exceptions
  • 22.6. Rewriting Exception Arrow Code
  • 22.7. Hiding Low-Level Errors from End Users
  • 22.8. Narrowing Exception Tries
• 23. Metaprogramming
  • 23.0. Introduction
  • 23.1. Removing Metaprogramming Usage
  • 23.2. Reifying Anonymous Functions
  • 23.3. Removing Preprocessors
  • 23.4. Removing Dynamic Methods
• 24. Types
  • 24.0. Introduction
  • 24.1. Removing Type Checking
  • 24.2. Dealing with Truthy Values
  • 24.3. Changing Float Numbers to Decimals
• 25. Security
  • 25.0. Introduction
  • 25.1. Sanitizing Inputs
  • 25.2. Changing Sequential IDs
  • 25.3. Removing Package Dependencies
  • 25.4. Replacing Evil Regular Expressions
  • 25.5. Protecting Object Deserialization
• Glossary of Terms
• Index

pokaż cały spis treści

ukryj recenzje