For more detailed essays, you can explore the collection directly from the 97 Things Every Programmer Should Know collection. This collection provides valuable lessons and practical tips that can benefit both novices and experienced professionals in their respective fields.

Code Quality and Maintenance

  • Code Readability and Documentation

    • Code Design
      • Code Is Design
      • Encapsulate Behavior, not Just State
    • Code Layout
      • Code Layout Matters
      • Comment Only What the Code Cannot Say
    • Writing Maintainable Code
      • Write Code as If You Had to Support It for the Rest of Your Life
      • Write Small Functions Using Examples

  • Code Review and Refactoring

    • Code Reviews
      • Code Reviews
    • Refactoring Practices
      • Improve Code by Removing It
      • The Boy Scout Rule
      • Own (and Refactor) the Build
    • Automation in Refactoring
      • Automate Your Coding Standard

Testing and Debugging

  • Automated Testing Practices

    • Behavioral Testing
      • Test for Required Behavior, not Incidental Behavior
    • Precision in Testing
      • Test Precisely and Concretely
    • Continuous Testing
      • Test While You Sleep (and over Weekends)
      • Write Tests for People

  • Debugging Techniques and Error Handling

    • Logging and Error Handling
      • Verbose Logging Will Disturb Your Sleep
      • Don’t Ignore that Error!
      • Prevent Errors
    • Debugging Tools and Techniques
      • How to Use a Bug Tracker
      • News of the Weird: Testers Are Your Friends

Design Principles

  • Modularity and Reusability

    • Single Responsibility and Modularity
      • The Single Responsibility Principle
      • Don’t Repeat Yourself
    • Encapsulation and Types
      • Encapsulate Behavior, not Just State
      • Prefer Domain-Specific Types to Primitive Types
      • Missing Opportunities for Polymorphism

  • API and Interface Design

    • API Design
      • The Golden Rule of API Design
    • Interface Usability
      • Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly

Development Practices

  • Agile and Iterative Development

    • Early and Frequent Releases
      • Deploy Early and Often
    • Practice and Feedback
      • Do Lots of Deliberate Practice
      • Step Back and Automate, Automate, Automate
    • Version Control
      • Put Everything Under Version Control
    • Prudence in Development
      • Act with Prudence
    • Risk-Taking
      • Don’t Be Afraid to Break Things
    • Commit Practices
      • Know Your Next Commit

  • Tooling and Environment

    • Command-line Tools
      • Know How to Use Command-line Tools
    • Integrated Development Environment (IDE)
      • Know Your IDE
    • Analysis Tools
      • Take Advantage of Code Analysis Tools
    • Unix Tools
      • The Unix Tools Are Your Friends

Performance and Optimization

  • Optimization Techniques

    • Reduction in Complexity
      • Simplicity Comes from Reduction
    • Algorithm and Data Structure Selection
      • Use the Right Algorithm and Data Structure
    • Performance Issues
      • The Road to Performance Is Littered with Dirty Code Bombs

  • Concurrency and Scalability

    • Message Passing
      • Message Passing Leads to Better Scalability in Parallel Systems
    • Inter-Process Communication
      • Inter-Process Communication Affects Application Response Time

Professional Development

  • Learning and Growth

    • Continuous Improvement
      • Continuous Learning
      • Reinvent the Wheel Often
    • Openness to Opportunities
      • Start from Yes
    • Language Skills
      • Learn Foreign Languages
      • Know Well More than Two Programming Languages

  • Estimation and Planning

    • Project Estimation
      • Learn to Estimate
    • Prudent Actions
      • Act with Prudence
    • Broad Learning
      • Read the Humanities

Collaboration and Communication

  • Teamwork and Pair Programming

    • Pair Programming
      • Pair Program and Feel the Flow
    • Collaborative Problem-Solving
      • Two Heads Are Often Better than One
      • When Programmers and Testers Collaborate

  • Customer Interaction and Requirements

    • Customer Communication
      • Your Customers Do not Mean What They Say
    • Project Advocacy
      • Let Your Project Speak for Itself
    • Code Reading
      • Read Code

Defensive Programming

  • Error Handling and Prevention

    • Preventive Measures
      • Prevent Errors
    • Error Handling Practices
      • Don’t Rely on “Magic Happens Here”
      • Don’t Be Cute with Your Test Data
    • Interim Solutions
      • The Longevity of Interim Solutions

  • Safe Code Modifications

    • Code Changes
      • Don’t Touch that Code!
    • Build Management
      • Own (and Refactor) the Build

Culture and Philosophy

  • Programming Philosophy

    • Role and Mythology
      • The Guru Myth
      • Hard Work Does not Pay Off
    • Cultural Understanding
      • Don’t Just Learn the Language, Understand its Culture
    • Community Coding
      • Ubuntu Coding for Your Friends

  • Behavior and Attitude

    • Self-awareness
      • Know Your Limits
    • Work-Life Balance
      • Put the Mouse Down and Step Away from the Keyboard
    • Ethical Coding
      • You Gotta Care about the Code

Technical Concepts

  • Fundamental Concepts
    • Numerical Accuracy
      • Floating-point Numbers Aren’t Real
    • Data Management
      • Large Interconnected Data Belongs to a Database
    • Build and Linking
      • The Linker Is not a Magical Program
    • Deployment
      • One Binary

Specific Practices and Tools

  • Version Control and Build Management
    • Version Control
      • Put Everything Under Version Control
    • Build Practices
      • Own (and Refactor) the Build
      • Keep the Build Clean
      • Know Your Next Commit