# Master Fundamentals: Delay Abstraction for Success!

Newsy: Dev Concepts Weekly
Published: 2026-03-09T13:00:00.870Z
Source: https://newsyai.com/edition/eea1c1b3-58a1-4844-b831-295e1a8992e1
Archive: https://newsyai.com/newsy/249754d5-9f20-4825-9aeb-daeec7c365c9.md

---

# 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
1. Short leash on “helpers”  
   - If a helper is used in just one place, keep it local. Let repetition breathe.
2. Rule of three (for real)  
   - Abstract only after you’ve solved the “same” problem three times and the differences are understood.
3. Name by purpose, not plumbing  
   - When you do extract, name the intent (e.g., `chargeCustomer`) not the mechanics (`callPaymentAPI`).
4. Keep the exit hatch  
   - Design your abstraction so callers can escape with a simple override or optional parameter—no one‑way doors.
5. 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](https://sandimetz.com/blog/2016/1/20/the-wrong-abstraction)  
- Kent Beck — Make It Work, Make It Right, Make It Fast [kentbeck.github.io](https://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
1. 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.
2. 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.
3. Add tolerance windows  
   - Treat values as ranges when appropriate (e.g., “within 2 seconds,” “within 1%”). Document the window next to the check.
4. Separate precision from display  
   - Keep high‑precision internally; present friendly numbers to users. Never do math on display strings.
5. 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](https://floating-point-gui.de/)  
- RFC 3339 — Date and Time on the Internet [www.rfc-editor.org/rfc/rfc3339](https://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
1. One‑pager first  
   - Write a 6–10 sentence brief: problem, constraints, success, non‑goals, a happy‑path example. Share that before any diagram.
2. Example pack  
   - Collect 3 real inputs and the outputs you expect. These become seeds for tests and interfaces.
3. Sketch the lanes  
   - Draw a napkin‑diagram with 3–6 boxes and arrows. Label each arrow with the verb (e.g., “validate,” “charge,” “notify”).
4. Pre‑mortem in the margins  
   - Add 3 “what could go wrong?” bullets and how you’ll notice. Keep it in the doc.
5. 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](https://tom.preston-werner.com/2010/08/23/readme-driven-development.html)  
- Example Mapping — Matt Wynne [cucumber.io/blog/bdd/example-mapping-introduction/](https://cucumber.io/blog/bdd/example-mapping-introduction/)  
- Shape Up — Shaping work at the right fidelity [basecamp.com/shapeup](https://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.
