Books & Videos

Table of Contents

  1. Chapter 1 Care about the Code

  2. you.write(code);

    1. Chapter 2 Keeping Up Appearances

      1. Presentation Is Powerful
      2. It’s About Communication
      3. Layout
      4. Names
      5. Making Yourself Presentable
      6. Conclusion
    2. Chapter 3 Write Less Code!

      1. Why Should We Care?
      2. Flappy Logic
      3. Duplication
      4. Dead Code
      5. Comments
      6. Verbosity
      7. Bad Design
      8. Whitespace
      9. So What Do We Do?
      10. Conclusion
    3. Chapter 4 Improve Code by Removing It

      1. Code Indulgence
      2. It’s Not Bad, It’s Inevitable
      3. So What?
      4. Waking the Dead
      5. Surgical Extraction
      6. Conclusion
    4. Chapter 5 The Ghost of a Codebase Past

      1. Presentation
      2. The State of the Art
      3. Idioms
      4. Design Decisions
      5. Bugs
      6. Conclusion
    5. Chapter 6 Navigating a Route

      1. A Little Help from My Friends
      2. Look for Clues
      3. Learn by Doing
      4. Conclusion
    6. Chapter 7 Wallowing in Filth

      1. Smell the Signs
      2. Wading into the Cesspit
      3. The Survey Says…
      4. Working in the Sandpit
      5. Cleaning Up Messes
      6. Making Adjustments
      7. Bad Code? Bad Programmers?
    7. Chapter 8 Don’t Ignore That Error!

      1. The Mechanism
      2. The Madness
      3. The Mitigation
      4. Conclusion
    8. Chapter 9 Expect the Unexpected

      1. Errors
      2. Threading
      3. Shutdown
      4. The Moral of the Story
    9. Chapter 10 Bug Hunting

      1. An Economic Concern
      2. An Ounce of Prevention
      3. Bug Hunting
      4. Non-Reproducible Bugs
      5. Conclusion
    10. Chapter 11 Testing Times

      1. Why Test?
      2. Types of Tests
      3. When to Write Tests
      4. When to Run Tests
      5. What to Test
      6. Good Tests
      7. What Does a Test Look Like?
      8. The Structure of Tests
      9. No Code Is an Island
      10. Conclusion
    11. Chapter 12 Coping with Complexity

      1. Blobs
      2. Case Study: Reducing Blob Complexity
      3. Lines
      4. And Finally: People
      5. Conclusion
    12. Chapter 13 A Tale of Two Systems

      1. The Messy Metropolis
      2. Design Town
      3. So What?
  3. Practice Makes Perfect

    1. Chapter 14 Software Development Is…

      1. This Software (Food)stuff
      2. Software Development Is…an Art
      3. Software Development Is…a Science
      4. Software Development Is…a Sport
      5. Software Development Is…Child’s Play
      6. Software Development Is…a Chore
      7. Metaphor Overload
    2. Chapter 15 Playing by the Rules

      1. We Need More Rules!
      2. Set the Rules
    3. Chapter 16 Keep It Simple

      1. Simple Designs
      2. Simple Lines of Code
      3. Keeping It Simple, Not Stupid
      4. Assumptions Can Reduce Simplicity
      5. Avoid Premature Optimisation
      6. Sufficiently Simple
      7. A Simple Conclusion
    4. Chapter 17 Use Your Brain

      1. Don’t Be Stupid
      2. Avoid Mindlessness
      3. You Are Allowed to Think!
    5. Chapter 18 Nothing Is Set in Stone

      1. Fearless Change
      2. Change Your Attitude
      3. Make the Change
      4. Plus ça Change
    6. Chapter 19 A Case for Code Reuse

      1. Reuse Case 1: The Copy-Pasta
      2. Reuse Case 2: Design for Reuse
      3. Reuse Case 3: Promote and Refactor
      4. Reuse Case 4: Buy In, or Reinvent the Wheel
    7. Chapter 20 Effective Version Control

      1. Use It or Lose It
      2. Pick One, Any One
      3. Storing the Right Things
      4. Use Version Control Well
      5. Branches: Seeing the Wood for the Trees
      6. The Home for Your Code
      7. Conclusion
    8. Chapter 21 Getting One Past the Goalpost

      1. Software Development: Shovelling Manure
      2. A False Dichotomy
      3. Fix the Team to Fix the Code
      4. Releasing a Build to QA
      5. On Getting a Fault Report
      6. Our Differences Make Us Stronger
      7. Pieces of the Puzzle
    9. Chapter 22 The Curious Case of the Frozen Code

      1. Hunting the Code Freeze
      2. A New World Order
      3. Forms of Freeze
      4. Branches Make It Work
      5. But It’s Not Really Frozen!
      6. Length of the Freeze
      7. Feel the Freeze
      8. The End Draws Near
      9. Antifreeze
      10. Conclusion
    10. Chapter 23 Please Release Me

      1. Part of the Process
      2. A Cog in the Machine
      3. Release Early and Often
      4. And There’s More…
  4. Getting Personal

    1. Chapter 24 Live to Love to Learn

      1. What to Learn?
      2. Learning to Learn
      3. Learning Models
      4. Teach to Learn
      5. Act to Learn
      6. What Have We Learnt?
    2. Chapter 25 Test-Driven Developers

      1. Driving the Point Home
      2. Success Breeds Complacency
      3. Testing Times
      4. Test-Driven Developers
      5. Conclusion
    3. Chapter 26 Relish the Challenge

      1. It’s the Motivation
      2. What’s the Challenge?
      3. Don’t Do It!
      4. Get Challenged
      5. Conclusion
    4. Chapter 27 Avoid Stagnation

      1. Your Skills Are Your Investment
      2. An Exercise for the Reader
      3. Job Security
    5. Chapter 28 The Ethical Programmer

      1. Attitude to Code
      2. Legal Issues
      3. Attitude to People
      4. The Hippocodic Oath
      5. Conclusion
    6. Chapter 29 A Love for Languages

      1. Love All Languages
      2. Love Your Language
      3. Cultivating Your Language Relationship
      4. A Perfect Metaphor?
      5. Conclusion
    7. Chapter 30 Posturing Programmers

      1. Basic Computer Posture
      2. Eye Strain
      3. Conclusion
  5. Getting Things Done

    1. Chapter 31 Smarter, Not Harder

      1. Pick Your Battles
      2. Battle Tactics
      3. Conclusion
    2. Chapter 32 It’s Done When It’s Done

      1. Are We There Yet?
      2. Developing Backwards: Decomposition
      3. Define “Done”
      4. Just Do It
    3. Chapter 33 This Time I’ve Got It…

      1. Desert Island Development
      2. Stood at the Bottom of the Mountain
  6. The People Pursuit

    1. Chapter 34 People Power

      1. What to Do
      2. Know Your Experts
      3. 20/20 Hindsight
    2. Chapter 35 It’s the Thought That Accounts

      1. Stretching the Metaphor
      2. Accountability Counts
      3. Code++
      4. Making It Work
      5. Setting the Standard
      6. The Next Steps
      7. Conclusion
    3. Chapter 36 Speak Up!

      1. Code Is Communication
      2. Interpersonal Communication
      3. Talking of Teams
      4. Talking to the Customer
      5. Other Communication
      6. Conclusion
    4. Chapter 37 Many-festos

      1. A Generic Manifesto for Software Development
      2. OK, OK
      3. The Manyfestos
      4. But, Really?
      5. The Punchline
    5. Chapter 38 An Ode to Code

      1. Coding Is a People Problem