In the mode of the distributed systems reading list and the list of awesome, this is a reading list to help folks improve their practice of software engineering. The title is inspired by John Allspaw's (Chief Technology Officer at Etsy) essay on "senior engineers".
In order to account for different learning styles, it's suggested that after reading these articles, you discuss them with someone or a group. While summarizing the article is good (what did it say), what we're really interested in is analyzing the article.
A good way to take notes is to fork this repository, and add bullet points notes after each article. Here are some good discussion starters or notes to bring to a discussion:
- Of the points made in the article, what were the three most important and why? How are they connected or how are they dissimilar?
- What wasn't clear? What questions do you have?
- Where is the author wrong and why?
- What predictions can we make using the author's arguments?
- Apply the author's arguments to the current project we're working on, the team/department or the company?
To prepare for the discussion, if you're a:
- visual learner, try making tables or venn-diagrams or other charts of these categories or pros/cons,
- auditory learner, try talking these questions through with someone,
- reading/writing learner, try making an outline of your thoughts,
- kinesthetic learner, base your notes off of your recent experienes and examples.
At the very beginning of your journey it’s difficult to identify what is good and what is bad, what is gold and what is fluff. (Lindsay Holmwood)
Some of the viewpoints expressed will be controversial, outdated or crazy - that's intentional. One goal is to challenge existing beliefs to force examination and challenge any biases. If there’s an viewpoint you disagree with, jot down a brief critique, note how the article made you feel and reflect what about the article made you feel that way. This should lead to one of two outcomes: you'll either improve your arguments about why that idea is flawed, or your perspective will become more nuanced. 1
- Beautiful Code
- Mythical Man Month
- Pragmatic Programmer
- Release It
Aka "blog posts"
- On Being A Senior Engineer
- John Allspaw gives examples of the difference between maturity and seniority in a profession.
- The Law of Leaky Abstractions
- Joel Spolsky describes how abstractions are imperfect and underlying implementation details sneak through.
- MonolithFirst
- Martin Fowler discusses the tradeoffs of microservices vs. monoliths
- Failing at Microservices.
- Richard Clayton describes a lot of the common challenges involved in implementing a popular strategy.
- Egoless Programming
- Jeff Atwood reminds us that "you are not your code".
- Applying cardiac alarm management techniques to your on-call
- Lindsay Holmwood applies science to on call rotations!
- Disagree And Commit
- Don Reinertsen explains a way to use conflict productively in a team.
- How to Report Bugs Effectively
- Simon Tatham breaks down a common source of frustration for both software users and developers - reporting and fixing bugs.
- How awesome engineers ask for help
- Greg Sabo lays out the commonsense (but maybe not always at top of mind) tips and tricks for the (necessary) habit of asking for help.
- Notes on Distributed Systems for Young Bloods
- Jeff Hodges compiles a hit list of the issues found in distributed systems engineering.
- Towards an understanding of technical debt
- Kellan Elliott-McCrea discusses how technical debt may or may not exist.
- The Process Myth
- Michael Lopp (aka Rands) talks about the why the P-word exists and isn't bad - "processes should reflect your values".
- Runbooks are stupid and you’re doing them wrong
- Jeff Goldschrafe argues that exceptional states should not be treated exceptionaly.
- Choose Boring Technology
- Dan McKinley argues that constraints can drive creativity.
- Lessons learned from reading postmortems
- Dan Luu does science on some of the largest mistakes in the industry.
- How One Jira Ticket Made My Employer $1MM/Month (really 2 separate articles, the jira ticket part is more manager-y vs. the perf. metrics)
- Why I Love Reading Other People’s Code And You Should Too
- Alan Skorkin points out that before mastering something we have to see a lot of examples.
- A Codebase is an Organism
- Since codebases inevitably grow over time, Kevin Simler looks at how to manage that growth.
- How to ask good questions
- Julia Evans dissects the art of asking a question - although there may be "no such thing as a stupid question", there certainly are poorly asked ones.
- Why Averages Suck and Percentiles are Great
- Michael Kopp lays out some basics of monitoring.
- Monitoring Best Practices Learned from IT Outages , Zen and the Art of System Monitoring
- Vivian Au, in a guest post by DataDog staff on the PagerDuty blog, looks at how to classify and choose data to alert on which to alert.
- Noah Lehmann-Haupt gives a great overview of monitoring and breaks down high level principles for how to approach the problem of making sure your stuff is working.
- Logging vs. instrumentation Also 1 and 2
- An opinionated piece diffentiating between two related practices.
- Just Say No to More End-to-End Tests
- Mike Wacker (although starting from a link bait title) reviews the testing pyramid.
- Clear Writing Means Clear Thinking Means…
- A slightly dated, but remarkably relevant argument for the power of writing - a necessary skill in larger technical organizations.
Introductory topics for a software engineering beginning their journey
- Debugging and Profiling Although formal education provides solid theoretical foundations for a career in software engineering, it neglects a lot of the practical side. This topic from a course at MIT designed to cover the tools of the trade is a short list of the common tools used to debug a running Linux system. This list of tools and the exercises are a good to put in your toolbox for when things stop working.
- What We Actually Know About Software Development, and Why We Believe It’s True
- Greg Wilson both summarizes peer-reviewed research on software development and advocates for doing science about our profession.
- Simple Made Easy, slides
- Rich Hickey discusses simplicity's virtues over easiness'. He showes that while many choose easiness they may end up with complexity, and the better way is to choose easiness along the simplicity path.
- You and Your Research
- Richard Hamming shares his observations on "why do so few scientists make significant contributions and so many are forgotten in the long run?" Some of the key ideas include: courage, luck, drive, a focus on important problems, open doors, and selling the work.
- How To Design A Good API and Why it Matters
- Josh Bloch examines what makes a good (programmtic) API and practices to design them.
- Billion User Load Balancer
- Patrick Shuff talks about Facebook's multi-tiered network.
- Designs, Lessons and Advice from Building Large Distributed Systems
- Jeff Dean
- 10 Deploys Per Day
- In this oldie-but-goodie, John Allspaw talks about some of the fundamental good practices around deployment.
Here are three reasons to spend time out of your busy schedule doing some reading/watching:
- stay up to date: in the 21st century, sofware will continue to change. Yesterday it was Java, today its Go, etc.
- self-improvement: everyone makes mistakes or has gaps in their skillset. Even the best are still learning and improving.
- career growth: tomorrow's bigger and harder challenges will require new skills. Think about this preparation for handling something an order of magnitude harder.
- https://github.com/mmcgrana/services-engineering/
- https://github.com/JanVanRyswyck/awesome-talks
- http://danluu.com/programming-blogs/
Please contribute good articles back to this list!
- Fork it ( https://github.internal.digitalocean.com/phillip/reading/fork )
- Create your feature branch off of origin/master (
git checkout -b my-new-feature origin/master) - Commit your changes (
git commit -am 'Add some feature') - Push to the branch (
git push origin my-new-feature) - Create new Pull Request