The Effective Engineer by Edmond Lau
4 min read

The Effective Engineer by Edmond Lau

The Effective Engineer by Edmond Lau

I completed reading The Effective Engineer and it was a nice read. The book is a compilation of software engineering techniques sprinkled with stories on increasing the impact of engineering by focusing on high-leverage activities.I recommend this book as a must read for junior to mid senior level Engineers

The book is broken down inot three parts:

Adopt the Right Mindset

  • Focus on High-Leverage Activities
    • Leverage is defined as Impact Produced per Time Invested.
    • Focus on high leverage and not just easy wins.
    • Three ways to increase your leverage
      • By reducing the time invested: Ask yourself, How can I complete this activity in a shorter amount of time?
      • By improving the impact produced: Ask yourself, How can I increase the value produced by this activity?
      • By moving to a higher leverage activity: Ask yourself, Is there something else I can work on that will produce more value?
  • Optimize for Learning
    • Learning is a higher leverage activity due to its exponential growth.
    • If you optimize for learning you may become slower today but increasingly faster as the time passes.
    • Devoting 20% of the time in learning will pay off in the long run.
    • Few Examples for effective learning
      • Study code for core abstractions written by the best engineer at your company or on open source projects.
      • Pick the harshest critic for code review.
      • Participate in design discussions, even if they are unrelated.
      • Get outside of your comfort zone more often.
      • Select teams with a few senior engineers so you can learn from their experience.
      • Fearlessly jump into code that you are unfamiliar with.
  • Priortize Regularly
    • To stay committed to high-leverage activities, regularly review how you rank activities.
    • Limit the amount of Work in Progress,Cost of context switching is high.
    • Focus on what directly produces value.
    • Learn to say no.
    • Focus on the important and non-urgent.
    • When possible, preserve larger blocks of focused time in your schedule.
    • Don't try to remember stuff. Brain is bad at remembering. It's rather good at processing.

Execute

  • Invest in Iteration Speed
    • Moving fast enables us to build more things and learn at faster rate.
    • Invest in time saving tools.
    • Have a high test coverage.
    • Faster you iterate, faster you can learn.
    • Shorten the debugging and validation loop.
  • Measure what you want to Improve
    • Use metric to drive progress,if you can't measure it, you can't improve it.
      • A Good Metric always
        • Drives forward progress.
        • Helps you guard against future regressions.
        • Helps you focus on right things.
      • Actionable - Whose movement can be casually explained by team's effort.
      • Responsive -The metric updates quickly enough to provide timely feedback.
    • When numbers look off, dig into the problem.
    • Run end-to-end integration tests on analytics.
    • Examine collected data sooner.
    • Log data liberally.
    • Build tools to iterate on data sooner.
  • Validate your Ideas Early and Often
    • Request code review and commit early and iteratively.
    • Not validating early leads to wasted efforts.
    • Approach problem iteratively.
    • Reduce the risk of large implementations by using small validations. Invest a little extra effort to figure out if the rest of your plan is possible and worth doing.
    • Working solo? Be wary. Be extra vocal and get feedback.
    • Use A/B testing to validate your product hypotheses.
  • Improve your Project Estimation Skills
    • Decompose tasks into granular subtasks.
    • The person who does the work does the estimate.
    • Beware of mythical man month. Communication overhead is significant.
    • Reduce risk early.
    • Allow budget for the unknown.
    • Additional hours hurt productivity. Causes burnout.

Build long term value

  • Balance Quality with Pragmatism
    • Right abstractions make huge differenc.Use abstractions to manage complexity, a good abstraction should be
      • Easy to learn.
      • Hard to misuse.
      • Easy to extend.
      • Sufficiently powerful to satisfy requirements.
      • Easy to use even without documentation.
    • Establish sustainable code review process.
    • Code reviews help
      • Catch bugs and design problems early.
      • Sharing working knowledge of the codebase.
      • Increases long term agility. Easier to understand, quicker to modify.
    • Repay Technical Debt
      • Accumulating technical debt is fine as far as it is repaid within time.
      • Refactor often.
    • Automate Testing
      • Unit test cases and some integration testing provide a scalable way of managing growing codebase.
      • Tests also allow engineers to make changes, especially large refactorings, with significantly higher confidence.
      • A suite of extensive and automated tests can reduce overall error rates by validating the quality and by safeguarding against regressions.
  • Minimize Operational Burden
    • Be Careful of the “Shiny New Things” Syndrome.
    • Do the simple thing first.
    • The first solution that comes to mind is generally complex. Don't stop. Keep peeling off the layers of onion.
    • Embrace operational simplicity.
    • Automate Mechanics Over Decision-making.
    • Plan and practice failure modes.
    • Discipline to focus on simplicity is high leverage.
    • Build Systems to Fail Fast.
      • Fail immediately and visibly.
      • Doesn’t necessarily mean crashing your programs for users.
      • Failing fast is high leverage as it saves debugging time.
  • Invest in your Team's Growth
    • Surround yourself with great advisors
    • Push relentlessly towards automation.
    • Build the right software abstractions.
    • The higher you climb up the engineering ladder, the more your effectiveness will be measured not by your individual contributions but by your impact on the people around you.
    • Invest in automated testing.
      • Automated test cases lead to higher confidence when refactoring.
      • Don’t be dogmatic about 100% code coverage.
      • Value of tests increases over time and cost to write goes down.
    • Build shared ownership of code.
      • Keep bus factor more than one.
      • Shared ownership removes isolated silos of information.
    • Your career depends on your team's success.
    • Allot experimentation time, either through 20% time or hackathons.
    • Foster a culture of learning and continuous improvement.
    • Make hiring everyone's responsibility.
    • Hire the best.

Time is our most finite asset, and leverage — the value we produce per unit time — allows us to direct our time toward what matters most.

Enjoying these posts? Subscribe for more