bookmarks.
Last update: 12/10/2025 23:00
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 / October
- Automated Lean Proofs for Every Type
- Examples are the best documentation
- My Approach to Building Large Technical Projects
- Designing a Low Latency 10G Ethernet Core - Part 1 (Introduction)
- 12 thoughts on “How to *actually* test your readme”
- When Money Is Abundant, Knowledge Is The Real Wealth
- 2145 The Importance Of Understanding Systems
- Second-Order Thinking: What Smart People Use to Outperform
- VPS Setup and Security Checklist: Complete Self-Hosting Guide for 2025
- fi-le.net,
- Getting silly with C, part ~(~1<<1)
- The Syndrome of the Ultra-fit
- Weird CPU architectures, the MOV only CPU
- UTF-8 is a Brilliant Design
- Fail Fast
- It Takes Two to Contract
- « A Beginner's Guide to Extending Emacs
- Type Branding in Typescript
- Why We're Building Stategraph: Terraform State as a Distributed Systems Problem
- Many Hard Leetcode Problems are Easy Constraint Problems
- Is GitHub Actions suitable for running benchmarks?
- We have outgrown the Process model
- Folks, we have the best π
- Algebraic Types are not Scary, Actually
- Beyond Orthogonality: How Language Models Pack Billions of Concepts into 12,000 Dimensions
- Claude Can (Sometimes) Prove It
- Mathematical induction
- Why argument structure is important
- Five Ways To Prioritize Better
- Laziness death spirals — LessWrong
- My Algorithm for Beating Procrastination
- Full list of what made people more hard-working
- Akrasia is confusion about what you want
- Subagents, akrasia, and coherence in humans
- #08 - B+Tree Data Structure (CMU Intro to Database Systems)
- Building and operating a pretty big storage system called S3
- Adventures in CPU contention
- How to Be a Leader When the Vibes Are Off
- Fundamental of Virtual Memory
- How has mathematics gotten so abstract?
- Priorities
- Property-Based Testing of OCaml 5's Runtime System - Midtgaard:OLIVIERFEST25.pdf
- Identity Types
- RNA structure prediction is hard. How much does that matter?
- Does One Have to be a Genius to Do Maths?
- I built ChatGPT with Minecraft redstone!
- Notes on Self-Control
- how AWS S3 serves 1 petabyte per second on top of slow HDDs
- Walking around the compiler
- Is Life a Form of Computation?
- Transformers KV Caching Explained
- Testing is better than DSA
- Tips for Working with Legacy Code
- How to waste CPU like a Professional
- Time Spent on Hardening
- What is "good taste" in software engineering?
- The golden ratio as a number base
- Bayesian Data Analysis
- RISC-V Conditional Moves
- "Testing Distributed Systems w/ Deterministic Simulation" by Will Wilson
- Inside NVIDIA GPUs: Anatomy of high performance matmul kernels
- 50 Things I Know
- dynamically typed languages exist?
- Dan Slimmon
- Lecture: Queueing theory on a cocktail napkin
- Why TigerBeetle is the most interesting database in the world
- Register allocation in the Go compiler
- Natural transformations
- The Business of Sportsbooks is Built on Losers
- How Did Sports Betting Become Legal in the US?
- Development gets better with Age
- Building the heap: racking 30 petabytes of hard drives for pretraining
- Type Theory for All: The Goal of Science is to Communicate Ideas
- What Every Programmer Should Know About Memory
- Talent is Alignment
- Hacker Laws
- Game Development: History, Industry, and Engine Design
- How Functional Programming Shaped (and Twisted) Frontend Development
- You can't parse XML with regex. Let's do it anyways.
- The Software Essays that Shaped Me
- GitHub - ivanyu/awesome-deterministic-simulation-testing: A curated list of awesome deterministic simulation testing resources 😎
- So, You Want to Learn More About Deterministic Simulation Testing?
- Go Data Structures: Interfaces
- Work is Not School: Surviving Institutional Stupidity
- Type Theory & Functional Programming
- Inside vLLM: Anatomy of a High-Throughput LLM Inference System
2025 / September
- Distributed consensus
- Everything you know is wrong
- GPT-2 Neural Network Poetry
- How to Beat Procrastination
- Prompt Engineering Guide
- Gödel’s Incompleteness Theorems
- Context Engineering for AI Agents: Lessons from Building Manus
- How to Lead in a Room Full of Experts
- A Very Early History of Algebraic Data Types
- The FLP theorem
- STYLE.md at main · tigerbeetle/tigerbeetle
- • Napkin (v1.6)
- Advanced Testing and Determinism
- Basic Type System Terminology
- Ongoing Tradeoffs, and Incidents as Landmarks
- Functors, Applicatives, And Monads In Pictures
- Hypervisor 101 in Rust
- My Thoughts on Renting Versus Buying
- 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
- LangChain’s best practices for 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
- Models of (Dependent) Type Theory
- 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
- 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
- How should we learn from bugs?
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
- 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
- Writing an IR from Scratch and survive to write a post - Eduardo Blázquez’s Personal Webpage
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
- 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
- Nobody Ever Gets Credit for Fixing Problems that Never Happened
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
- 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
- Salary Negotiation: Make More Money, Be More Valued | Kalzumeus Software
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
- Finding Flow: Escaping Digital Distractions Through Deep Work and Slow Living
- 50 Years of Travel Tips
- Picoeconomics
- 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
- 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.
- 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
- IBM RISC System/6000 Family
- Trapped Priors As A Basic Problem Of Rationality
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?
- 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
- How Complex Systems Fail
- 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
- William Cotton
- Pivot Points
- Being who you are, while becoming better
- Integrity Constraints and the Relational Derivative • Buttondown
- How to train a model on 10k H100 GPUs?
- bytecode interpreters for tiny computers ⁑ Dercuano
- Why is the Speed of Light So Fast? (Part 1)
- Magic isn’t real - Inside thoughts
- Programmer's Guide | C64 OS
- Terminal colours are tricky
- TCP Server in Zig - Part 1 - Single Threaded
- Welcome to Linux From Scratch!
- Why TCP needs 3 handshakes | PixelsTech
- Search for Charts by Data Visualization Functions
- Patterns for Personal Web Sites
- 15 rules for blogging, and my current streak (Interconnected)
- CRDTs go brrr
- LEGO IDEAS - Working Turing Machine
- The Writings of Leslie Lamport
- There is No Now - ACM Queue
- Two Workflow Tips
- The Problem With Building Good Habits | Stephan Joppich
- An Illustrated Proof of the CAP Theorem
- Monty Anderson
- No Feedback ∴ No Good
- rust-gpu.github.io
- How I manage my dotfiles · Jamie Tanna | Software Engineer
- brutalist-manifesto
- Sequences Highlights — LessWrong
- Learning By Writing — LessWrong
- A Dictionary of Single-Letter Variable Names | Blog | jackkelly.name
- Build Systems, Not Heroes
- How to convince engineers that formal methods is cool • Buttondown
- Let the network tell you where you are: a nerd snipe story
- Why do systems fail? Tandem NonStop system and fault tolerance
- sled book shop | sled-rs.github.io
- Error Handling in a Correctness-Critical Rust Project | sled-rs.github.io
- RescueTime - Your Weekly dashboard
- NTAPI Undocumented Functions
- Web Browser Engineering
- Books
- A liveness example in TLA+ – Surfing Complexity
- Focus on decisions, not tasks
- start - TLA+ Wiki
- Accountability sinks | A Working Library
- On accountability | A Working Library
- Which kernel is the most readable one? | Lobsters
- Cognitive load
- Distributed Systems Reading List
- start - TLA+ Wiki
- What docs as code really means | passo.uno :: Fabrizio Ferri-Benedetti on Technical Writing
- Google Testing Blog: SMURF: Beyond the Test Pyramid
- Learning to learn | K/L
- Building and scaling Notion’s in-house data lake
- S-38.3143 Queueing Theory (5 ECTS) L
- On the Importance of Typing Fast | rugu
- Whence '\n'? – Casey Rodarmor's Blog
- Understanding DNS resolution on Linux and Kubernetes
- Queuing Theory Tutorial
- How do Graphics Cards Work? Exploring GPU Architecture
- The Basics - by Thorsten Ball - Register Spill
- Canvas Fingerprinting - BrowserLeaks
- ADHD and Managing Your Reputation - by Vaishnav Sunil
- Writes and Write-Nots
- A Commentary on Defining Observability
- Using static websites for tiny archives – alexwlchan
- stormrider
- School is Not Enough - by Simon Sarris
- Founder Mode for Non-Founders · Daniel Mangum
- Abstract Machines of Systems Biology
2024 / September
- My Software Bookshelf | olano.dev
- Essays: NSA Surveillance: a Guide to Staying Secure - Schneier on Security
- Zig and Emulators
- Putting a meaningful dent in your error backlog – Dan Slimmon
- A new cycle-stepped 6502 CPU emulator
- Neurotechnology Numbers Worth Knowing
- August 2024 Time Tracking
- What is Table-Oriented Programming? :: Table-Oriented Programming (TOP)
- Authenticated Boot and Disk Encryption on Linux
- Notes/Primer on Clang Compiler Frontend (1) : Introduction and Architecture - Youssef Ateya
- Full Text, Full Archive RSS Feeds for any Blog | DOGESEC
- Opinions for Writing Good CSS
- Ask HN: Resources for GPU Compilers? | Hacker News
- The Art of Finishing | ByteDrum
- Dick Grune's Annotated Literature Lists
- Typed Lambda Calculus / Calculus of Constructions
- Thoughts on "The Future of TLA+" • Buttondown
- On distributed systems | Distributed Systems by Szymon Durak
- Founder Mode
- Programming with Lambda Calculus
- Why is Browser Observability Hard | Hazel Weakly
- The Fundamental Law Of Software Dependencies
- DNS "propagation" is actually caches expiring
- Taming Consensus in the Wild (with the Shared Log Abstraction)
- ATProto for distributed systems engineers - AT Protocol
- Linux's Bedtime Routine – Tookmund – A place for my random thoughts about software
- Implementing HanoiDB - Session 1: Introduction
- Programming languages resources | Max Bernstein
- Feynman Algorithm
- Explore AMX instructions: Unlock the performance of Apple Silicon | by 郑启航 | Sep, 2024 | Medium
- What I Gave Up To Become An Engineering Manager
- What to Do When You Forget Your Root Password – Tookmund – A place for my random thoughts about software
- B-trees and database indexes
- Practices of Reliable Software Design
- How does it feel to test a compiler? | by Alexander Zakharenko | Jul, 2024 | Medium
- Constraining writers in distributed systems
- Erasure Coding for Distributed Systems
- "Pushing the Limits of Web Browsers" by Lars Bak (2012)
- The BITSAVERS.ORG Documents Library : Free Texts : Free Download, Borrow and Streaming : Internet Archive
- What’s in an e-graph? | Max Bernstein
- My Homelab Setup
- Closures in Zig
- Legacy
- Going Buildless | Max Böck
- Your customers hate MVPs. Make a SLC instead.
- The Long Road to Fiber Optics - by Brian Potter
- Object-Oriented
- The Lesson to Unlearn
- Introduction to the PDP 11, Unit 1, System Overview
- My 71 TiB ZFS NAS after 10 years and zero drive failures
- CSCI 181G PO
- NetworkManager or networkd [LWN.net]
- Chapter 0 Preface — Programming Languages
- Code Reviews Do Find Bugs
- Books - Computing History
- A gentle guide to self-hosting your software | ᕕʕ •ᴥ•ʔ୨ Shank Space
- Visual guide to SSH tunneling and port forwarding - ITTAVERN.COM
- Informal History Of Programming Ideas
- Applied Mathematical Programming
- How not to be boring - PostHog
- Go To Statement Considered Harmful
- Linearizability! Refinement! Prophecy! – Surfing Complexity
- Be someone who does things | notes.eatonphil.com
- Tensor Labbet · A blog of deep learnings
- Raft
- Wealth = Have ÷ Need | Derek Sivers
- The guide to implementing 2D platformers | Higher-Order Fun
- XXIIVV — goals
- Alpha Conversion | Kevin Sookocheff
- Refactoring Invariants • Buttondown
- glouw/c8c: The chip8 compiler, assembler, and virtual machine
- How Discord Stores Trillions of Messages
- Introduction to the λ-calculus
2024 / August
- DRMacIver's Notebook: Asymmetric vices and the unity of virtue
- Practical Math: My Journey from Idea to Application | Happiness Machines
- On writing | What's new
- EMUBook
- Vector Clocks Explained
- The algebra (and calculus!) of algebraic data types
- x86re
- There is no mystery over who wrote the Blue Screen of Death, despite what some may want you to believe - The Old New Thing
- React Compiler, How Does It Work? [1] - Entry Point through Babel Plugin | 장용석 블로그
- How to talk to your parents about hardware memory safety | CHERIoT Platform
- Learning & The Power of the First Step - TK • Newsletter
- Do Quests, Not Goals
- Peter DaSilva/The New York Times/Redux
- Ray Tracing Harmonic Functions
- Hacking a Virtual Power Plant | rya.nc
- WebGPU Unleashed: A Practical Tutorial
- SNES: Sprites and backgrounds rendering
- Tales of the M1 GPU - Asahi Linux
- Adam Keys is Thinking - Methods of production
- Monitoring Node.js: Watch Your Event Loop Lag! - David Hettler 🥨
- The Illustrated QUIC Connection: Every Byte Explained
- How we tamed Node.js event loop lag: a deepdive | Trigger.dev
- Some Books I Like // One Year of NULL BITMAP • Buttondown
- Ask HN: What are some "toy" projects you used to learn neural networks hands-on? | Hacker News
- Visual Data Structures Cheat-Sheet - by Nick M
- Examples of Great URL Design - Jim Nielsen’s Blog
- Higher-kinded Bounded Polymorphism
- A Visual Guide to Quantization - by Maarten Grootendorst
- Crafting Interpreters with Rust: On Garbage Collection | Tung Le Vo
- HTTP/0.9 From Scratch
- HTTP/1.0 From Scratch
- The Compiler Writer Resource Page
- The Art of Learning - TK • Newsletter
- Efficient and Insightful Generalization
- How to avoid losing items? Holding pens. | Alex W.'s Blog
- naklecha/llama3-from-scratch: llama3 implementation one matrix multiplication at a time
- Late Again – Rands in Repose
- How to write.
- What I Learned Working For Mark Zuckerberg - Noah Kagan
- Practices of Reliable Software Design
- Look at yourself objectively (Aaron Swartz's Raw Thought)
- Lean into the pain (Aaron Swartz's Raw Thought)
- Applying Books in My Life - TK • Newsletter
- Obsession | notes.eatonphil.com
- Home
- Ethernet History Deepdive – Why Do We Have Different Frame Types? – Daniels Networking Blog
- A ToC of the 20 part linker essay [LWN.net]
- B-trees
- How SSH Secures Your Connection :: Noratrieb's blog
- Self-hosting DNS - GHOST
- You Are NOT Dumb, You Just Lack the Prerequisites
- Predicting the Future of Distributed Systems
- Confront reality (Aaron Swartz's Raw Thought)
- Cherish mistakes (Aaron Swartz's Raw Thought)
- Fix the machine, not the person (Aaron Swartz's Raw Thought)
- Rachel Thomas, PhD - Your Immune System is Not a Muscle
- Database “sharding” came from UO? – Raph's Website
- Best resources to learn about data and distributed systems - Pierre Zemb
- Learning about distributed systems: where to start?
- Notes on Distributed Systems for Young Bloods – Something Similar
- Distributed systems theory for the distributed systems engineer | Paper Trail
- How to sync Mac and Linux /home | Derek Sivers
- How much of success is luck?
- State and time are the same thing • Buttondown
2024 / July
- A write-ahead log is not a universal part of durability | notes.eatonphil.com
- "Simple Made Easy" - Rich Hickey (2011)
- Measuring personal growth
- My programming beliefs as of July 2024
- Elaboration of the PostgreSQL sort cost model
- Programmers Should Never Trust Anyone, Not Even Themselves
- Falsehoods Software Developers Believe About Event-Driven Systems · Blog · Loïc Carr
- Don't End The Week With Nothing
- Good and Bad Procrastination
- Alexander Gromnitsky's Blog :: 2024-07-01 :: The cheapest NAS
- full-issue
- The Joy of Reading Books You Don't Entirely Understand - Reactor
- Neo Geo Architecture | A Practical Analysis
- NMI_Review
- Every website and web app should have a service worker | Go Make Things
- The sad state of property-based testing libraries
- Lensy Moore
- Reverse Engineering the Verification QR Code on my Diploma
- Trying Kolmogorov-Arnold Networks in Practice - Casey Primozic's Homepage
- A TUTORIAL ON POINTERS AND ARRAYS IN C
- What every systems programmer should know about concurrency
- Properly Testing Concurrent Data Structures
- How to implement a hash table (in C)
- How I Use Obsidian – Matt Stein
- How I use Obsidian - macwright.com
- doceamus-edu-sweller.indd
- Dirty writes – Surfing Complexity
- How to think in writing - by Henrik Karlsson
- Be patient with problems - by Henrik Karlsson
- Learning By Writing
- Modeling B-trees in TLA+ – Surfing Complexity
- Synchronization is bad for scale
- Serving a billion web requests with boring code - llimllib notes
- Robin Rendle — Creativity is the byproduct of work
- How we designed our company for speed - PostHog
- Notes for new hires | Clinton Blackburn
- Why you need a "WTF Notebook"
- A Git story: Not so fun this time | Brachiosoft Blog
- Magical Music Theory Tools to Learn Music Online for Free
- Build your own React
- The Right Kind of Stubborn
- Adam Keys is Thinking - Slash pages & micro-features
- The Architecture of Open Source Applications (Volume 1)Berkeley DB
- The Architecture of Open Source Applications
- Scoped Propagators
- MathPages
- Deep-ML
- time-clocks
- lorin/systems-reading: Systems and failure reading list
- Welcome … — Physics-based Deep Learning
- Why I’m Writing A Book On Cryptography
- Let's reproduce GPT-2 (1.6B): one 8XH100 node, 24 hours, $672, in llm.c · karpathy/llm.c · Discussion #677
- The Forth Methodology of Charles Moore by Jeff Fox 12/09/01
- Agda by Example: λ-calculus
- WebGPU Fundamentals
- Use A Work Journal To Recover Focus Faster And Clarify Your Thoughts
- 89 things I know about Git commits · Jamie Tanna | Software Engineer
- Superbabies: Putting The Pieces Together — LessWrong
- Adam Keys is Thinking - Journal, highlight, revisit, blog
- CSS GPU Animation: Doing It Right — Smashing Magazine
- Trust as a bottleneck to growing teams quickly | benkuhn.net
- Three important steps before jumping to the code
- Matrix Theory of Mind - by Thorsten Ball - Register Spill
- O tal do Isolamento no A.C.I.D. - Alen Vieira
- The microarchitecture of Intel and AMD CPUs
- A malleable garden
- Beating the L1 cache with value speculation
- An Incremental Approach to Compiler Construction
- A Race to the Bottom - Database Transactions Undermining Your AppSec · Doyensec's Blog
- Where Did Combinators Come From? Hunting the Story of Moses Schönfinkel—Stephen Wolfram Writings
- How and why we built our startup around small teams
- The Hazardous Life of an Undersea Cable
- Understanding 3D Graphics | Azeem Bande-Ali | azeemba.com
- The humble beginning of id Software | Brachiosoft Blog
- On reading about optimizing compilers | Ludwig
- Hugo Sidenotes Shortcode :: dade
- Linear Algebra Fundamentals
- Bio-digital jazz, man
- Jonas Hietala: Microfeatures in my blog
- sbensu: We need visual programming. No, not like that.
- How to Create a Liquid Raymarching Scene Using Three.js Shading Language | Codrops
- Software Engineering Is Not Engineering | Brain Baking
- interdb.jp
- Keep perfecting your config • Buttondown
- The Backup And Sync Strategy, Revised | Brain Baking
- untitled1.html
- bobbyiliev/introduction-to-bash-scripting: Free Introduction to Bash Scripting eBook
- How to create software quality. | Irrational Exuberance
- Layers of context. | Irrational Exuberance
- Developing domain expertise: get your hands dirty. | Irrational Exuberance
- VisCircuit - Make Circuits Easy to Learn
- Self Hosting 101 - A Beginner's Guide
- The Greatest Educational Life Hack: Learning Math Ahead of Time - Justin Skycak
- SQLite Transactions
- Alternative Technologies
- RFC 677: Maintenance of duplicate databases
- little-languages
- time-clocks
- Computer Architecture : Foundational Reading - by Babbage
- Managing Underperformers | Jack Danger
- Learning LLVM (Part-2)
- why you should write more - by Ava - bookbear express
- 1989 Networking: NetWare 386 | OS/2 Museum
- Setting up an x86 CPU in 64-bit mode
- PostgreSQL triggers and isolation levels - Vlad Mihalcea
- Parse, don’t validate
- Structured Procrastination
- Build your own SQLite, Part 1: Listing tables
- On having more interesting ideas - by Henrik Karlsson
- Chase Your Reading - by Robin Hanson - Overcoming Bias
- onceupon/Bash-Oneliner: A collection of handy Bash One-Liners and terminal tricks for data processing and Linux system maintenance.
- Haskell for all: Software engineers are not (and should not be) technicians
- Categories of leadership on technical teams | benkuhn.net
- First Principles: The Building Blocks of True Knowledge
- lecture18
- Intro | Putting the "You" in CPU
- How Simultaneous Multithreading Works Under the Hood
- When Then Zen
- My OBTF Workflow & Bash Script
- Tools + Techniques for Procedural Gamedev - Casey Primozic's Homepage
- Startup Finance for Founders — Part I, Accounting by Peter Reinhardt
- Ray Tracing in One Weekend Series
- advanced-linux-programming
- Rediscovering Transaction Processing From History and First Principles
- Introduction · Reverse Engineering
- sigtt611-bernstein
- Let's Consign CAP to the Cabinet of Curiosities - Marc's Blog
- kiennt26's home | Linux Network Performance Ultimate Guide
- Calculus for Beginners
- Taking my diabetes treatment into my own hands | Martin Janiczek
- Consensus
- Database Indexes & Phone Books - by Thorsten Ball
- Philosophy of How to Learn
- Learning about PCI-e: Driver & DMA
- Forget “show, don’t tell”. Engage, don’t show! • Lea Verou
- Not Just Scale - Marc's Blog
- Story: Redis and its creator antirez | Brachiosoft Blog
- Understanding_digital_signal_processing
- soulmachine/machine-learning-cheat-sheet: Classical equations and diagrams in machine learning
- Plain text journaling | ᕕ( ᐛ )ᕗ Herman's blog
- A weekend's (re)reading list | Ludwig
- #001 - Abraçando o caminho sem volta - Insight Espresso
- Complex systems emerge from simple rules
- Math 331 Reading Guides
- Simple event broker tries Tiger Style
- The Four Theories of Truth as a Method for Critical Thinking - Daniel Imfeld
- How to Compile Your Language
- The Documentation Tradeoff - by Kent Beck
- Motivation
- Art of Assembly Language, PDF Files
- The Hitchhiker's Guide to Logical Verification
- Advice to the young
- Adam Keys is Thinking - The (Leadership) Discipline
- How I Computer in 2024 · Jon Seager
- Elements kinds in V8 · V8
- Lysxia - Where does the name "algebraic data type" come from?
- Creativity Fundamentally Comes From Memorization
2024 / June
- Cultures of writing. - by Karina Nguyen - sémaphore
- https://segment.com/blog/when-aws-autoscale-doesn-t/
- Be findable - by Thorsten Ball - Register Spill
- CRDT: Text Buffer - Made by Evan
- The Design Space of Wikis
- Systems: The Purpose of a System is What It Does - Anil Dash
- Productivity Versus Alignment
- Work hard and take everything really seriously - macwright.com
- Biohacking Lite
- What Color is Your Function? – journal.stuffwithstuff.com
- Feynman's Razor - by Defender of the Basic
- Regular, Recursive, Restricted
- Learn OpenGL, extensive tutorial resource for learning Modern OpenGL
- A (Draft) Taxonomy of SIMD Usage – Branch Free
- Data Modeling in Document Databases for the RDBMS-Minded
- Build Your Own X
- Legend of Worlds
- Proxmox vs FreeBSD: Which Virtualization Host Performs Better? - IT Notes
- Notational intelligence | thesephist.com
- staniks.github.io
- Things you wish you didn't need to know about S3
- Mediocre Engineer’s guide to HTTPS
- Making USB devices - end to end guide to your first gadget
- NULL BITMAP Builds a Database #1: The Log is Literally the Database • Buttondown
- Ray Tracing in One Weekend
- Never, Sometimes, Always - lukeplant.me.uk
- How I Cured My Procrastination - Learn How To Learn
- Confusion is a muse | notes.eatonphil.com
- Experts vs. Imitators
- On Seeing Through and Unseeing: The Hacker Mindset · Gwern.net
- Complex Analysis
- Accounting for Developers, Part I | Modern Treasury Journal
- Scratchapixel 4.0, Learn Computer Graphics Programming
- Exponentially Better Rotations
- The Book of Shaders
- The Law of Leaky Abstractions – Joel on Software
- Useful and Overlooked Skills · Collab Fund
- 2000-cook
- Don’t Shave That Yak! | Seth's Blog
- The simple genius of checklists, from B-17 to the Apollo missions | Inside Nuclino
- On Having Enough Socks · Gwern.net
- (1) So you wanna de-bog yourself - by Adam Mastroianni
- (1) Do Ten Times as Much - by Bryan Caplan - Bet On It
- Internet Search Tips · Gwern.net
- Simple sabotage for software · Erik Bernhardsson
- A few words on taking notes | All Things Distributed
- Ship something every day
- Richard Hamming: You and Your Research
- Programmers should stop celebrating incompetence
- Always Measure One Level Deeper
- Always Measure One Level Deeper – Communications of the ACM
- Start With Simple Tools
- Decision Brownouts
- Arbitrariness Costs
- Cheng Lou - "On the Spectrum of Abstraction" summarized transcript (React Europe 2016)
- How to Overcome Plateaus - Learn How To Learn
- A complete guide to iconography
- Ownership
- 500 Lines or LessAn Archaeology-Inspired Database
- Let's write a video game from scratch like it's 1987
- karpathy/LLM101n: LLM101n: Let's build a Storyteller
- Counted B-Trees
- Spaced Repetition for Efficient Learning · Gwern.net
- Why Forgetting Can Be Good - Scott H Young
- Introduction - Habitual Mastery (Series) - Scott H Young
- The Hitchhiker's Guide to the Unexpected
- A Distributed Systems Reading List
- Effective Spaced Repetition
- Hitting the High Notes – Joel on Software
- Writing My Own Database From Scratch
- antoniosarosi/mkdb: Toy Database
- Reflections on a decade of coding
- The Unix and Internet Fundamentals HOWTO
- How to Test
- Becoming a go-to person gets you promoted. Here's how to do it as a software engineer.
- Microfeatures I Love in Blogs and Personal Websites
- Terms, types, and functions
- Say Hello to 1-based indexing in JavaScript!
- Understanding V8's Bytecode
- Using d8 · V8
- Database anomalies and isolation levels |
- Hacking Millions of Modems (and Investigating Who Hacked My Modem)
- How terminal works. Part 1: Xterm, user input | Thoughts-chain
- Reversing Choplifter – Blondihacks
- Virtualization Internals Part 1 - Intro to Virtualization | Saferwall
- leandromoreira/digital_video_introduction: A hands-on introduction to video technology: image, video, codec (av1, vp9, h265) and more (ffmpeg encoding). Translations: 🇺🇸 🇨🇳 🇯🇵 🇮🇹 🇰🇷 🇷🇺 🇧🇷 🇪🇸
- Classic Papers in Programming Languages and Logic
- Inside the tiny chip that powers Montreal subway tickets
- Ordinary Incompetence · Gwern.net
- Working hurts less than procrastinating, we fear the twinge of starting — LessWrong
- making regex from scratch in GO - Lewis Metcalf
- You probably wrote half a monad by accident – Andy G's Blog
- What Should You Do with Your Life? Directions and Advice - Alexey Guzey
- Marcus' Blog
- Differential Analysis: A Summary
- zine-ali
- Fast · Patrick Collison
- How to evolve a product | Granola
- Modern cryptography on the NES - Super Tilt Bro. for NES by sgadrat
- Malloc_tutorial
- malloc
- How much memory does a call to ‘malloc’ allocates? – Daniel Lemire's blog
- Implementing SHA-256 on the 6502 | Bumbershoot Software
- Understanding React Compiler | Tony Alicea
- What is a CIDR trie and how can it help you? · blog | sven kanoldt
- Hermitage: Testing the “I” in ACID — Martin Kleppmann’s blog
- Writing is a technology that restructures thought
- Introduction | Bmg documentation
- The Work Life of Developers: Activities, Switches and Perceived Productivity
- TLA+ modeling of a single replicaset transaction modeling
- A snapshot isolated database modeling in TLA+
- An Experienced (Neo)Vimmer's Workflow
2024 / May
- Ansible is a Lisp
- Abstract Heresies: Statements and Expressions
- Tracking the Wins
- Study of Historical Code | ℤ→ℤ
- Figma’s journey to TypeScript | Figma Blog
- Do Things and Tell People
- How to Build a $20 Billion Semiconductor Fab
- Why Full Text Search is Hard
- My favorite teacher - by Thorsten Ball - Register Spill
- The Time Linkerd Erased My Load Balancer
- "Integration tests" are just vibes • Buttondown
- Chris's Wiki :: blog/tech/UEFIAndBIOSAndOtherPCTerms
- How to style React applications while the world burns around us | Herb Caudill
- Bollards: Why & What · Josh Thompson
- Safety and Liveness Properties
- ISP Router Design Mistakes | Brain Baking
- pal-iii : Digital Equipment Corporation : Free Download, Borrow, and Streaming : Internet Archive
- Visualization Mnemonics for Software Principles - DaedTech
- How NASA is Hacking Voyager 1 Back to Life - IEEE Spectrum
- Exploring Hacker News by mapping and analyzing 40 million posts and comments for fun | Wilson Lin
- Professional corner-cutting : Havoc's Blog
- GPUs Go Brrr · Hazy Research
- ISP Column - April 2024
- Bye Opam, Hello Nix | Emil Privér
- Implementing MVCC and major SQL transaction isolation levels | notes.eatonphil.com
- Reading C type declarations
- From Any Spot on the Field - by Thorsten Ball
- Kim Young Jin - Ambitious but at peace
- So we built a Reverse Tunnel in Go over HTTP/3 and QUIC | Flipt Blog
- Pmarchive · Pmarca Guide to Personal Productivity
- How and why to make a /now page on your site | Derek Sivers
- Structured Procrastination
- The Misunderstood Stoic
- What I look for in empirical software papers • Buttondown
- Guide: How to start a writing habit
- A New Way to Store Knowledge
- Semantic note-taking | cceckman, from the Internet
- Tools That Make You Feel Empowered
- A Road to Common Lisp / Steve Losh
- The Power of the Marginal
- The Back-to-Basics Readings of 2012 | All Things Distributed
- Write yourself a Git!
- Ilya 30u30
- Megaparsec tutorial
- How Far Can I Legally Make a Scheduled I Substance?
- Queueing – An interactive study of queueing strategies – Encore Blog
- Doing is normally distributed, learning is log-normal | Andrew Quinn's TILs
- Old Dogs, new CSS Tricks | Max Böck
- Evolution of the ELF object file format | MaskRay
- No Wrong Doors. | Irrational Exuberance
- Feynman's Garden @ marginalia.nu
- In the beginning… was the command line | thesephist.com
- Writing a Unix clone in about a month
- Functional TypeScript #1: Algebraic Data Types
- Developers aren't Nerds | 0xFF
2024 / April
- Everything I Know About SSDs 2019
- Book list for streetfighting computer scientists - dankwiki, the wiki of nick black
- You Don’t Need a Writing Ritual
- Subroutine calls in the ancient world, before computers had stacks or heaps - The Old New Thing
- lizrice/containers-from-scratch: Writing a container in a few lines of Go code, as seen at DockerCon 2017 and on O'Reilly Safari
- Visualizing the ARM64 Instruction Set | Zachary Yedidia's blog
- Advice to Young People, The Lies I Tell Myself - jxnl.co
- great_tables - The Design Philosophy of Great Tables
- The hearts of the Super Nintendo
- Building My First Homelab Server Rack · mtlynch.io
- My list of challenging software projects some programmers should try | andreinc
- Why the “Eisenhower matrix” is a fantastic productivity hack - Big Think
- Here is why vim uses hjkl keys as arrow keys
- Optimizing Javascript for fun and for profit
- Garbage Collection for Systems Programmers
- My new home server · g/ianguid/o.today
- My favorite technical blogs
- How I significantly improved my sleep schedule - Issa Rice
- If Inheritance is so bad, why does everyone use it? • Buttondown
- How to send progress updates - Slava Akhmechet
- Do you really need IPv4 anymore?
- What makes a great technical blog | notes.eatonphil.com
- An IRC client in your motherboard | Phillip Tennen
- Discrete logic IC CPU | Ivan's blog
- Double-Entry Bookkeeping as a Directed Graph · Matheus Portela
- RECOMMENDED DESIGN BOOKS/FILMS – How Design MAKES THE WORLD (The book)
- A Visual Guide to Vision Transformers | MDTURP
- What makes concurrency so hard? • Buttondown
- 12 Map Happenings that Rocked our World: Part 9 – Map Happenings
- The Psychology of Liminal Spaces
- Incomplete List of Mistakes in the Design of CSS [CSS Working Group Wiki]
- About the author
- oss-security - Make your own backdoor: CFLAGS code injection, Makefile injection, pkg-config
- Formal Methods: Just Good Engineering Practice? - Marc's Blog
- Linux text manipulation
- 3 important things I overlooked during code reviews | Piglei
- The Guide to Stock Options conversations - by Anton Zaides
- Tips on how to structure your home directory
- Stop Acting Like You're Famous
- The Technium: 101 Additional Advices
- Parsing and all that
- Halo 2 in HD: Pushing the Original Xbox to the Limit – I Code 4 Coffee
- 50 Years Later, This Apollo-Era Antenna Still Talks to Voyager 2 - IEEE Spectrum
- Visualizing Algorithms
- On Opening Essays, Conference Talks, and Jam Jars
- Good Ideas in Computer Science ・ Daniel Hooper
- The Man Who Killed Google Search
- Other people’s problems | Seth's Blog
- "Thought loss anxiety" is the fear of forgetting good ideas due to lack of good record-keeping
- adam-maj/tiny-gpu: A minimal GPU design in Verilog to learn how GPUs work from the ground up
- Wisdom from Marcus Aurelius - by Gurwinder - The Prism
- Finding Fulfillment
- Operable Software
- kenjihiranabe/The-Art-of-Linear-Algebra: Graphic notes on Gilbert Strang's "Linear Algebra for Everyone"
- tsouanas/fmcbook: Matemática Fundacional para Computação: book by Thanos Tsouanas (in portuguese)
- Learn one thing at a time | Lawrence Jones
- Staring into the abyss as a core life skill | benkuhn.net
- Inside the Super Nintendo cartridges
- Constraints on giving feedback. | Irrational Exuberance
- Bytecode VMs in surprising places
2024 / March
- Demystifying GPUs for CPU-centric programmers | Medium
- Understanding GPU caches – RasterGrid
- Learn CSS Layout The Pedantic Way
- Building a Scalable Accounting Ledger
- My thoughts on writing a Minecraft server from scratch (in Bash)
- How User Groups Made Software Reuse a Reality | ℤ→ℤ
- Inside the miracle of modern chip manufacturing
- Airfoil – Bartosz Ciechanowski
- Internet gardening | James' Coffee Blog
- Byte Interviews the Apple Lisa Dev Team (1983)
- Motorola's 6809 : The Best 8-Bit? - by Babbage
- A Deep Dive into the Underlying Architecture of Groq's LPU
- Paul Butler – The hater’s guide to Kubernetes
- Anatomy of a NixOS Config - unmoved centre
- Reverse Engineering Protobuf Definitions From Compiled Binaries
- Why (and how) to read books | notes.eatonphil.com
- O Juro é negativo após 2008 - by 🟩🟩Trezoitão🟩🟩
- The CAP Theorem. The Bad, the Bad, & the Ugly | Dominik Tornow
- The checklist manifesto (Dr. Atul Gawande, 2009)
- AT&T ARCHIVES AND HISTORY CENTER
- Coordination Avoidance in Database Systems
- Why I blog
- Learning a technical subject
- Your attitude determines your success
- How I read a research paper
- How HEAD works in git
- POV: I'm on my third coffee and you just asked me how the internet works
- Technical Skills Are Overrated. Focus on Your Attitude.
- “No” Is a Good Default Answer
- CAP is Good, Actually • Buttondown
- Breaking Down Tasks - Jacob Kaplan-Moss
- SQLite Internals: Pages & B-trees · The Fly Blog
- Create More Than You Consume if You Want to Worry Less and Feel More Fulfilled — OMAR ITANI
- My weekly review habit | benkuhn.net
- 40 years of programming
- Learning from DNA: a grand challenge in biology · Hazy Research
- Nix is a better Docker image builder than Docker's image builder - Xe Iaso
- How Figma's Databases Team Lived to Tell the Scale | Figma Blog
- First month on a database team | notes.eatonphil.com
- Checking Causal Consistency of MongoDB
- 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
- Redefining Observability | Hazel Weakly
- Be Well Tuned
- Tecno S8C
- My favorite essays of life advice | benkuhn.net
- Take Ownership of Your Future Self
- Leadership requires taking some risk. | Irrational Exuberance
- Dobiasd/articles: thoughts on programming
- The Mechanics of Proof — The Mechanics of Proof, by Heather Macbeth
- How to Start Google
- articles/internals_of_the_async_await_pattern_from_first_principles.md at master · Dobiasd/articles
- Design is an Island - by Kent Beck
- Decision logs
- myme.no - Focus by Automation
- Doing weeknotes
- Fail Forward With Kindness / marcel.io
- The Beginner’s Guide to Queuing theory | Qminder
- Why do regexes use `$` and `^` as line anchors? • Buttondown
- #7 - On Keeping a Notebook | Kadambari
- So you think you want to write a deterministic hypervisor?
- Tech Independence | Derek Sivers
- ADHD Productivity Fundamentals — 0xFF
- Sega Saturn Architecture | A Practical Analysis
- Linux Crisis Tools
- Deterministic Simulation Testing | Resonate
- Things you're allowed to do
- Be impatient | benkuhn.net
- Think real hard | benkuhn.net
- The problem with invariants is that they change over time – Surfing Complexity
- Why Mathematics is Boring | The n-Category Café
- Basic Things
- Type system of the React compiler
2024 / February
- A Brief Summary of Evolutionary Design | CodingItWrong.com
- How Did I Get Here?
- Idea Generation - Sam Altman
- Why Gödel, Escher, Bach is the most influential book in my life. | by Mark Johnson | Medium
- How Do You Spend Your Time? - Marc's Blog
- Writing For Somebody - Marc's Blog
- Writing Is Magic - Marc's Blog
- OKRs are Bullshit - by drmorr
- Demystifying GPU Compute Architectures - by Babbage
- Teach Yourself Programming in Ten Years
- Tunable Consistency in MongoDB
- HOW TO STUDY
- How do you approach reading a paper?
- An intuition for distributed consensus in OLTP systems | notes.eatonphil.com
- Distributed Logical Time
- Fighting undead documentation
- B+-Tree Indexes
- Evolution of tree data structures for indexing: more exciting than it sounds · Erthalion's blog
- Bloom Filters
- DRMacIver's Notebook: Writing good programming abstractions
- Software infrastructure 2.0: a wishlist · Erik Bernhardsson
- Table of Contents | Ultimate Electronics Book
- What I Wish Someone Had Told Me - Sam Altman
- How MOSFETS Work - Unravel the Mysteries of How mosfets Work!
- williamdemeo/TypeFunc: Resources for type theory, functional programming, etc.
- Build your own Database Index: part 1
- ego
- Compiler Theory and Reactivity
- Haskell for all: Unification-free ("keyword") type checking
- Roman Jakobson : The Functions of Language / Signo - Applied Semiotics Theories
- Website Refresh 2023
- 2024-02-25 a history of the tty
- Earth is becoming sentient — Steph Ango
- How to change a system (18 ways) – Changeology
- Job titles are bullshit · Jamie Tanna | Software Engineer
- How I backup | Derek Sivers
- Shape Up: Stop Running in Circles and Ship Work that Matters
- No one can teach you to have conviction | benkuhn.net
- OBTF Follow-up