Master Fundamentals: Delay Abstraction for Success!
The Pros Know the Fundamentals Better!
Weekly Edition
Three high‑impact topics (about 90 seconds each) to compound your growth. Plain English, vivid metaphors, practical moves.
1) Delay Abstraction: Copy Twice, Abstract Once
Most teams abstract too early and pay interest forever. Treat abstraction like pouring concrete—wait until the shape is proven.
Why this compounds
- Fewer tangled designs: Early abstractions guess at a “common” shape that later needs acrobatics.
- Faster change: Duplicates are cheap to tweak; the right abstraction pops out when patterns repeat.
- Clearer code: Real examples teach you what to name and where the seams should be.
Metaphor
- Tailor first, pattern later: A seamstress makes a couple of garments, learns where people actually move, then cuts a reusable pattern. Not the other way around.
How to do it
- Short leash on “helpers”
- If a helper is used in just one place, keep it local. Let repetition breathe.
- Rule of three (for real)
- Abstract only after you’ve solved the “same” problem three times and the differences are understood.
- Name by purpose, not plumbing
- When you do extract, name the intent (e.g.,
chargeCustomer) not the mechanics (callPaymentAPI).
- When you do extract, name the intent (e.g.,
- Keep the exit hatch
- Design your abstraction so callers can escape with a simple override or optional parameter—no one‑way doors.
- Prune relentlessly
- If an abstraction stops helping, in‑line it. De‑abstracting is a feature, not a failure.
Try this today
- Find a tiny abstraction that has just one caller. Paste it back in place, delete the “shared” version, and see if the calling code becomes easier to read.
Further reading
- Sandi Metz — The Wrong Abstraction sandimetz.com/blog/2016/1/20/the-wrong-abstraction
- Kent Beck — Make It Work, Make It Right, Make It Fast kentbeck.github.io
2) Choose Your Ruler: Decide Precision and Tolerance Up Front
Bugs love fuzzy measurements. Decide—deliberately—how exact your system needs to be, and where it can be “close enough.”
Why this compounds
- Fewer flaky tests: Clear rounding rules and time windows reduce false negatives.
- Cheaper data work: Right‑sized types (cents vs. dollars, meters vs. millimeters) avoid over‑engineering.
- Calmer UX: Tolerances prevent “off by a hair” errors that confuse users.
Metaphor
- Measuring flour with a scale vs. a teacup: Cakes need grams; soups don’t. Pick the right tool and your recipe becomes repeatable.
How to do it
- Pick units you can live with
- Money? Store as integer cents. Time? Store in UTC with explicit time zones at the edge. Sizes? Define bytes vs. kibibytes once.
- Write the rounding rule where data is born
- Round/clip on input; store the canonical value; display with formatting. Don’t round on every hop.
- Add tolerance windows
- Treat values as ranges when appropriate (e.g., “within 2 seconds,” “within 1%”). Document the window next to the check.
- Separate precision from display
- Keep high‑precision internally; present friendly numbers to users. Never do math on display strings.
- Test with “just over/under” cases
- Include boundary examples: 0, 1, max, max+1, and values right at your rounding thresholds.
Try this today
- Pick one flaky check (time, money, percentages). Declare a tolerance, move rounding to the intake step, and add two boundary tests around that rule.
Further reading
- The Floating‑Point Guide floating-point-gui.de
- RFC 3339 — Date and Time on the Internet www.rfc-editor.org/rfc/rfc3339
3) Lo‑Fi First: Crayon Before CAD
Before tooling, tickets, or code, sketch with the cheapest medium you can: short text, rough lists, and concrete examples. Clarity loves low fidelity.
Why this compounds
- Faster alignment: People argue less when they can react to a scrappy sketch instead of a polished castle.
- Fewer rewrites: It’s cheap to erase a crayon line; expensive to rework a detailed blueprint.
- Better names: Writing a one‑page “how this works” forces you to pick words your teammates can actually use.
Metaphor
- Film storyboards: Directors sketch scenes with stick figures to find the story beats before building sets.
How to do it
- One‑pager first
- Write a 6–10 sentence brief: problem, constraints, success, non‑goals, a happy‑path example. Share that before any diagram.
- Example pack
- Collect 3 real inputs and the outputs you expect. These become seeds for tests and interfaces.
- Sketch the lanes
- Draw a napkin‑diagram with 3–6 boxes and arrows. Label each arrow with the verb (e.g., “validate,” “charge,” “notify”).
- Pre‑mortem in the margins
- Add 3 “what could go wrong?” bullets and how you’ll notice. Keep it in the doc.
- Only then pick tools
- After language and examples are stable, choose libraries and patterns that match the shape you discovered.
Try this today
- For your next change, spend 20 minutes writing a one‑pager and two concrete examples. Share it. Don’t open your IDE until a teammate can restate the plan in their own words.
Further reading
- README‑Driven Development (expanded notes) tom.preston-werner.com/2010/08/23/readme-driven-development.html
- Example Mapping — Matt Wynne cucumber.io/blog/bdd/example-mapping-introduction/
- Shape Up — Shaping work at the right fidelity basecamp.com/shapeup
Quick Recap
- Delay abstraction until patterns are real; copy twice, abstract once.
- Choose precision and tolerance up front; pick the right ruler and write the rounding rule where data is born.
- Go lo‑fi first; words and examples beat premature tools and code.
Keep compounding: wait before you pour concrete, measure with the right tool, and sketch before you sculpt.