Code That Fits in Your Head: Heuristics for Software Engineering

Length: 589 pages
Edition: 1
Language: English
Publisher: Addison-Wesley Professional
Publication Date: 2021-09-30
ISBN-10: 0137464401
ISBN-13: 9780137464401
Sales Rank: #128702 (See Top 100 Books)

The latest title in Addison Wesley’s world-renowned Robert C. Martin Series on better software development, Code That Fits in Your Head offers indispensable practical advice for writing code at a sustainable pace, and controlling the complexity that causes too many software projects to spin out of control.

Reflecting decades of experience consulting on software projects and helping development teams succeed, Mark Seemann shares proven practices and heuristics, supported by realistic advice. His guidance ranges from checklists to teamwork, encapsulation to decomposition, API design to unit testing and troubleshooting.

Throughout, Seemann illuminates his insights with up-to-date code examples drawn from a start to finish sample project. Seemann’s examples are written in C#, and designed to be clear and useful to every object-oriented enterprise developer, whether they use C#, Java, or another language. Code That Fits in Your Head is accompanied by the complete code base for this sample application, organized in a Git repository to facilitate further exploration of details that don’t fit in the text.

Cover Page
About This eBook
Half Title
Title Page
Copyright Page
Dedication Page
Contents
Series Editor Foreword
Preface
About the Author
I: Acceleration
    1. Art or Science?
        1.1 Building a House
        1.2 Growing a Garden
        1.3 Towards Engineering
        1.4 Conclusion
    2. Checklists
        2.1 An Aid to Memory
        2.2 Checklist for a New Code Base
        2.3 Adding Checks to Existing Code Bases
        2.4 Conclusion
    3. Tackling Complexity
        3.1 Purpose
        3.2 Why Programming Is Difficult
        3.3 Towards Software Engineering
        3.4 Conclusion
    4. Vertical Slice
        4.1 Start with Working Software
        4.2 Walking Skeleton
        4.3 Outside-in
        4.4 Complete the Slice
        4.5 Conclusion
    5. Encapsulation
        5.1 Save the Data
        5.2 Validation
        5.3 Protection of Invariants
        5.4 Conclusion
    6. Triangulation
        6.1 Short-Term versus Long-Term Memory
        6.2 Capacity
        6.3 Conclusion
    7. Decomposition
        7.1 Code Rot
        7.2 Code That Fits in Your Brain
        7.3 Conclusion
    8. API Design
        8.1 Principles of API Design
        8.2 API Design Example
        8.3 Conclusion
    9. Teamwork
        9.1 Git
        9.2 Collective Code Ownership
        9.3 Conclusion
II: Sustainability 201
    10. Augmenting Code
        10.1 Feature Flags
        10.2 The Strangler Pattern
        10.3 Versioning
        10.4 Conclusion
    11. Editing Unit Tests
        11.1 Refactoring Unit Tests
        11.2 See Tests Fail
        11.3 Conclusion
    12. Troubleshooting
        12.1 Understanding
        12.2 Defects
        12.3 Bisection
        12.4 Conclusion
    13. Separation of Concerns
        13.1 Composition
        13.2 Cross-Cutting Concerns
        13.3 Conclusion
    14. Rhythm
        14.1 Personal Rhythm
        14.2 Team Rhythm
        14.3 Conclusion
    15. The Usual Suspects
        15.1 Performance
        15.2 Security
        15.3 Other Techniques
        15.4 Conclusion
    16. Tour
        16.1 Navigation
        16.2 Architecture
        16.3 Usage
        16.4 Conclusion
A. List of Practices
    A.1 The 50/72 Rule
    A.2 The 80/24 Rule
    A.3 Arrange Act Assert
    A.4 Bisection
    A.5 Checklist for A New Code Base
    A.6 Command Query Separation331
    A.7 Count the Variables
    A.8 Cyclomatic Complexity
    A.9 Decorators for Cross-Cutting Concerns
    A.10 Devil’s Advocate
    A.11 Feature Flag
    A.12 Functional Core, Imperative Shell
    A.13 Hierarchy of Communication
    A.14 Justify Exceptions from the Rule
    A.15 Parse, Don’t Validate
    A.16 Postel’s Law
    A.17 Red Green Refactor
    A.18 Regularly Update Dependencies
    A.19 Reproduce Defects as Tests
    A.20 Review Code
    A.21 Semantic Versioning
    A.22 Separate Refactoring of Test and Production Code
    A.23 Slice
    A.24 Strangler
    A.25 Threat-Model
    A.26 Transformation Priority Premise
    A.27 X-driven Development
    A.28 X Out Names
Bibliography
Index
Code Snippets