bookmarks.
Last update: 15/09/2025 00:09
Feel free to follow this list via RSS too, you can find it here.
If you prefer, you ca also check the tags accordingly their labels here.
Everything that I added here, come from my RSS feed. If you curios about the recommendations, you can check my OPML file at here.
Table of Contents
2025 / September
- Writing an operating system kernel from scratch
- Magical systems thinking
- How Container Filesystem Works: Building a Docker-like Container From Scratch
- Becoming the person who does the thing
- Getting Started with Randomised Testing
- Pragmatism in Programming Proverbs
- Ramblings
- LLM Inflation
- We shouldn’t have needed lockfiles
- GPT-4.1 Prompting Guide
- GPT-4
- Architecture by Fashion, Not Fundamentals - kellabyte
- How Tool Complexity Impacts AI Agents Selection Accuracy
- Evaluating Tool Selection
- ToolACE: Winning the Points of LLM Function Calling
- Optimizing Tool Calling
- LLM Evaluation Metrics: The Ultimate LLM Evaluation Guide
- Fine-tuning With Tool Calling
- IEEE Xplore Full-Text PDF:
- How My Blog Handles Math and Images in HTML, Atom, and Email in 2025
- Sometimes Software is Done, or Why Hugo Why
- Unexpected sudo hang under VPN kill-switch
- Thinking about coding
- Vibe Coding Terminal Editor
- Ads Are a Positional Good
- Knowledge and Common Knowledge in a Distributed Environment, Part 2
- The Loudness Wars
- More casual-posting
- LLMs as Parts of Systems
- 6 surprising things about life in SF
- Rust Atomics and Locks
- Thoughts on (Amazonian) Leadership
- Don’t Build Multi-Agents
- Of Rats and Ratchets
- You can try to like stuff
- A CPU is a compiler
- A Random Walk in 10 Dimensions
- How many dimensions is this?
- Your Biggest Customer Might Be Your Biggest Bottleneck
- How we made Kagi Assistant load twice as fast
- Debugging nixpkgs Package Build
- wal3: A Write-Ahead Log for Chroma, Built on Object Storage
- What Is the Fourier Transform?
- Evolving The OCaml Programming Language
- Bartosz Milewski's Programming Cafe
- Pratt Parsers: Expression Parsing Made Easy
- Demystifying Pratt Parsers
- The day Return became Enter
- Logical Duals in Software Engineering
- Unintended consequences
- Sometimes CPU cores are odd
- Burrito Monads, Arrow Kitchens, and Freyd Category Recipes
- Anything can be a message queue if you use it wrongly enough
- Do the simplest thing that could possibly work
- Game Theory at Work: When to Talk and When to Shut Up
- SQLite commits are not durable under default settings
- Mike Mai’s Typography Manual
- Materialized views are obviously useful
- A Guide to Gen AI / LLM Vibecoding for Expert Programmers
- Language Models as Thespians
- Without the futex, it's futile
- Discrete Distributions
- Bypassing no-go theorems
- Raft does not Guarantee Liveness in the face of Network Faults
- Beyond Booleans
- Faster Index I/O with NVMe SSDs
- View Change Protocols And Reconfiguration
- Designing Software in the Large
- How should we learn from bugs?
- Jepsen 18: Serializable Mom by Kyle Kingsbury
- Patterns vs. "Patterns"
- Don't write bugs
- Look Out For Bugs
- Formality on demand
- Oldest recorded transaction
- The Angels and Demons of Nondeterminism
- Normalization of deviance
- Stop writing CLI validation. Parse it right the first time.
- 2 thoughts on “The problems that accountability can’t fix”
- Strong Eventual Consistency - The Big Idea behind CRDTs
- Deliberate Abstraction
- How I solved a distributed queue problem after 15 years
- The story of how RSS beat Microsoft
- Building A Database On S3
- Hypervisor in 1,000 Lines
- From Unit Tests to Whole Universe Tests (with Will Wilson)
- A break from programming languages
- Defeating Nondeterminism in LLM Inference
- My Quarterly System Health Check-in: Beyond The Dashboard
- How To Automate Anything. A Guide to Parts Every Maker Should Know How To Use.
- Knowledge and Common Knowledge in a Distributed Environment, Part 1
- jantimon/react-hydration-rules: Comprehensive guide documenting React hydration and Suspense fallback behaviors during SSR
- Elements of Rust - Core Types and Traits
- GitHub - the-litte-book-of/linear-algebra: There is hardly any theory which is more elementary than linear algebra, in spite of the fact that generations of professors and textbook writers have obscured its simplicity by preposterous calculations with matrices. —Jean Dieudonne
- Big O
- Bits and pieces
2025 / August
- You no longer need JavaScript
- BUGGIFY
- Secret Management on NixOS with sops-nix
- Circuit Simulator Applet
- Optimizing our way through Metroid
- "| > "
- Consistency Models
- How to Think About GPUs
- NixOS & Flakes Book
- Consensus algorithms at scale: Part 1 - Introduction
- Typechecker Zoo
- The Patterns
- Type inference for plain data
- iPhone DevOps - ultimate edition
- OOMProf - Profiling on the Brink
- What even is distributed systems
- Viewstamped Replication: The Less-Famous Consensus Protocol
- A CT scanner reveals surprises inside the 386 processor's ceramic package
- Lobsters Interview with Hwayne
- Over engineering my homelab so I don't pay cloud providers
- Why You Should Build Durable Workflows With Postgres
- Cognitive Decline Can Be Slowed Down With Lifestyle Changes, From Diet to Exercise and Social Time, New Study Suggests
- Implementing Viewstamped Replication protocol
- How to Scale Proteomics
- Build Your Own Lisp Learn C and build your own programming language in 1000 lines of code!
- Software books I wish I could read
- Gate-level emulation of an Intel 4004 in 4004 bytes of C
- Social Capital: The Compound Interest of Your Engineering Career
- Proofs are Programs
- Practical Static Analysis for Privacy Bugs
- How to reverse engineer an analog chip: the TDA7000 FM radio receiver
- The Making of D.
- The Math Is Haunted
- Linear types for programmers
- Does the Bitter Lesson Have Limits?
- HoareHoare Logic, Part I
- The many, many, many JavaScript runtimes of the last decade
- A Bytecode VM for Arithmetic: The Parser
- Lobsters Interview with Icefox
- What Declarative Languages Are
2025 / July
- „I Am Tired All The Time“ – 13 Reasons Why
- Emacs: The MacOS Bug
- Your actions reflect your priorities
- polarizing parsers
- Behind the Scenes: My "How Computers Really Work" Series on Computerphile
- How the Brain Increases Blood Flow on Demand
- 2000 words about arrays and tables
- Why We Need to Know LR and Recursive Descent Parsing Techniques
- Writing memory efficient C structs
- Writing an OS in Rust
- Typechecking Is Undecidable When 'Type' Is A Type
- Learning Basic Electronics By Building FireFlies
- Simple and fast Rust deriving using macro_rules
- Learning Is Slower Than You Think — And That’s the Point
- LLM Embeddings Explained: A Visual and Intuitive Guide
- consensus
- You’re probably using the wrong dictionary
- Atomic Habits Summary
- Getting decent error reports in Bash when you're using 'set -e'
- Paul Dirac and the religion of mathematical beauty
- Heredocs Can Make Your Bash Scripts Self-Documenting
- Using fortune to reinforce habits
- Trust Deterministic Execution to Scale & Simplify Your Systems • Frank Yu • YOW! 2023
- Verified Assembly 2: Memory, RISC-V, Cuts for Invariants, and Ghost Code
- Advanced Rust macros with derive-deftly
- The Intel 4004 Microprocessor and the Silicon Gate Technology
- Development shells with Nix: four quick examples
- RealtimeKit and CPU Scheduling
- How often is the query plan optimal?
- Tail Latency Might Matter More Than You Think
- Why English doesn’t use accents
- Programming Extensible Data Types in Rust with CGP - Part 2: Modular Interpreters and Extensible Visitors
- Writing an IR from Scratch and survive to write a post - Eduardo Blázquez’s Personal Webpage
- Hacking Coroutines into C
- We Made Postgres Writes Faster, but it Broke Replication
- Can we test it? Yes, we can! - Mitchell Hashimoto
- Tree-Structured Concurrency II: Replacing Background Tasks With Actors — 2025-07-02
- Sort By Controversial
- Gödel's beavers, or the limits of knowledge
- Efficiency of a sparse hash table
- Austerity - Wikipedia
- How does a screen work?
- Let's Learn x86-64 Assembly! Part 0 - Setup and First Steps
- Row Polymorphic Programming
- Strategies for very fast Lexers
- Human Stigmergy
- Feynman: Knowing versus Understanding
- Turing Machines: How Computers Evolved From People
- Making the assumption rule only apply to atoms
- Compiler bootstrapping in Nixpkgs
- Adding lookbehinds to rust-lang/regex
- NixOS Secrets Management
- Lessons From Creating My First Text Adventure
- Programming Extensible Data Types in Rust with CGP - Part 3: Implementing Extensible Records
- Reverse proxy deep dive
- constrained languages are easier to optimize
- A Smart Bear » Specificity: A weapon of mass effectiveness
- you are in a box
- RNA Is the Cell’s Emergency Alert System | Quanta Magazine
- Function Over Form: Why ‘Unbiological’ Neural Networks Are the Truest Simulation of the Brain #
- placing functions — 2025-07-08
- Computational Lambda-Calculus And Monads
- Program Synthesis: The λ in the Machine
- The Future of Maths May Be Deeply Weird
- My Ultimate Self-hosting Setup
- To be a better programmer, write little proofs in your head
- On The Unusual Effectiveness Of Logic In Computer Science
- Casey Muratori – The Big OOPs: Anatomy of a Thirty-five-year Mistake – BSC 2025
- Gödel’s Incompleteness Theorems
- Deeper theories of program design
- Mario is (NP-) Hard
- What is a Transformer?
- LL and LR Parsing Demystified
- Automating Away Claude's Bad Habits with Hooks
- Hardest Problem in Computer Science: Centering Things
- A reckless introduction to Hindley-Milner type inference
- Algorithms for Modern Processor Architectures
- Cloudflare and the infinite sadness of migrations
- How to draw lambda diagrams
- To The Programmer
- Implementing a Functional Language with Graph Reduction
- Monotonic and Wall Clock Time in the Go time package
- The Future is NOT Self-Hosted
- Rust running on every GPU
- It’s time for modern CSS to kill the SPA
- Guia para implementar regras de especulação em sites mais complexos bookmark_borderbookmark Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.
- Formal specs as sets of behaviors
- technicalities: "not rocket science" (the story of monotone and bors)
- Mathematics for Computer Science
- Migrating my NAS from CoreOS/Flatcar Linux to NixOS
- What part of Hindley-Milner do you not understand?
- Reflections on OpenAI
- Programming Language Theory has a public relations problem
- Basic facts about GPUs
- NULLBITMAPGPT
- Why your website should be under 14kB in size
- Store tags after payloads
- Maybe writing speed actually is a bottleneck for programming
- Caching is an Abstraction, not an Optimization
- Zig's New Async I/O
- Working through ‘Writing A C Compiler’
- Type Theory in Computer Science, Linguistics, Logic
- How Long Contexts Fail
- How to Fix Your Context
- The sound of inevitability
- A distributed systems reliability glossary
- How to bring data centre-like connectivity to your home with IPTTTH
- Inverse Triangle Inequality Jul 7, 2025
- How NAT traversal works
- LLM Inference in Production
- An Introduction to Neurotransmitters (and How to Modulate Them)
- Writing a very simple JIT Compiler in about 1000 lines of C
- You Are The Compiler
- The Mathematical Functions Grimoire
- RE//verse 2025: Full-stack Reverse Engineering of the Original Microsoft Xbox (Markus Gaasedelen)
- Logical Quantifiers in Software
- Lies we tell ourselves to keep using Golang
- How to Network as an Introvert
- A Smart Guide to Choosing the Right Antidepressant
- From Python Programmer to Distributed Systems Researcher in 10 Years Without a PhD
- Queuing Theory on a Cocktail Napkin by Dan Slimmon | DC Systems 007
2025 / June
- Inference in Agda
- Bloom Filters by Example
- My experience using financial commitments to overcome akrasia
- My TRT Lite Protocol
- How to Think About Time in Programming
- Stateful workload operator: stateful systems on Kubernetes at LinkedIn
- Learnings from building AI agents
- How much code does that proc macro generate?
- The Halting Problem is a terrible example of NP-Harder
- What is cosh(List(Bool))? Or beyond algebra: analysis of data types.
- Git Notes: git's coolest, most unloved feature
- Estrogen: A trip report
- Of Course ML Has Monads!
- How do Transistors Work? How are Transistors Assembled Inside a CPU?
- Career advice, or something like it
- What I talk about when I talk about IRs
- Variables Pt. 2
- We Can Just Measure Things
- More frontend web tricks
- 56 Responses to “Guess I’m A Rationalist Now”
- Homomorphically Encrypting CRDTs
- In Praise of “Normal” Engineers
- Monads are not like burritos
- react/compiler/packages/babel-plugin-react-compiler/src/Inference/MUTABILITY_ALIASING_MODEL.md at main · facebook/react
- Retries
- Building Effective AI Agents
- Time Series Forecasting with Graph Transformers
- Graphical Linear Algebra
- I wrote a compiler
- Double-Entry Ledgers: The Missing Primitive in Modern Software
- ADRs.
- Conformance Checking at MongoDB: Testing That Our Code Matches Our TLA+ Specs
- How Long Must I Test?
- Notes on Managing ADHD
- A Brief Tour of FLP Impossibility
- atl.wiki
- Just fucking code.
- What's the big deal about Deterministic Simulation Testing?
- How can one write blazing fast yet useful compilers (for lazy pure functional languages)?
- Self-Host & Tech Independence: The Joy of Building Your Own
- a timeline -- V3.1
- Can We Rely On Timers For Distributed Algorithms?
- TigerBeetle 0.16.11
- What Every Programmer Should Know about How CPUs Work • Matt Godbolt • GOTO 2024
- How Scale Makes Distributed Systems Slower • Jonathan Magen • GOTO 2024
- The Shape of the Essay Field
- Designing Error Types in Rust Libraries
- How We Migrated 30+ Kubernetes Clusters to Terraform
- If you are useful, it doesn’t mean you are valued
- 0.9999... ≊ 1
- Building a Linear Regression from Scratch with Python & Mathematics
- Awesome Emacs on macOS
- Crafting your environment
2025 / May
- Write down what you’ve done
- Bayes For Everyone - by Scott Alexander - Astral Codex Ten
- What does "Undecidable" mean, anyway
- immersive linear algebra
- Awesome Emacs on macOS
- Access Control Syntax
- How I use Obsidian
- Against Curry-Howard Mysticism [loc-000S]
- Why Algebraic Effects
- Nobody Ever Gets Credit for Fixing Problems that Never Happened
- The Annotated Kolmogorov-Arnold Network (KAN)
- The Annotated Transformer
- HOWTO: Avoid temptation -- why avoiding temptation is harder than you think
- HOWTO: Change your behavior
- Transpiler, a meaningless word
- What every computer science major should know
- Good Performance for Bad Days
- The Ingredients of a Productive Monorepo
- Not causal chains, but interactions and adaptations
- SSTable and Log Structured Storage: LevelDB
- Memtable & SSTable (Sorted String Table)
- Spaced Repetition Systems Have Gotten Way Better
- Overcoming the Legacy Code Challenge
- Behind the Scenes: Sleeping soundly with the help of TLA+
- Newtyped Indices are Proofs
- Working on Complex Systems
- Onwards to the Core: etcd
- Statistical Properties: Are We Serious?
- Rethinking Modern Asynchronous Paradigms
- Stop using REST for state synchronization
- My 2025 high-end Linux PC 🐧
- Beej's Guide to Networking Concepts
- GitHub - miguelmota/bash-streams-handbook: 💻 Learn Bash streams, pipelines and redirection, from beginner to advanced.
- Beyond the Wrist: Debugging RSI
- On becoming competitive when joining a new company
- Why do things go right?
- Learning Containers From The Bottom Up
- On work processes and outcomes
- How much information is in DNA?
- Reading "Business" Books Is A Waste Of Time
- Virtual DOM
- Critical Architecture/Software Theory
- Propositions as Types
- Contents
- The most important thing to understand about queues
- A Better Man Page Viewer
- Parsing is Search
- Why Bloom filters?
- Functions are Vectors
- The Fuzzing Book
- IO devices and latency
- Disconnecting Distraction
- Battle of the Mallocators
- What is Entropy?
- Personal Knowledge Management Workflow for a Deeper Life — as a Computer Scientist
- Why Vim Is More than Just an Editor – Vim Language, Motions, and Modes Explained
- The Top Idea in Your Mind
- Pwning the Ladybird browser
2025 / April
- Why I Blog and How I Automate it
- Tools for keeping focused
- Attention is your scarcest resource
- Tiny Emulators
- Why do electrons not fall into the nucleus?
- Meanings as programs: Programming Really Is Simple Mathematics
- Advice for time management as a manager
- Solving SICP
- Transactions are a protocol
- An introduction to Bayes' rule - Chapter 1
- But good sir, what is electricity?
- The Skill That Never Goes Obsolete
- Push Ifs Up And Fors Down Nov 15, 2023
- Design of a NAND gate using the ICPS PDK
- Impact, agency, and taste
- Phil Eaton on Technical Blogging
- Decomposing Transactional Systems
- Rust Collections Case Study: BTreeMap
- {transitions} = f(state)
- The Mysterious Flow of Fluid in the Brain | Quanta Magazine
- How the Brain Protects Itself From Blood-Borne Threats | Quanta Magazine
- How CouchDB Prevents Data Corruption: fsync
- 3 thoughts on “Paxos made visual in FizzBee”
- Implementing SQL JOIN Support in ChronDB via PostgreSQL Protocol
- Faster interpreters in Go: Catching up with C++
- Just Throw It Into Postgres
- Hacking the Postgres wire protocol
- SQLite Transactions and Virtual Tables
- Virtual Machine - Stack Arithmetic
- An epic treatise on error models for systems programming languages
- Practical Alloy
- Antithesis driven testing
- Revisiting an early critique of formal verification
- An Introduction to Virtual Consensus in Delos
- Meaning as programs: Programming Really Is Simple Mathematic
- Introduction
- Concurrency bugs in Lucene: How to fix optimistic concurrency failures
- Just because you’re getting an index scan, doesn't mean you can’t do better!
- MySQL transactions per second vs fsyncs per second
- Land ahoy: leaving the Sea of Nodes
- What Fekete’s Anomaly Can Teach Us About Isolation
- How do LLMs work?
- Systems Correctness Practices at AWS
- Hacking a Smart Home Device
- Distributed Systems Programming Has Stalled
- Model error
- One or Two? How Many Queues?
- Things that go wrong with disk IO
- Dice and Queues
- Size matter
- Snapshot Isolation vs Serializability
- Versioning versus Coordination
- The Challenge
- How to Write Blog Posts that Developers Read
- Demystifying monads in Rust through property-based testing
- Resilience: some key ingredients
- Comptime Zig ORM Mar 19, 2025
- Large Lambda Model
- Compiler Engineering for Substructural Languages I: The Problem with Polymorphism
- How to Sync Anything
- Why The First Computers Were Made Out Of Light Bulbs
- Good models protect us from bad models
- Flambda2 Ep. 4: How to write a purely functional compiler
- 100 Ways To Live Better
- The Hitchhiker's Guide to Concurrency
- Implementers, Solvers, and Finders
- Parser Combinators Beat Regexes
- Demystifying the #! (shebang): Kernel Adventures
- Impromptu disaster recovery
- Expose an external resource with a Kubernetes Ingress
- High Agency In 30 Minutes
- What I'd do as a College Freshman in 2025
- Creating 256 Bytes of RAM (in a simulation)
- Async from scratch 1: What's in a Future, anyway?
- Refactoring won't save you from a layoff
- Salary Negotiation: Make More Money, Be More Valued | Kalzumeus Software
- My favorite technical blogs
- The Computer Backup Rule of Three
- The Best Programmers I Know
- Build your own SQLite, Part 1: Listing tables
- There is No Automatic Reset for Engineering
- A Quick Journey Into the Linux Kernel
- 🦀 Building a search engine from scratch, in Rust: part 1
- Apple’s Darwin OS and XNU Kernel Deep Dive
- BTrees, Inverted Indices, and a Model for Full Text Search
- Catalog of Patterns of Distributed Systems
- It's Time to Stop Building KV Databases
- How far neuroscience is from understanding brains
- A Brief, Incomplete, and Mostly Wrong History of Programming Languages
- Don't Be Afraid Of Types
- Your Network, Your Rules: Take Charge With Own DNS
- How browsers REALLY load Web pages
- 2024's hottest topics in databases (a bibliometric approach)
- to do nothing
- The History of the Web
- Nix derivations by hand, without guessing
- Total functions and beyond
- Bret Victor - Inventing on Principle
- Domain-Agnostic and Domain-Specific Tools
- What is a CUDA Device Architecture?
- More Drowning Children
- Philosophy and Methodology of Experiments
- How does async Rust work
- My Beancount books are 95% automatic after 3 years
- What is wrong with the architecture of the Internet?
- Programming Really Is Simple Mathematics
- Every Intervention Is A Complex Calculation of Tradeoffs
- Win Streaking and Reliability
- What to Do
- .arpa, rDNS and a few magical ICMP hacks
2025 / March
- A Society That Lost Focus
- The surreal joy of having an overprovisioned homelab
- An HTTP Server in Go From scratch: Part 2
- A Field Guide to Rapidly Improving AI Products
- SQL Indexing and Tuning e-Book
- The append-and-review note
- complexity as entropy
- 1. Lambda Calculus - Grammar & Terms
- Fixing Recursions In Grammar
- How I Biohack My Vitality
- Why cryptography is not based on NP-complete problems
- Added Replication Slots in
- Turbocharging V8 with mutable heap numbers
- Lambda Calculus and Lisp, part 1
- XOR in boolean logic
- Time Depletion
- A brief meditation on formal systems and lying goblins
- Zen and the Art of Microcode Hacking
- My LLM codegen workflow atm
- Leader election with S3 and If-Match
- Finding Time to Invest in Yourself
2025 / February
- Rationalization
- How Core Git Developers Configure Git
- Ask for no, don’t ask for yes
- The Bottom Line
- Learning: the hardest problem in computer science
- Algebraic effects are a functional approach to manage side effects
- Speed matters: Why working quickly is more important than it seems
- Meta’s Hyperscale Infrastructure: Overview and Insights
- Picoeconomics
- Finding Flow: Escaping Digital Distractions Through Deep Work and Slow Living
- 50 Years of Travel Tips
- Using Generics to Inject Stubs when Testing
- Applied Picoeconomics
- Fire And Motion
- The Holy Grail of Self-Improvement
- HOWTO: Be more productive
- Akrasia, hyperbolic discounting, and picoeconomics
- How I Am Productive
- Productivity
- Every productivity thought I've ever had, as concisely as possible
- Anatomy of a Formal Proof
2025 / January
- Playing to Win Overview
- Willingness to look stupid
- 150 Great Articles & Essays: interesting articles to read online
- Storage is cheap, but not thinking about logging is expensive
- Building a tiny Linux from scratch
- How to Lose Time and Money
- Writing, Briefly
- What You'll Wish You'd Known
- Split Out Unrelated Changes
- how do we set up teams for success?
- How/why to get good at debugging your mind
- fold-… and monoids
- Holding a Program in One's Head
- "Simple Made Easy" - Rich Hickey (2011)
- Try Snapshot Testing for Compilers and Compiler-Like Things
- The 2025 AI Engineer Reading List
- HOWTO: Control yourself
- Not every user owns an iPhone
- Flattening ASTs (and Other Compiler Data Structures)
- Dual N-Back
- Operating System in 1,000 Lines - Intro
- Queues Don't Fix Overload
- 🏆 How I'm advancing my career without neglecting my life. "New year's resolutions" done right.
- Can we use this index, please? – Why not?
- The magic of metalinguistic programming The magic of metalinguistic programming
2024 / December
- Examining Intel's Arrow Lake, at the System Level Examining Intel's Arrow Lake, at the System Level
- Basic Awareness in Addition to Deep Understanding
- That's Not an Abstraction, That's Just a Layer of Indirection
- About 40 hours (23 min. read)
- Here's What the Fight For Your Attention Really Looks Like
- Use of Time in Distributed Databases (part 2): Use of logical clocks in databases
- USB-C head-to-head comparison
- I Thought I Found a Bug…
- Against a universal definition of ‘type’ (pdf)
- Lock Files Considered Harmful
- Use of Time in Distributed Databases (part 1)
- A worked example of copy-and-patch compilation
- Andrew Kelley Practical Data Oriented Design (DoD)
- Problem Driven Development
- Formal Methods: Just Good Engineering Practice?
- Post-apocalyptic programming
- Snapshot Isolation vs Serializability
- Goodhart's Law Isn't as Useful as You Might Think
- On btrfs and memory corruption
- Chi-Squared From Fundamentals
- The Martial Art of Rationality
- Bayesian reasoning
- Utilizing highly synchronized clocks in distributed databases
- Parkinson's Law: It's Real, So Use It
- Property-testing async code in Rust to build reliable distributed systems
- An Intuitive Explanation of Bayes's Theorem
- Bayes theorem, and making probability intuitive – by 3Blue1Brown
- How to Lead a More Rational Life with Bayes' Theorem
- Trapped Priors As A Basic Problem Of Rationality
- An Introduction To Bayesian Inference
- SemVer Is Not About You Nov 23, 2024
- Database mocks are just not worth it
- A Tricycle of the Mind
- Software Design is Knowledge Building
- The road to Emacs maximalism
- Technical Debt is Entropy In Software
- On Ada's Dependent Types, and its Types as a Whole
- Intel's $475 million error: the silicon behind the Pentium division bug
- Morris Chang and the Origins of TSMC - by Brian Potter Morris Chang and the Origins of TSMC
- Implementing and Verifying "Static Program Analysis" in Agda, Part 1: Lattices
- Reads causing writes in Postgres
- Server-Sent Events (SSE) Are Underrated
- seconds since the Epoch
- Twelve Virtues of Rationality
- Deliver the Bare Minimum
- On long term software development: caring (enough) about the future
- How bloom filters made SQLite 10x faster
- Ideas from "A Philosophy of Software Design"
- Nix is a build system
- The Canva outage: another tale of saturation and resilience
- UIs Should Be Versioned, Just Like We Version APIs
- Notes From Figma II: Engineering Learnings
- Turing Machines
- Pragmatic Category Theory | Part 1: Semigroup Intro
- Energy Cheat Sheet - by Brian Potter - Construction Physics Energy Cheat Sheet
- An Introduction to Residuality Theory - Barry O'Reilly - CPH DevFest 2024
- Pushing AMD’s Infinity Fabric to its Limits Pushing AMD’s Infinity Fabric to its Limits
- "Performance Matters" by Emery Berger
- (Mostly) Deterministic Simulation Testing in Go
- (1) How We Built a Self-Healing System to Survive a Terrifying Concurrency Bug At Netflix How We Built a Self-Healing System to Survive a Terrifying Concurrency Bug At Netflix
- How We Got the Lithium-Ion Battery - by Brian Potter How We Got the Lithium-ion Battery
- Your lying virtual eyes
- Telling Stories in Athenian Law
- Ask HN: How do you improve your writing?
- I Don’t Use Monads
- Feel, don't think
- Time Tracking in Obsidian
- Common Misconceptions about Compilers
- Networking For People Who Don't Network
- Confusing or misunderstood topics in systems programming: Part 0
- GitHub - facundoolano/software-papers: 📚 A curated list of papers for Software Engineers
- Implementing Raft: Part 0 - Introduction
- Why Does Ozempic Cure All Diseases? - by Scott Alexander Why Does Ozempic Cure All Diseases?
- OhHelloAna.blog
- Lou's Pseudo 3d Page
- Distributed Erlang
- A CAP tradeoff in the wild
- In Search of an Understandable Consensus Algorithm
- Distributed Systems Horror Stories: Kubernetes Deep Health Checks
- Lectures on Relational Algebra
- Modern Hardware for Future Databases
- Dependent Types and the Art of HTTP Headers
- The Structure of a Worldview - by Regan The Structure of a Worldview
- On the Relationship Between Static Analysis and Type Theory
- The disaggregated write-ahead log
- A Roadmap to Security Game Testing: Finding Exploits in Video Games
- Model checking safety of Ben-Or's Byzantine consensus with Apalache
- A Map of Sync
- Optimizers: The Low-Key MVP
- How Public Key Cryptography Really Works | Quanta Magazine
- Implementing Type Systems as Macros
- Principles of Dependent Type Theory
- Data Replication Design Spectrum
- PSA: Most databases do not do checksums by default
- Extending MVCC to be serializable, in TLA+
- CAP is Good, Actually
- lorentz app
- The Prequel to SQL is SEQUEL
- Viewstamped Replication Revisited
- Transaction Isolation in Postgres, explained
- Two-phase commit and beyond
- The Soul of an Old Machine: Revisiting the von Neumann Architecture
- SQLite Index Visualization: Search
- Using Nix to Try Tools
- Building a distributed log using S3 (under 150 lines of Go)
- Disillusioning the Magic of the fork System Call Disillusioning the Magic of the fork System Call
- Quake 3 Source Code Review: Network Model (Part 3 of 5) >>
- Analytics-Optimized Concurrent Transactions
- Playground Wisdom: Threads Beat Async/Await
- An Overview of Distributed PostgreSQL Architectures
- Understanding Round Robin DNS - by Zsolt Ero Understanding Round Robin DNS
- Herding elephants: Lessons learned from sharding Postgres at Notion
- Chapter on TLA+ - Software Specification Methods
- A Brief Introduction to Linear Types
- Checking linearizability in Go
- Real-Time Model Checking is Really Simple
- What To Use Instead of PGP
- How LLMs work
- LevelDB Explained - How to Analyze the Time Complexity of SkipLists?
- githublog/2024/11/1/sending-an-ethernet-packet.md at main · francisrstokes/githublog · GitHub
- Why I Will Always Be Angry About Software Engineering
- One thought on “Reading the Generalized Isolation Level Definitions paper with Alloy”
- Exploring Postgres's arena allocator by writing an HTTP server from scratch
- Data Modeling with Sums and Products
- Mitigation
- An introduction to thinking about risk
- Why is it so hard to buy things that work well?
- Bypassing regulatory locks, Faraday cages and upgrading your hearing
- The Importance of Saying "Oops"
- The Monads Hurt My Head — But Not Anymore
- one big choice shapes a hundred more
- How to Grow Professional Relationships
- The Art of Long-Term Thinking in a Short-Sighted World
- Local Optimizations Don't Lead to Global Optimums
- Read, Write, Execute
- Sensibly Default
- Compilers: Incrementally and Extensibly
- Predictive Scaling in MongoDB Atlas, an Experiment
- How Good Are American Roads?
- Hey, wait – is employee performance really Gaussian distributed??
- 𝔇𝔢𝔱𝔢𝔯𝔪𝔦𝔫𝔦𝔰𝔱𝔦𝔠 𝔰𝔦𝔪𝔲𝔩𝔞𝔱𝔦𝔬𝔫 𝔱𝔢𝔰𝔱𝔦𝔫𝔤
- Pessimistic or Optimistic Concurrency Control? Lessons Learned from Real-World Customer Scenarios
- Category Theory in Programming
- Crash Course on Notation in Programming Language Theory
- 7 Databases in 7 Weeks for 2025
- How to Study Mathematics
- The Meditation on Curiosity
- Evolving my ergonomic setup (or, my laptop with extra steps)
- SQLite Index Visualization: Structure
- Work hard
- A Smart Bear » Failure to face the truth
- Going a Little Further
- Don't miss the next article.
- IBM RISC System/6000 Family
- What implementation-independent test file formats exist for language tooling?
- Fairness in TLA+
- Parents & Owners in React: Data Flow
- How to do distributed locking
- >>> 2024-02-11 the top of the DNS hierarchy (PDF)
- asatarin/testing-distributed-systems: Curated list of resources on testing distributed systems
- Learning and reviewing system internals: tactics and psychology
- Lamport clocks
- Understanding the BM25 full text search algorithm
- Jan 14 A career ending mistake
2024 / November
- Property-based Testing Patterns
- 6 things I wish I knew the day I started Berklee
- Build your own SQLite
- It's ok to be afraid
- Building Databases over a Weekend
- The Need to Explain
- How Often Should We Sharpen Our Tools?
- Choosing What To Read
- Zero Disk Architecture
- Configuring VSCode with Nix on macOS
- User Interface with Ant Tweak Bar
- Petnames: A humane approach to secure, decentralized naming
- my blogging setup is my writing process
- Grammars, parsing, and recursive descent
- How I configure my Git identities
- The Catastrophe of Shiny Objects
- The only computer science book worth reading twice?
- PlayStation 2 Architecture
- The Lost Reading Items
- Doing more than one thing at a time: how do computers runm multiple independent programs
- Managing High Performers
- A Smart Bear » A life-changing challenge guided by Pascal’s Wager
- Why you're bad at giving feedback
- Eventually consistent plain text accounting
- The Lying p Value
- The Universe of Discourse
- Thoughts on Meaning and Writing
- # on shortification of "learning"
- Every Transaction Matters
- TLA from first principles
- [yap transcript] On first principles thinking
- Why I don’t like discussing action items during incident reviews
- If you don’t examine what worked, how will you know what works?
- How should I read type system notation?
- How Complex Systems Fail
- Userland Disk I/O
- PSA: SQLite does not do checksums
- A mental model for Linux file, hard and soft links
- Rust versions of TAPL's System F and System F-omega type checkers
- Probability for Computer Scientists
- It's About the Guarantees
- Pattern: Event sourcing
- Pattern: Saga
- Logging Guide
- Why I use TLA+ and not(TLA+): Episode 1
- Smolderingly fast b-trees
- Sensors and gauges - Observability in distributed systems
- How Not to Disagree
- What Can You Learn from Photographing Your Life? | The New Yorker
- How we shrunk our Javascript monorepo git size by 94%
- Five Common Misconceptions About Event-Driven Architecture
- Be Suspicious of Success
- Table of Contents
- Observability 101: Terminology and Concepts
- Getting Started with OpenTelemetry Visualization - A Practical Guide
- Setting Up Prometheus, Grafana, Loki, Tempo & Mimir for end-to-end Monitoring & Logging Atmosly
- Prometheus 101: Metrics, Monitoring, Practical Setup and More
- Monitoring Your Apps in Kubernetes Environment with Prometheus
- Linearizability in distributed systems
- Crushing Castlevania with Antithesis
- Building A Strong Ownership Culture in A Team
- Bias For Action
- On Good Software Engineers
- Damas-Hindley-Milner inference two ways
- On the cruelty of really teaching computing science
- Can't trust any VPN these days
- Sets, types and type checking
- Surfing Complexity
- Multi-version concurrency control in TLA+
- Computer Organization E-book by Stephen Marz
- Getting Big Things Done
2024 / October
- How Do You Spend Your Time?
- Solving the Mystery of ARM7TDMI Multiply Carry Flag
- Abstract Machines of Systems Biology
- Founder Mode for Non-Founders · Daniel Mangum
- School is Not Enough - by Simon Sarris
- stormrider
- Using static websites for tiny archives – alexwlchan
- A Commentary on Defining Observability
- Writes and Write-Nots
- ADHD and Managing Your Reputation - by Vaishnav Sunil
- Canvas Fingerprinting - BrowserLeaks
- The Basics - by Thorsten Ball - Register Spill
- How do Graphics Cards Work? Exploring GPU Architecture
- Queuing Theory Tutorial
- Understanding DNS resolution on Linux and Kubernetes
- Whence '\n'? – Casey Rodarmor's Blog
- On the Importance of Typing Fast | rugu
- S-38.3143 Queueing Theory (5 ECTS) L
- Building and scaling Notion’s in-house data lake
- Learning to learn | K/L
- Google Testing Blog: SMURF: Beyond the Test Pyramid
- What docs as code really means | passo.uno :: Fabrizio Ferri-Benedetti on Technical Writing
- start - TLA+ Wiki
- Distributed Systems Reading List
- Cognitive load
- Which kernel is the most readable one? | Lobsters
- On accountability | A Working Library
- Accountability sinks | A Working Library
- start - TLA+ Wiki
- Focus on decisions, not tasks
- A liveness example in TLA+ – Surfing Complexity
- Books
- Web Browser Engineering
- NTAPI Undocumented Functions
- RescueTime - Your Weekly dashboard
- Error Handling in a Correctness-Critical Rust Project | sled-rs.github.io
- sled book shop | sled-rs.github.io
- Why do systems fail? Tandem NonStop system and fault tolerance
- Let the network tell you where you are: a nerd snipe story
- How to convince engineers that formal methods is cool • Buttondown
- Build Systems, Not Heroes
- A Dictionary of Single-Letter Variable Names | Blog | jackkelly.name
- Learning By Writing — LessWrong
- Sequences Highlights — LessWrong
- brutalist-manifesto
- How I manage my dotfiles · Jamie Tanna | Software Engineer
- rust-gpu.github.io
- No Feedback ∴ No Good
- Monty Anderson
- An Illustrated Proof of the CAP Theorem
- The Problem With Building Good Habits | Stephan Joppich
- Two Workflow Tips
- There is No Now - ACM Queue
- The Writings of Leslie Lamport
- LEGO IDEAS - Working Turing Machine
- CRDTs go brrr
- 15 rules for blogging, and my current streak (Interconnected)
- Patterns for Personal Web Sites
- Search for Charts by Data Visualization Functions
- Why TCP needs 3 handshakes | PixelsTech
- Welcome to Linux From Scratch!
- TCP Server in Zig - Part 1 - Single Threaded
- Terminal colours are tricky
- Programmer's Guide | C64 OS
- Magic isn’t real - Inside thoughts
- Why is the Speed of Light So Fast? (Part 1)
- bytecode interpreters for tiny computers ⁑ Dercuano
- How to train a model on 10k H100 GPUs?
- Integrity Constraints and the Relational Derivative • Buttondown
- Being who you are, while becoming better
- Pivot Points
- William Cotton
2024 / September
- Introduction to the λ-calculus
- How Discord Stores Trillions of Messages
- glouw/c8c: The chip8 compiler, assembler, and virtual machine
- Refactoring Invariants • Buttondown
- Alpha Conversion | Kevin Sookocheff
- XXIIVV — goals
- The guide to implementing 2D platformers | Higher-Order Fun
- Wealth = Have ÷ Need | Derek Sivers
- Raft
- Tensor Labbet · A blog of deep learnings
- Be someone who does things | notes.eatonphil.com
- Linearizability! Refinement! Prophecy! – Surfing Complexity
- Go To Statement Considered Harmful
- How not to be boring - PostHog
- Applied Mathematical Programming
- Informal History Of Programming Ideas
- Visual guide to SSH tunneling and port forwarding - ITTAVERN.COM
- A gentle guide to self-hosting your software | ᕕʕ •ᴥ•ʔ୨ Shank Space
- Books - Computing History
- Code Reviews Do Find Bugs
- Chapter 0 Preface — Programming Languages
- NetworkManager or networkd [LWN.net]
- CSCI 181G PO
- My 71 TiB ZFS NAS after 10 years and zero drive failures
- Introduction to the PDP 11, Unit 1, System Overview
- The Lesson to Unlearn
- Object-Oriented
- The Long Road to Fiber Optics - by Brian Potter
- Your customers hate MVPs. Make a SLC instead.
- Going Buildless | Max Böck
- Legacy
- Closures in Zig
- My Homelab Setup
- What’s in an e-graph? | Max Bernstein
- The BITSAVERS.ORG Documents Library : Free Texts : Free Download, Borrow and Streaming : Internet Archive
- "Pushing the Limits of Web Browsers" by Lars Bak (2012)
- Erasure Coding for Distributed Systems
- Constraining writers in distributed systems
- How does it feel to test a compiler? | by Alexander Zakharenko | Jul, 2024 | Medium
- Practices of Reliable Software Design
- B-trees and database indexes
- What to Do When You Forget Your Root Password – Tookmund – A place for my random thoughts about software
- What I Gave Up To Become An Engineering Manager
- Explore AMX instructions: Unlock the performance of Apple Silicon | by 郑启航 | Sep, 2024 | Medium
- Feynman Algorithm
- Programming languages resources | Max Bernstein
- Implementing HanoiDB - Session 1: Introduction
- Linux's Bedtime Routine – Tookmund – A place for my random thoughts about software
- ATProto for distributed systems engineers - AT Protocol
- Taming Consensus in the Wild (with the Shared Log Abstraction)
- DNS "propagation" is actually caches expiring
- The Fundamental Law Of Software Dependencies
- Why is Browser Observability Hard | Hazel Weakly
- Programming with Lambda Calculus
- Founder Mode
- On distributed systems | Distributed Systems by Szymon Durak
- Thoughts on "The Future of TLA+" • Buttondown
- Typed Lambda Calculus / Calculus of Constructions
- Dick Grune's Annotated Literature Lists
- The Art of Finishing | ByteDrum
- Ask HN: Resources for GPU Compilers? | Hacker News
- Opinions for Writing Good CSS
- Full Text, Full Archive RSS Feeds for any Blog | DOGESEC
- Notes/Primer on Clang Compiler Frontend (1) : Introduction and Architecture - Youssef Ateya
- Authenticated Boot and Disk Encryption on Linux
- What is Table-Oriented Programming? :: Table-Oriented Programming (TOP)
- August 2024 Time Tracking
- Neurotechnology Numbers Worth Knowing
- A new cycle-stepped 6502 CPU emulator
- Putting a meaningful dent in your error backlog – Dan Slimmon
- Zig and Emulators
- Essays: NSA Surveillance: a Guide to Staying Secure - Schneier on Security
- My Software Bookshelf | olano.dev
2024 / August
- State and time are the same thing • Buttondown
- How much of success is luck?
- How to sync Mac and Linux /home | Derek Sivers
- Distributed systems theory for the distributed systems engineer | Paper Trail
- Notes on Distributed Systems for Young Bloods – Something Similar
- Learning about distributed systems: where to start?
- Best resources to learn about data and distributed systems - Pierre Zemb
- Database “sharding” came from UO? – Raph's Website
- Rachel Thomas, PhD - Your Immune System is Not a Muscle
- Fix the machine, not the person (Aaron Swartz's Raw Thought)
- Cherish mistakes (Aaron Swartz's Raw Thought)
- Confront reality (Aaron Swartz's Raw Thought)
- Predicting the Future of Distributed Systems
- You Are NOT Dumb, You Just Lack the Prerequisites
- Self-hosting DNS - GHOST
- How SSH Secures Your Connection :: Noratrieb's blog
- B-trees
- A ToC of the 20 part linker essay [LWN.net]
- Ethernet History Deepdive – Why Do We Have Different Frame Types? – Daniels Networking Blog
- Home
- Obsession | notes.eatonphil.com
- Applying Books in My Life - TK • Newsletter
- Lean into the pain (Aaron Swartz's Raw Thought)
- Look at yourself objectively (Aaron Swartz's Raw Thought)
- Practices of Reliable Software Design
- What I Learned Working For Mark Zuckerberg - Noah Kagan
- How to write.
- Late Again – Rands in Repose
- naklecha/llama3-from-scratch: llama3 implementation one matrix multiplication at a time
- How to avoid losing items? Holding pens. | Alex W.'s Blog
- Efficient and Insightful Generalization
- The Art of Learning - TK • Newsletter
- The Compiler Writer Resource Page
- HTTP/1.0 From Scratch
- HTTP/0.9 From Scratch
- Crafting Interpreters with Rust: On Garbage Collection | Tung Le Vo
- A Visual Guide to Quantization - by Maarten Grootendorst
- Higher-kinded Bounded Polymorphism
- Examples of Great URL Design - Jim Nielsen’s Blog
- Visual Data Structures Cheat-Sheet - by Nick M
- Ask HN: What are some "toy" projects you used to learn neural networks hands-on? | Hacker News
- Some Books I Like // One Year of NULL BITMAP • Buttondown
- How we tamed Node.js event loop lag: a deepdive | Trigger.dev
- The Illustrated QUIC Connection: Every Byte Explained
- Monitoring Node.js: Watch Your Event Loop Lag! - David Hettler 🥨
- Adam Keys is Thinking - Methods of production
- Tales of the M1 GPU - Asahi Linux
- SNES: Sprites and backgrounds rendering
- WebGPU Unleashed: A Practical Tutorial
- Hacking a Virtual Power Plant | rya.nc
- Ray Tracing Harmonic Functions
- Peter DaSilva/The New York Times/Redux
- Do Quests, Not Goals
- Learning & The Power of the First Step - TK • Newsletter
- How to talk to your parents about hardware memory safety | CHERIoT Platform
- React Compiler, How Does It Work? [1] - Entry Point through Babel Plugin | 장용석 블로그
- There is no mystery over who wrote the Blue Screen of Death, despite what some may want you to believe - The Old New Thing
- x86re
- The algebra (and calculus!) of algebraic data types
- Vector Clocks Explained
- EMUBook
- On writing | What's new
- Practical Math: My Journey from Idea to Application | Happiness Machines
- DRMacIver's Notebook: Asymmetric vices and the unity of virtue
2024 / July
- Creativity Fundamentally Comes From Memorization
- Lysxia - Where does the name "algebraic data type" come from?
- Elements kinds in V8 · V8
- How I Computer in 2024 · Jon Seager
- Adam Keys is Thinking - The (Leadership) Discipline
- Advice to the young
- The Hitchhiker's Guide to Logical Verification
- Art of Assembly Language, PDF Files
- Motivation
- The Documentation Tradeoff - by Kent Beck
- How to Compile Your Language
- The Four Theories of Truth as a Method for Critical Thinking - Daniel Imfeld
- Simple event broker tries Tiger Style
- Math 331 Reading Guides
- Complex systems emerge from simple rules
- #001 - Abraçando o caminho sem volta - Insight Espresso
- A weekend's (re)reading list | Ludwig
- Plain text journaling | ᕕ( ᐛ )ᕗ Herman's blog
- soulmachine/machine-learning-cheat-sheet: Classical equations and diagrams in machine learning
- Understanding_digital_signal_processing
- Story: Redis and its creator antirez | Brachiosoft Blog
- Not Just Scale - Marc's Blog
- Forget “show, don’t tell”. Engage, don’t show! • Lea Verou
- Learning about PCI-e: Driver & DMA
- Philosophy of How to Learn
- Database Indexes & Phone Books - by Thorsten Ball
- Consensus
- Taking my diabetes treatment into my own hands | Martin Janiczek
- Calculus for Beginners
- kiennt26's home | Linux Network Performance Ultimate Guide
- Let's Consign CAP to the Cabinet of Curiosities - Marc's Blog
- sigtt611-bernstein
- Introduction · Reverse Engineering
- Rediscovering Transaction Processing From History and First Principles
- advanced-linux-programming
- Ray Tracing in One Weekend Series
- Startup Finance for Founders — Part I, Accounting by Peter Reinhardt
- Tools + Techniques for Procedural Gamedev - Casey Primozic's Homepage
- My OBTF Workflow & Bash Script
- When Then Zen
- How Simultaneous Multithreading Works Under the Hood
- Intro | Putting the "You" in CPU
- lecture18
- First Principles: The Building Blocks of True Knowledge
- Categories of leadership on technical teams | benkuhn.net
- Haskell for all: Software engineers are not (and should not be) technicians
- onceupon/Bash-Oneliner: A collection of handy Bash One-Liners and terminal tricks for data processing and Linux system maintenance.
- Chase Your Reading - by Robin Hanson - Overcoming Bias
- On having more interesting ideas - by Henrik Karlsson
- Build your own SQLite, Part 1: Listing tables
- Structured Procrastination
- Parse, don’t validate
- PostgreSQL triggers and isolation levels - Vlad Mihalcea
- Setting up an x86 CPU in 64-bit mode
- 1989 Networking: NetWare 386 | OS/2 Museum
- why you should write more - by Ava - bookbear express
- Learning LLVM (Part-2)
- Managing Underperformers | Jack Danger
- Computer Architecture : Foundational Reading - by Babbage
- time-clocks
- little-languages
- RFC 677: Maintenance of duplicate databases
- Alternative Technologies
- SQLite Transactions
- The Greatest Educational Life Hack: Learning Math Ahead of Time - Justin Skycak
- Self Hosting 101 - A Beginner's Guide
- VisCircuit - Make Circuits Easy to Learn
- Developing domain expertise: get your hands dirty. | Irrational Exuberance
- Layers of context. | Irrational Exuberance
- How to create software quality. | Irrational Exuberance
- bobbyiliev/introduction-to-bash-scripting: Free Introduction to Bash Scripting eBook
- untitled1.html
- The Backup And Sync Strategy, Revised | Brain Baking
- Keep perfecting your config • Buttondown
- interdb.jp
- Software Engineering Is Not Engineering | Brain Baking
- How to Create a Liquid Raymarching Scene Using Three.js Shading Language | Codrops
- sbensu: We need visual programming. No, not like that.
- Jonas Hietala: Microfeatures in my blog
- Bio-digital jazz, man
- Linear Algebra Fundamentals
- Hugo Sidenotes Shortcode :: dade
- On reading about optimizing compilers | Ludwig
- The humble beginning of id Software | Brachiosoft Blog
- Understanding 3D Graphics | Azeem Bande-Ali | azeemba.com
- The Hazardous Life of an Undersea Cable
- How and why we built our startup around small teams
- Where Did Combinators Come From? Hunting the Story of Moses Schönfinkel—Stephen Wolfram Writings
- A Race to the Bottom - Database Transactions Undermining Your AppSec · Doyensec's Blog
- An Incremental Approach to Compiler Construction
- Beating the L1 cache with value speculation
- A malleable garden
- The microarchitecture of Intel and AMD CPUs
- O tal do Isolamento no A.C.I.D. - Alen Vieira
- Matrix Theory of Mind - by Thorsten Ball - Register Spill
- Three important steps before jumping to the code
- Trust as a bottleneck to growing teams quickly | benkuhn.net
- CSS GPU Animation: Doing It Right — Smashing Magazine
- Adam Keys is Thinking - Journal, highlight, revisit, blog
- Superbabies: Putting The Pieces Together — LessWrong
- 89 things I know about Git commits · Jamie Tanna | Software Engineer
- Use A Work Journal To Recover Focus Faster And Clarify Your Thoughts
- WebGPU Fundamentals
- Agda by Example: λ-calculus
- The Forth Methodology of Charles Moore by Jeff Fox 12/09/01
- Let's reproduce GPT-2 (1.6B): one 8XH100 node, 24 hours, $672, in llm.c · karpathy/llm.c · Discussion #677
- Why I’m Writing A Book On Cryptography
- Welcome … — Physics-based Deep Learning
- lorin/systems-reading: Systems and failure reading list
- time-clocks
- Deep-ML
- MathPages
- Scoped Propagators
- The Architecture of Open Source Applications
- The Architecture of Open Source Applications (Volume 1)Berkeley DB
- Adam Keys is Thinking - Slash pages & micro-features
- The Right Kind of Stubborn
- Build your own React
- Magical Music Theory Tools to Learn Music Online for Free
- A Git story: Not so fun this time | Brachiosoft Blog
- Why you need a "WTF Notebook"
- Notes for new hires | Clinton Blackburn
- How we designed our company for speed - PostHog
- Robin Rendle — Creativity is the byproduct of work
- Serving a billion web requests with boring code - llimllib notes
- Synchronization is bad for scale
- Modeling B-trees in TLA+ – Surfing Complexity
- Learning By Writing
- Be patient with problems - by Henrik Karlsson
- How to think in writing - by Henrik Karlsson
- Dirty writes – Surfing Complexity
- doceamus-edu-sweller.indd
- How I use Obsidian - macwright.com
- How I Use Obsidian – Matt Stein
- How to implement a hash table (in C)
- Properly Testing Concurrent Data Structures
- What every systems programmer should know about concurrency
- A TUTORIAL ON POINTERS AND ARRAYS IN C
- Trying Kolmogorov-Arnold Networks in Practice - Casey Primozic's Homepage
- Reverse Engineering the Verification QR Code on my Diploma
- Lensy Moore
- The sad state of property-based testing libraries
- Every website and web app should have a service worker | Go Make Things
- NMI_Review
- Neo Geo Architecture | A Practical Analysis
- The Joy of Reading Books You Don't Entirely Understand - Reactor
- full-issue
- Alexander Gromnitsky's Blog :: 2024-07-01 :: The cheapest NAS
- Good and Bad Procrastination
- Don't End The Week With Nothing
- Falsehoods Software Developers Believe About Event-Driven Systems · Blog · Loïc Carr
- Programmers Should Never Trust Anyone, Not Even Themselves
- Elaboration of the PostgreSQL sort cost model
- My programming beliefs as of July 2024
- Measuring personal growth
- "Simple Made Easy" - Rich Hickey (2011)
- A write-ahead log is not a universal part of durability | notes.eatonphil.com
2024 / June
- An Experienced (Neo)Vimmer's Workflow
- A snapshot isolated database modeling in TLA+
- TLA+ modeling of a single replicaset transaction modeling
- The Work Life of Developers: Activities, Switches and Perceived Productivity
- Introduction | Bmg documentation
- Writing is a technology that restructures thought
- Hermitage: Testing the “I” in ACID — Martin Kleppmann’s blog
- What is a CIDR trie and how can it help you? · blog | sven kanoldt
- Understanding React Compiler | Tony Alicea
- Implementing SHA-256 on the 6502 | Bumbershoot Software
- How much memory does a call to ‘malloc’ allocates? – Daniel Lemire's blog
- malloc
- Malloc_tutorial
- Modern cryptography on the NES - Super Tilt Bro. for NES by sgadrat
- How to evolve a product | Granola
- Fast · Patrick Collison
- zine-ali
- Differential Analysis: A Summary
- Marcus' Blog
- What Should You Do with Your Life? Directions and Advice - Alexey Guzey
- You probably wrote half a monad by accident – Andy G's Blog
- making regex from scratch in GO - Lewis Metcalf
- Working hurts less than procrastinating, we fear the twinge of starting — LessWrong
- Ordinary Incompetence · Gwern.net
- Inside the tiny chip that powers Montreal subway tickets
- Classic Papers in Programming Languages and Logic
- leandromoreira/digital_video_introduction: A hands-on introduction to video technology: image, video, codec (av1, vp9, h265) and more (ffmpeg encoding). Translations: 🇺🇸 🇨🇳 🇯🇵 🇮🇹 🇰🇷 🇷🇺 🇧🇷 🇪🇸
- Virtualization Internals Part 1 - Intro to Virtualization | Saferwall
- Reversing Choplifter – Blondihacks
- How terminal works. Part 1: Xterm, user input | Thoughts-chain
- Hacking Millions of Modems (and Investigating Who Hacked My Modem)
- Database anomalies and isolation levels |
- Using d8 · V8
- Understanding V8's Bytecode
- Say Hello to 1-based indexing in JavaScript!
- Terms, types, and functions
- Microfeatures I Love in Blogs and Personal Websites
- Becoming a go-to person gets you promoted. Here's how to do it as a software engineer.
- How to Test
- The Unix and Internet Fundamentals HOWTO
- Reflections on a decade of coding
- antoniosarosi/mkdb: Toy Database
- Writing My Own Database From Scratch
- Hitting the High Notes – Joel on Software
- Effective Spaced Repetition
- A Distributed Systems Reading List
- The Hitchhiker's Guide to the Unexpected
- Introduction - Habitual Mastery (Series) - Scott H Young
- Why Forgetting Can Be Good - Scott H Young
- Spaced Repetition for Efficient Learning · Gwern.net
- Counted B-Trees
- karpathy/LLM101n: LLM101n: Let's build a Storyteller
- Let's write a video game from scratch like it's 1987
- 500 Lines or LessAn Archaeology-Inspired Database
- Ownership
- A complete guide to iconography
- How to Overcome Plateaus - Learn How To Learn
- Cheng Lou - "On the Spectrum of Abstraction" summarized transcript (React Europe 2016)
- Arbitrariness Costs
- Decision Brownouts
- Start With Simple Tools
- Always Measure One Level Deeper – Communications of the ACM
- Always Measure One Level Deeper
- Programmers should stop celebrating incompetence
- Richard Hamming: You and Your Research
- Ship something every day
- A few words on taking notes | All Things Distributed
- Simple sabotage for software · Erik Bernhardsson
- Internet Search Tips · Gwern.net
- (1) Do Ten Times as Much - by Bryan Caplan - Bet On It
- (1) So you wanna de-bog yourself - by Adam Mastroianni
- On Having Enough Socks · Gwern.net
- The simple genius of checklists, from B-17 to the Apollo missions | Inside Nuclino
- Don’t Shave That Yak! | Seth's Blog
- 2000-cook
- Useful and Overlooked Skills · Collab Fund
- The Law of Leaky Abstractions – Joel on Software
- The Book of Shaders
- Exponentially Better Rotations
- Scratchapixel 4.0, Learn Computer Graphics Programming
- Accounting for Developers, Part I | Modern Treasury Journal
- Complex Analysis
- On Seeing Through and Unseeing: The Hacker Mindset · Gwern.net
- Experts vs. Imitators
- Confusion is a muse | notes.eatonphil.com
- How I Cured My Procrastination - Learn How To Learn
- Never, Sometimes, Always - lukeplant.me.uk
- Ray Tracing in One Weekend
- NULL BITMAP Builds a Database #1: The Log is Literally the Database • Buttondown
- Making USB devices - end to end guide to your first gadget
- Mediocre Engineer’s guide to HTTPS
- Things you wish you didn't need to know about S3
- staniks.github.io
- Notational intelligence | thesephist.com
- Proxmox vs FreeBSD: Which Virtualization Host Performs Better? - IT Notes
- Legend of Worlds
- Build Your Own X
- Data Modeling in Document Databases for the RDBMS-Minded
- A (Draft) Taxonomy of SIMD Usage – Branch Free
- Learn OpenGL, extensive tutorial resource for learning Modern OpenGL
- Regular, Recursive, Restricted
- Feynman's Razor - by Defender of the Basic
- What Color is Your Function? – journal.stuffwithstuff.com
- Biohacking Lite
- Work hard and take everything really seriously - macwright.com
- Productivity Versus Alignment
- Systems: The Purpose of a System is What It Does - Anil Dash
- The Design Space of Wikis
- CRDT: Text Buffer - Made by Evan
- Be findable - by Thorsten Ball - Register Spill
- https://segment.com/blog/when-aws-autoscale-doesn-t/
- Cultures of writing. - by Karina Nguyen - sémaphore
2024 / May
- Developers aren't Nerds | 0xFF
- Functional TypeScript #1: Algebraic Data Types
- Writing a Unix clone in about a month
- In the beginning… was the command line | thesephist.com
- Feynman's Garden @ marginalia.nu
- No Wrong Doors. | Irrational Exuberance
- Evolution of the ELF object file format | MaskRay
- Old Dogs, new CSS Tricks | Max Böck
- Doing is normally distributed, learning is log-normal | Andrew Quinn's TILs
- Queueing – An interactive study of queueing strategies – Encore Blog
- How Far Can I Legally Make a Scheduled I Substance?
- Megaparsec tutorial
- Ilya 30u30
- Write yourself a Git!
- The Back-to-Basics Readings of 2012 | All Things Distributed
- The Power of the Marginal
- A Road to Common Lisp / Steve Losh
- Tools That Make You Feel Empowered
- Semantic note-taking | cceckman, from the Internet
- A New Way to Store Knowledge
- Guide: How to start a writing habit
- What I look for in empirical software papers • Buttondown
- The Misunderstood Stoic
- Structured Procrastination
- How and why to make a /now page on your site | Derek Sivers
- Pmarchive · Pmarca Guide to Personal Productivity
- So we built a Reverse Tunnel in Go over HTTP/3 and QUIC | Flipt Blog
- Kim Young Jin - Ambitious but at peace
- From Any Spot on the Field - by Thorsten Ball
- Reading C type declarations
- Implementing MVCC and major SQL transaction isolation levels | notes.eatonphil.com
- Bye Opam, Hello Nix | Emil Privér
- ISP Column - April 2024
- GPUs Go Brrr · Hazy Research
- Professional corner-cutting : Havoc's Blog
- Exploring Hacker News by mapping and analyzing 40 million posts and comments for fun | Wilson Lin
- How NASA is Hacking Voyager 1 Back to Life - IEEE Spectrum
- Visualization Mnemonics for Software Principles - DaedTech
- pal-iii : Digital Equipment Corporation : Free Download, Borrow, and Streaming : Internet Archive
- ISP Router Design Mistakes | Brain Baking
- Safety and Liveness Properties
- Bollards: Why & What · Josh Thompson
- How to style React applications while the world burns around us | Herb Caudill
- Chris's Wiki :: blog/tech/UEFIAndBIOSAndOtherPCTerms
- "Integration tests" are just vibes • Buttondown
- The Time Linkerd Erased My Load Balancer
- My favorite teacher - by Thorsten Ball - Register Spill
- Why Full Text Search is Hard
- How to Build a $20 Billion Semiconductor Fab
- Do Things and Tell People
- Figma’s journey to TypeScript | Figma Blog
- Study of Historical Code | ℤ→ℤ
- Tracking the Wins
- Abstract Heresies: Statements and Expressions
- Ansible is a Lisp
2024 / April
- Bytecode VMs in surprising places
- Constraints on giving feedback. | Irrational Exuberance
- Inside the Super Nintendo cartridges
- Staring into the abyss as a core life skill | benkuhn.net
- Learn one thing at a time | Lawrence Jones
- tsouanas/fmcbook: Matemática Fundacional para Computação: book by Thanos Tsouanas (in portuguese)
- kenjihiranabe/The-Art-of-Linear-Algebra: Graphic notes on Gilbert Strang's "Linear Algebra for Everyone"
- Operable Software
- Finding Fulfillment
- Wisdom from Marcus Aurelius - by Gurwinder - The Prism
- adam-maj/tiny-gpu: A minimal GPU design in Verilog to learn how GPUs work from the ground up
- "Thought loss anxiety" is the fear of forgetting good ideas due to lack of good record-keeping
- Other people’s problems | Seth's Blog
- The Man Who Killed Google Search
- Good Ideas in Computer Science ・ Daniel Hooper
- On Opening Essays, Conference Talks, and Jam Jars
- Visualizing Algorithms
- 50 Years Later, This Apollo-Era Antenna Still Talks to Voyager 2 - IEEE Spectrum
- Halo 2 in HD: Pushing the Original Xbox to the Limit – I Code 4 Coffee
- Parsing and all that
- The Technium: 101 Additional Advices
- Stop Acting Like You're Famous
- Tips on how to structure your home directory
- The Guide to Stock Options conversations - by Anton Zaides
- 3 important things I overlooked during code reviews | Piglei
- Linux text manipulation
- Formal Methods: Just Good Engineering Practice? - Marc's Blog
- oss-security - Make your own backdoor: CFLAGS code injection, Makefile injection, pkg-config
- About the author
- Incomplete List of Mistakes in the Design of CSS [CSS Working Group Wiki]
- The Psychology of Liminal Spaces
- 12 Map Happenings that Rocked our World: Part 9 – Map Happenings
- What makes concurrency so hard? • Buttondown
- A Visual Guide to Vision Transformers | MDTURP
- RECOMMENDED DESIGN BOOKS/FILMS – How Design MAKES THE WORLD (The book)
- Double-Entry Bookkeeping as a Directed Graph · Matheus Portela
- Discrete logic IC CPU | Ivan's blog
- An IRC client in your motherboard | Phillip Tennen
- What makes a great technical blog | notes.eatonphil.com
- Do you really need IPv4 anymore?
- How to send progress updates - Slava Akhmechet
- If Inheritance is so bad, why does everyone use it? • Buttondown
- How I significantly improved my sleep schedule - Issa Rice
- My favorite technical blogs
- My new home server · g/ianguid/o.today
- Garbage Collection for Systems Programmers
- Optimizing Javascript for fun and for profit
- Here is why vim uses hjkl keys as arrow keys
- Why the “Eisenhower matrix” is a fantastic productivity hack - Big Think
- My list of challenging software projects some programmers should try | andreinc
- Building My First Homelab Server Rack · mtlynch.io
- The hearts of the Super Nintendo
- great_tables - The Design Philosophy of Great Tables
- Advice to Young People, The Lies I Tell Myself - jxnl.co
- Visualizing the ARM64 Instruction Set | Zachary Yedidia's blog
- lizrice/containers-from-scratch: Writing a container in a few lines of Go code, as seen at DockerCon 2017 and on O'Reilly Safari
- Subroutine calls in the ancient world, before computers had stacks or heaps - The Old New Thing
- You Don’t Need a Writing Ritual
- Book list for streetfighting computer scientists - dankwiki, the wiki of nick black
- Everything I Know About SSDs 2019
2024 / March
- Type system of the React compiler
- Basic Things
- Why Mathematics is Boring | The n-Category Café
- The problem with invariants is that they change over time – Surfing Complexity
- Think real hard | benkuhn.net
- Be impatient | benkuhn.net
- Things you're allowed to do
- Deterministic Simulation Testing | Resonate
- Linux Crisis Tools
- Sega Saturn Architecture | A Practical Analysis
- ADHD Productivity Fundamentals — 0xFF
- Tech Independence | Derek Sivers
- So you think you want to write a deterministic hypervisor?
- #7 - On Keeping a Notebook | Kadambari
- Why do regexes use `$` and `^` as line anchors? • Buttondown
- The Beginner’s Guide to Queuing theory | Qminder
- Fail Forward With Kindness / marcel.io
- Doing weeknotes
- myme.no - Focus by Automation
- Decision logs
- Design is an Island - by Kent Beck
- articles/internals_of_the_async_await_pattern_from_first_principles.md at master · Dobiasd/articles
- How to Start Google
- The Mechanics of Proof — The Mechanics of Proof, by Heather Macbeth
- Dobiasd/articles: thoughts on programming
- Leadership requires taking some risk. | Irrational Exuberance
- Take Ownership of Your Future Self
- My favorite essays of life advice | benkuhn.net
- Tecno S8C
- Be Well Tuned
- Redefining Observability | Hazel Weakly
- What are 1-bit LLMs?. The Era of 1-bit LLMs with BitNet b1.58 | by Mehul Gupta | Data Science in your pocket | Mar, 2024 | Medium
- Checking Causal Consistency of MongoDB
- First month on a database team | notes.eatonphil.com
- How Figma's Databases Team Lived to Tell the Scale | Figma Blog
- Nix is a better Docker image builder than Docker's image builder - Xe Iaso
- Learning from DNA: a grand challenge in biology · Hazy Research
- 40 years of programming
- My weekly review habit | benkuhn.net
- Create More Than You Consume if You Want to Worry Less and Feel More Fulfilled — OMAR ITANI
- SQLite Internals: Pages & B-trees · The Fly Blog
- Breaking Down Tasks - Jacob Kaplan-Moss
- CAP is Good, Actually • Buttondown
- “No” Is a Good Default Answer
- Technical Skills Are Overrated. Focus on Your Attitude.
- POV: I'm on my third coffee and you just asked me how the internet works
- How HEAD works in git
- How I read a research paper
- Your attitude determines your success
- Learning a technical subject
- Why I blog
- Coordination Avoidance in Database Systems
- AT&T ARCHIVES AND HISTORY CENTER
- The checklist manifesto (Dr. Atul Gawande, 2009)
- The CAP Theorem. The Bad, the Bad, & the Ugly | Dominik Tornow
- O Juro é negativo após 2008 - by 🟩🟩Trezoitão🟩🟩
- Why (and how) to read books | notes.eatonphil.com
- Reverse Engineering Protobuf Definitions From Compiled Binaries
- Anatomy of a NixOS Config - unmoved centre
- Paul Butler – The hater’s guide to Kubernetes
- A Deep Dive into the Underlying Architecture of Groq's LPU
- Motorola's 6809 : The Best 8-Bit? - by Babbage
- Byte Interviews the Apple Lisa Dev Team (1983)
- Internet gardening | James' Coffee Blog
- Airfoil – Bartosz Ciechanowski
- Inside the miracle of modern chip manufacturing
- How User Groups Made Software Reuse a Reality | ℤ→ℤ
- My thoughts on writing a Minecraft server from scratch (in Bash)
- Building a Scalable Accounting Ledger
- Learn CSS Layout The Pedantic Way
- Understanding GPU caches – RasterGrid
- Demystifying GPUs for CPU-centric programmers | Medium
2024 / February
- OBTF Follow-up
- No one can teach you to have conviction | benkuhn.net
- Shape Up: Stop Running in Circles and Ship Work that Matters
- How I backup | Derek Sivers
- Job titles are bullshit · Jamie Tanna | Software Engineer
- How to change a system (18 ways) – Changeology
- Earth is becoming sentient — Steph Ango
- 2024-02-25 a history of the tty
- Website Refresh 2023
- Roman Jakobson : The Functions of Language / Signo - Applied Semiotics Theories
- Haskell for all: Unification-free ("keyword") type checking
- Compiler Theory and Reactivity
- ego
- Build your own Database Index: part 1
- williamdemeo/TypeFunc: Resources for type theory, functional programming, etc.
- How MOSFETS Work - Unravel the Mysteries of How mosfets Work!
- What I Wish Someone Had Told Me - Sam Altman
- Table of Contents | Ultimate Electronics Book
- Software infrastructure 2.0: a wishlist · Erik Bernhardsson
- DRMacIver's Notebook: Writing good programming abstractions
- Bloom Filters
- Evolution of tree data structures for indexing: more exciting than it sounds · Erthalion's blog
- B+-Tree Indexes
- Fighting undead documentation
- Distributed Logical Time
- An intuition for distributed consensus in OLTP systems | notes.eatonphil.com
- How do you approach reading a paper?
- HOW TO STUDY
- Tunable Consistency in MongoDB
- Teach Yourself Programming in Ten Years
- Demystifying GPU Compute Architectures - by Babbage
- OKRs are Bullshit - by drmorr
- Writing Is Magic - Marc's Blog
- Writing For Somebody - Marc's Blog
- How Do You Spend Your Time? - Marc's Blog
- Why Gödel, Escher, Bach is the most influential book in my life. | by Mark Johnson | Medium
- Idea Generation - Sam Altman
- How Did I Get Here?
- A Brief Summary of Evolutionary Design | CodingItWrong.com