Book Note: The Pragmatic Programmer Part 5 - Bend Without Breaking

The Pragmatic Programmer Part 5 - Bend Without Breaking

Chapter 5 is about flexibility, but flexibility does not mean adding abstraction everywhere. It means reducing coupling where change is likely to enter.

■ How to use this note

This is part 5 of an eight-part reading series on The Pragmatic Programmer. It covers Chapter 5 · Bend, or Break.

I use the same operating principle as my Korean notes: notes are storage, insight cards are currency.

L0 · Entry

• Core idea: A flexible system is not one that predicted everything, but one that did not hide where change can happen.
• Why I picked this book: as AI writes more code, I want a clearer standard for what the developer still has to judge, explain, and verify.
• Initial assumption: I expected an older collection of programming advice. What remains is closer to an operating system for professional judgment.
• Scope: Decoupling and the Law of Demeter, Metaprogramming, Temporal Coupling, It’s Just a View, Blackboards
• Question: Why do some systems bend under change while others break?

L1 · Captures

• This chapter can be read through the question: Why do some systems bend under change while others break?
• Useful English terms: decoupling · metaprogramming · blackboard
• I avoid long quotations here and use paraphrase because the source is a copyrighted book.

L2 · Chapter Map

Scope	My label	Core question
Chapter 5 · Bend, or Break	Bend Without Breaking	Why do some systems bend under change while others break?

The Law of Demeter prevents objects from knowing too much about each other’s internals. Metaprogramming moves policy outside hard-coded implementation. Temporal coupling exposes the risk of order-dependent design. Views and blackboards show ways to handle the same facts from multiple perspectives.

L3 · Insight Cards

1. Coupling is the social life of code

When parts know too much about each other, every change becomes tiring. Good modules cooperate without prying.

2. Configuration is small-scale metaprogramming

When operational rules are not buried inside code, we gain the option to change behavior without redeploying everything.

3. Blackboards are an old prototype of agent collaboration

Multiple tools or agents contributing to a shared working surface looks surprisingly modern.

L4 · Production Board

• Find one long chain of calls and reduce the exposed knowledge.
• Move one environment-specific rule from code into configuration.
• Make shared state explicit where multiple steps cooperate.

Prompt template

Review the following software task through The Pragmatic Programmer lens.
1. Find duplicated knowledge, hidden coupling, and unclear responsibility.
2. Separate what humans are remembering from what can be automated.
3. Suggest three small improvements I can apply today.
4. Define the verification harness needed before delegating this to an AI agent.

L5 · Review

This chapter connects to Clean Code, Refactoring, and my current LLM Wiki experiment. The durable question is not which tool is fashionable, but how a developer chooses, changes, verifies, and communicates work.

• Open question: when AI generates more of the code, where does pragmatic responsibility move?
• Final takeaway: A flexible system is not one that predicted everything, but one that did not hide where change can happen.

Next

• Previous: Part 4
• Next: Part 6
• Back to bookshelf: /book