Chapter 4 — Execution

The chapter’s throughline: optimise your iteration speed. Faster, more automated releases and good monitoring let you respond to bugs quickly and see how the system is performing.

Move fast to learn fast

The faster you iterate, the more you learn about what works — you can build and try more. And speed isn’t reckless: over a four-year span Facebook’s worst outage lasted only 2.5 hours, shorter than outages at larger, slower companies. Moving fast doesn’t mean moving carelessly.

Continuous deployment’s “primary advantage is risk reduction” — it focuses the team on small batches and lets them “quickly pinpoint problems when they occur.” — Pascal-Louis Perez, former CTO of Wealthfront

Invest in time-saving tools

Asked which investments yield the highest returns, engineering leaders most often say tools.

“I’ve found that almost all successful people write a lot of tools… [A] very good indicator of future success [was] if the first thing someone did on a problem was to write a tool.” — Bobby Johnson, former Facebook Director of Infrastructure Engineering

Rule of thumb: if you have to do something manually more than twice, write a tool the third time.

Shorten your debugging and validation loops

It’s wishful thinking that code works first time and bug-free. Much of engineering is spent debugging or validating expected behaviour — the sooner you accept that, the sooner you’ll invest in making those loops faster.

You can shortcut normal flows when testing. Lau’s example: debugging the “invite a friend” flow in an iOS app, you could click through all three steps (friends tab → pick a contact → write the message) every iteration — or spend a few minutes wiring the app to drop you straight into the buggy part on launch. Effective engineers instinctively know when an upfront investment beats paying a tax every iteration.

Master your programming environment

Notice which everyday actions slow you down, then make them faster. Some starting points:

• Get proficient with your editor/IDE. Look up productivity tips for it.
• Learn a high-level, productive language. Scripting languages beat compiled ones for getting something done quickly.
• Know your shell. Basic UNIX tools often turn a task from minutes to seconds. Learn grep, sort, uniq, wc, awk, sed, xargs, find — and how to pipe them together. Bookmark useful one-liners.
• Prefer the keyboard over the mouse.
• Automate manual workflows. After doing something manually three times, consider automating it — e.g. auto-reloading a web page on save instead of the edit → switch → reload dance.
• Test ideas in an interactive interpreter.
• Make it fast to run just the tests for your current change. Use tooling that runs only the affected subset, ideally invoked from your editor with a few keystrokes.

Don’t ignore your non-engineering bottlenecks

Your iteration loop includes the whole org, not just your code.

• People dependencies. A PM slow on requirements, a designer not delivering mocks, another team’s feature blocking yours. The cause is usually misaligned priorities, not laziness. Communication is the fix: ask for updates and commitments at standups, check in periodically, follow up in writing on action items and dates. Projects fail from under-communicating, not over-communicating.
• Approvals. Don’t sink huge engineering time before seeking sign-off. Build prototypes, gather early data, run user studies to get preliminary approval — and explicitly ask decision-makers what they care about most so you nail those details.
• Review processes. QA verification, scalability/reliability reviews, security audits. Plan ahead; a little extra coordination upfront protects your iteration speed.

Key takeaways

• The faster you iterate, the more you learn. Moving too slowly to avoid mistakes loses opportunities.
• Invest in tooling. Faster compiles, deploys and turnaround compound the more you use them.
• Optimise your debugging workflow. Validation eats more time than you think; shorten those loops.
• Master the fundamentals of your craft. Efficiency in your daily environment pays dividends for a career.
• Take a holistic view of the iteration loop. Don’t ignore org/team bottlenecks within your influence.

Source

Edmond Lau, The Effective Engineer, Ch. 4.