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
• Execute, Execute, Execute
• Build long term value

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.