Useful or amusing computer-y advice I’ve found on the internet.

• Code is a liability, what the code does is an asset
• Dumb code is smart code
  • The Grug Brained Developer
  • Kernighan’s Law

    Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.

  • Repeat yourself, do more than one thing, and rewrite everything
  • Write code that’s easy to delete, and easy to debug too.
  • Why bad scientific code beats code following “best practices”
• Use assert()
  • The benefits of programming with assertions (a.k.a. assert statements)
  • Use of asserts in SQLite
  • Logging, asserts and unit tests
  • Use of Assertions
• Follow the not rocket-science rule of software engineering and codify all checks that can be automated into CI tasks (e.g. linting, style rules, tests)
  • Only once this rule is in place can you ensure that changes that don’t meet the constraints/properties of the project are rejected
  • You can even enforce properties outside of the code with unit tests, e.g. documentation unit tests
• Use data-oriented design
  • What data is actually needed for the program? What minimal set of transformations are required to solve the problem?
  • Storing data relationally (column-oriented) is often more data oriented than OOP.
  • CppCon 2014: Mike Acton “Data-Oriented Design and C++”
  • Andrew Kelley - Practical DOD
  • Data-oriented design book
• A relational data model is useful for most problems
  • Out of the Tar Pit
• Programmer as wizard, programmer as engineer
• Different extremes of handling failures robustly: The Erlang approach or the mission critical approach
  • The Erlang approach: Let it Crash
    • Write the happy path, plan for failure. Minimize blast radius and restart subcomponents needed.
  • The Mission Critical approach: Clean-room design, test everything, simulate the heck out of it, use formal verification
    • How SQLite is Tested
    • Testing Distributed Systems w/ Deterministic Simulation
• Parsing
  • Simple but Powerful Pratt Parsing
  • On Parsing
  • Parse don’t validate
• Performance
  • sled theoretical performance guide
  • Five ways not to fool yourself
  • Practical Optimizations
  • Good performance is not just big O
• I hate slow software. Modern computers feel sluggish because they don’t optimize for low latency user input and response.
• Property-based testing
  • Finding Property Tests
• Programming sucks
• John Carmack on inlined code
• Handles are the better pointers
• Friday deploy freezes are exactly like murdering puppies
• A Research Codebase Manifesto
• Game feel
  • Instant “Game Feel” Tutorial - Secrets of Springs Explained
  • Game Feel: Why Your Death Animation Sucks
• Interview prep
  • Binary search, revisited
  • Intuiting Monty Hall
  • Intro to the C++ memory model (how atomics/sequential consistency works)