Wiki

Software

Design and development

• The Four Elements of Simple Design (introduced by Kent Beck in the 1990s)
• 3 Rs of Software Architecture (Readability, Reliability, Refactorability)
• Arlo Belshee
  • Naming as a Process
  • Arlo’s Commit Notation
  • AgileIsrael 2017 Bug zero - Arlo Belshee
• Software Profession Resources - Austin Chadwick et al — there are many columns, including about extreme programming, TDD, refactoring
• An open source developer’s guide to systems programming - Alex Bunardzic
• Systems Thinking Examples - JP Ovaska
• Simple Made Easy - Rich Hickey (YouTube) — one of the best talks ever. State complects value and time (~35:40).
• Basics of the Unix Philosophy (ch. 1 from The Art of Unix Programming - Eric Steven Raymond)
• ISO 25010: software product evaluation model
• Ward Cunningham on “technical debt” (YouTube)
• Towards a Model-Driven Organization, part 1 and part 2 — Christian Kaul — alignment between “reality, data, and language” — in the footsteps of domain-driven design
• From Brad Appleton: “Program Development by Step-wise Refinement” (scan, html) by the legendary Niklaus Wirth (April 1971). Wirth is basically in the “CS Hall of Fame” right alongside the likes of Knuth, Parnas, Dijkstra, etc.
• No Best Practices
• https://github.com/jamesmullenbach/dotfiles/blob/master/codewisdom — collection of quotes from the greats
• https://www.linkedin.com/pulse/software-engineering-great-quotes-maximiliano-contieri/ — another such collection
• 7 minutes, 26 seconds, and the Fundamental Theorem of Agile Software Development, J.B. Rainsberger (YouTube) — “most people, most of the time, the cost of a feature is dominated.. dominated.. dominated!.. by the cost from accidental complication; that means that the cost of your feature has almost nothing to do with how hard it is and almost everything to do with how much your design sucks”
• What is a Product? - Marty Cagan

Programming languages

• Why Isn’t Functional Programming the Norm? - Richard Feldman (YouTube)
  • Alan Kay did not invent objects - Hillel Wayne
• Design Principles Behind Smalltalk - Daniel H. H. Ingalls — very deep; interesting usage of the term method

Scripting

• Bash scripting
  • Conquering the Command Line
  • Advanced Bash-Scripting Guide
  • pure bash bible

Workflow

• Trunk Based Development
  • https://trishagee.com/2023/05/29/why-i-prefer-trunk-based-development/
• http://www.extremeprogramming.org/
  • https://wiki.c2.com/?ExtremeProgramming
  • Manifesto for Agile Software Development
  • Principles behind the Agile Manifesto
  • Heuristics for Effective Software Development Organizations - Allen Holub
  • 5 Minute DevOps: Upgrading the Agile Manifesto — Bryan Finster
  • Voyage in the Agile Memeplex — Philippe Kruchten
  • What is Value? - Jez Humble (YouTube)
  • 5 Minute DevOps: Solving the Uncertainty Problem — Bryan Finster — amazing post about how to work as a team
• Minimum Viable CD (Continuous Delivery)
  • https://dojoconsortium.org/docs/starting-ci-cd/
• DORA’s State of DevOps research program
• The (Short) History of DevOps (YouTube)
• Async code reviews
  • Why your team doesn’t need to use pull requests
  • From Async Code Reviews to Co-Creation Patterns — Dragan Stepanovic
  • Async Code Reviews Are Chocking Your Company’s Throughput by Dragan Stepanovic (YouTube)
  • “there is no smaller batch without higher availability” - Andrea Laforgia via Dragan Stepanovic
    • that is, the team must be responsive to PRs, which, in turn, promotes smaller PRs
• Cynefin framework - complex, complicated, chaotic, clear domains. I was introduced to this by Fred George.
• Alan Richardson: Thinking Visually In Software Testing — broad applicability, using available tools to express ourselves most directly
• Active Knowledge in Software Development - Michael Feathers
• So you think you work in a team

Culture

• Don’t Call Yourself a Programmer — Patrick McKenzie — classic post, really helped me to get my first job in software: we aren’t hire for fun, we’re hired because we’re a cheaper way to solve problems for a business
• The Engineer/Manager Pendulum - Charity Majors
• Normalization of deviance — Dan Luu
• The maze is in the mouse: What ails Google. And how it can turn things around. — Praveen Seshadri — ”Within Google, there is a collective delusion that the company is exceptional. And as is the case in all such delusions, the deluded ones are just mortals standing on the shoulders of the truly exceptional people who went before them and created an environment of wild success. Eventually, the exceptional environment starts to fade, but the lingering delusion has abolished humility among the mere mortals who remain.” Eerily reminiscent of William Carlos Williams’ essay about the two types of Americans (all were immigrants of two types: heroes, small in number, who were mythologized by the rest, yet never accepted by them as brothers; and the rest, the lazy ones) — The American Background, found in Selected Essays (1954).
• Poor Programmers Out-Breed Good Ones - Daniel B. Markham — ”The longer good programmers stay in large settings, the more they train themselves to be poor programmers.”
  • see also: Good Enough Programming - Daniel B. Markham
• It is Time to Fulfill the Promise of Continuous Delivery: Charity Majors (YouTube) — ”I’ve never seen the happiness of your engineering team and the happiness of your users significantly diverge. I’ve never seen a team of absolutely miserable engineers creating a product that delights their users. And I’ve never seen a company with absolutely miserable users, where their engineers enjoyed their work.” / “A leader’s job in tech, if it is anything, it is to bring on the right people and then craft the right feedback loops.” / “The speed and cadence of your CI/CD pipeline will basically determine how high-performing your teams will be, more than any other variable.”

Architecture

• Microservices Architecture Journey at Airbnb
• When To Use Microservices (And When Not To!) • Sam Newman & Martin Fowler • GOTO 2020
• Logs vs Structured Events - Charity Majors — distributed systems logging — instead of logging and error levels, send one “blob” representing all the context about a request; send the blob at end of request (whether successful or unsuccessful)
  • Structured Events Are The Basis of Observability
  • Framework for an observability maturity model: using observability to advance your engineering & product
  • Observability-Driven Development for Tackling the Great Unknown — InfoQ: Jennifer Riggins, review by Manual Pais
  • https://sre.google/sre-book/monitoring-distributed-systems/#xref_monitoring_golden-signals
• Programs, Life Cycles, and Laws of Software Evolution - Meir M. Lehman, 1980
• The C4 model for visualizing software architecture
• The Future of Ops Is Platform Engineering - Charity Majors
• The Future of Software is a Sociotechnical Problem - Charity Majors

Testing/Unit Tests/TDD

• Test Desiderata - Summary — Kent Beck
  • Test Desiderata — Kent Beck
  • Programmer Test Principles - Kent Beck — his earliest version of these ideas
• TDD, Where Did It All Go Wrong - Ian Cooper (YouTube) — my favorite talk on TDD
• TDD Process Smells - Tim Ottinger & Jeff Langr
• TDD on the Front End - Geepaw Hill — the notion is to not test frameworks (which call our code) — move all the business logic out of the framework
• The 3 Types of Unit Test in TDD - David Farley (YouTube) — the core, comprehensive point is at 8:40
• Uncle Bob on TDD (YouTube) — short and sweet
• Does TDD Really Lead to Good Design? - Sandro Mancuso (YouTube)
• On Untestable Software - Blake Norrish — “Quality Engineering is the active and intentional creation of testable systems. … In order to do quality engineering, you need to intentionally and explicitly use quality assurance expertise to build testable systems.”
• Testing in the Twenties - Tim Bray
• An Introduction to Contract Testing — Bas Dijkstra
• Testing Without Mocks: A Pattern Language - James Shore
  • Mocks, Fakes, Stubs and Dummies — collection of definitions of these terms
• I test in prod - Charity Majors
• Testing Microservices: You’re Thinking About (Environment) Isolation All Wrong
• Surviving Legacy Code with Golden Master and Sampling - J.B. Rainsberger
• Stop requiring only one assertion per unit test: Multiple assertions are fine - Mark Seeman
• https://www.agilealliance.org/resources/sessions/test-driven-development-guided-by-zombies/
• https://michaelfeathers.substack.com/p/fixity-and-intention “We can look at tests as descriptions with varying lifetimes. Some may last for years and others may last for hours. They are useful as long as they facilitate change and understanding.”
• https://mkedemo.wordpress.com/2021/05/03/testing-beyond-requirements/comment-page-1/#comment-1061
  • http://www.thetesteye.com/papers/TheLittleBlackBookOnTestDesign.pdf
  • Testing and Checking Refined
  • https://www.developsense.com/articles/2005-01-TestingWithoutAMap.pdf
  • https://www.annemariecharrett.com/how-to-avoid-being-fooled-in-software-testing/

Waste

• Technical Debt Cripples Productivity — 23% of development time is wasted due to technical debt.
• Stripe developer survey, 2018 — ”How many hours per week do you estimate developers at your company waste on maintenance (i.e. dealing with bad code / errors, debugging, refactoring, modifying)?” — mean response out of 1000 responses: 42% of the work week

Data

• gbif.org - free and open access to biodiversity data

I’d like to learn more

• https://www.quantamagazine.org/behold-modular-forms-the-fifth-fundamental-operation-of-math-20230921/?mc_cid=732b2ea229
• https://convox.com/
• How To Design Programs, 2nd edition — text uses Scheme
• https://github.com/mbj/mutant — Mutation testing in Ruby (source: LinkedIn post)
  • Note: restrictive, not free for commercial use (free for OSS if you email author).
  • Python has open source options: https://github.com/boxed/mutmut and https://github.com/sixty-north/cosmic-ray
• Do some light research on OSes, based on my LinkedIn post
• CCTDD: Cypress Component Test Driven Design - Murat Ozcan
• books about #software that are not actually about software - LinkedIn
• https://dagger.io/blog/go-sdk — Go SDK for Docker-based CI/CD
• Wasm — use cases; viable delivery mechanism already?
  • https://www.youtube.com/watch?v=OGcm3rHg630
  • https://www.fermyon.com/blog/introducing-spin
  • https://www.fermyon.com/blog/webassembly-component-model
  • https://www.docker.com/blog/runc/
  • https://www.cncf.io/blog/2021/08/05/cloud-native-webassembly/
• How to test AWS serverless workloads, per Jason LeGris; 3 levels of testing:
  • Mock at the architecture boundaries for unit tests. (same as anything else -MG)
  • Run local with offline (using serverless cli tools) for local integration tests (hmm.. -MG)
  • Run in a clean “build” AWS account for pipeline integration tests. (Really cool! -MG)
• UI testing: https://testing-library.com/
• ChatGPT/Wolfram
  • How To Build Your Own Custom ChatGPT With Custom Knowledge Base
  • ChatGPT Gets Its “Wolfram Superpowers”!
• https://training.linuxfoundation.org/training/introduction-to-devsecops-for-managers-lfs180x/

• Kyle Griffin Aretae’s “set of readings to understand the learning model…these are my top reads on what I used to call Agile, and now I call ‘Blue Star’ software” source

  • The Lean Startup
  • Warfighting
  • 2-second Lean
  • Team of Teams
  • TDD by Example
  • Turn this Ship Around / It’s Your Ship
  • Elon Musk (book about his approach)
  • The Use of Knowledge in Society
  • Thinking Fast and Slow
  • On Liberty
  • An Enquiry Concerning Human Understanding
• Three books one could read before DDIA (source (LinkedIn))
  • Web Scalability for Startup Engineers by Artur Ejsmont
  • Understanding Distributed Systems by Robert Vitillo
  • Scalability Rules: Principles for Scaling Web Sites by Martin L. Abbott and Michael T. Fisher

Coding Practice

• http://codekata.com/
• https://adventofcode.com/
• https://codingchallenges.fyi/
• http://projecteuler.net/problems
• https://exercism.org/

Life

• Master Your Destiny — Coach Pain (YouTube)

Rhythms

• https://www.jovisan.net/uploads/1/0/7/1/10715323/brazilian_piano_styles.pdf

Misc

• https://gobotany.nativeplanttrust.org/simple/ — plant identification using a botanical key