Notes on software development

Analytics query goes 6x faster with EDB Postgres Distributed's new analytics engine

Set up a single-node EDB Postgres Distributed cluster on Ubuntu

What even is distributed systems

Stack traces for Postgres errors with backtrace_functions

Want to meet people, try charging them for it?

Debugging memory leaks in Postgres, jemalloc edition

Cheerleading

Debugging memory leaks in Postgres, heaptrack edition

Burn your title

Transactions are a protocol

Things that go wrong with disk IO

Phil Eaton on Technical Blogging

Minimal downtime Postgres major version upgrades with EDB Postgres Distributed

From web developer to database developer in 10 years

Edit for clarity

An explosion of transitive dependencies

Embedding Python in Rust (for tests)

Logical replication in Postgres: Basics

How I run a coffee club

Picking up volleyball in NYC with Goodrec and New York Urban

1 million page views

Exploring Postgres's arena allocator by writing an HTTP server from scratch

Effective unemployment and social media

Checking linearizability in Go

Intuitions for Distributed Consensus by Phil Eaton

Build a serverless ACID database with this one neat trick (atomic PutIfAbsent)

Be someone who does things

Obsession

What's the big deal about Deterministic Simulation Testing?

Delightful, production-grade replication for Postgres

A reawakening of systems programming meetups

A write-ahead log is not a universal part of durability

The limitations of LLMs, or why are we doing RAG?

Confusion is a muse

How I run a software book club

Implementing MVCC and major SQL transaction isolation levels

What makes a great technical blog

A paper reading club at work; databases and distributed systems research

Finding memory leaks in Postgres C code

Zig, Rust, and other languages

First month on a database team

An intuition for distributed consensus in OLTP systems

Writing a minimal in-memory storage engine for MySQL/MariaDB

Make your own way

Exploring a Postgres query plan

Writing a storage engine for Postgres: an in-memory Table Access Method

io_uring basics: Writing a file to disk

Go database driver overhead on insert-heavy workloads

Intercepting and modifying Linux system calls with ptrace

How do databases execute expressions?

Eight years of organizing tech meetups

Thinking about functional programming

We put a distributed database in the browser – and made a game of it

Metaprogramming in Zig and parsing CSS

Implementing the Raft distributed consensus protocol in Go

Two books I recommend to developers

My favorite software subreddits

Errors and Zig

Notes from Neal Gabler's Walt Disney

Lessons learned streaming building a Scheme-like interpreter in Go

An effective product manager

The year in books: 2022

Favorite compiler and interpreter resources

General book recommendations

In response to a frontend developer asking about database development

Is it worth writing about?

A Programmer-Friendly I/O Abstraction Over io_uring and kqueue

Writing a SQL database, take two: Zig and RocksDB

A minimal RocksDB example with Zig

A database without dynamic memory allocation

A minimal distributed key-value database with Hashicorp's Raft library

What's the big deal about key-value databases like FoundationDB and RocksDB?

SQLite has pretty limited builtin functions

Container scheduling strategies for integration testing 14 different databases in Github Actions

Implementing a simple jq clone in Go, and basics of Go memory profiling

One year as a solo dev building open-source data tools without funding

Let's build a distributed Postgres proof of concept

SQLite in Go, with and without cgo

HTML event handler attributes: down the rabbit hole

Interview With Phil of DataStation

Surveying SQL parser libraries in a few high-level languages

Writing a document database from scratch in Go: Lucene-like filters and indexes

Speeding up Go's builtin JSON encoder up to 55% for large arrays of objects

SMTP protocol basics from scratch in Go: receiving email from Gmail

The world of PostgreSQL wire compatibility

How to recommend books, or, stop recommending SICP

Bootloader basics

dsq: Commandline tool for running SQL queries against JSON, CSV, Excel, Parquet, and more.

Analyzing large JSON files via partial JSON parsing

The year in books: 11 to recommend in 2021

Writing a minimal Lua implementation with a virtual machine from scratch in Rust

Running SQL Server in a container on Github Actions

Implementing zip archiving in Golang: unzipping

Benchmarking esbuild, swc, tsc, and babel for React/JSX projects

Building a fast SCSS-like rule expander for CSS using fuzzy parsing

Exploring PL/pgSQL part two: implementing a Forth-like interpreter

Exploring PL/pgSQL: Strings, arrays, recursion, and parsing JSON

Experimenting with column- and row-oriented datastructures

Notes on running Electron

Enumerating and analyzing 40+ non-V8 JavaScript implementations

Writing a simple JSON library from scratch: a tour through modern C++

Parser generators vs. handwritten parsers: surveying major language implementations in 2021

Practical? Common Lisp on the JVM: A quick intro to ABCL for modern web apps

Writing an efficient object previewer for JavaScript

React without webpack: fast path to a working app from scratch

Controlled HTML select element in React has weird default UX

Leaders, you need to share organization success stories more frequently

Languages you can run in the browser, part 1: Python, JavaScript, SQLite

Coolest hard-tech companies in NYC 2021

Writing a Jinja-inspired template library in Python

Learning a new codebase: hacking on nginx

How to get better at recursion

Extending gosql to supporting LIMIT and OFFSET

The year in books: 20 to recommend in 2020

Static analysis with semgrep: practical examples using Docker

Emulating linux/AMD64 userland: interpreting an ELF binary

The impact of management teams as a decision-making group, in startups and enterprise

Standard ML in 2020

The case for comments in code

Writing a simple Python compiler: 1. hello, fibonacci

A single-node Kubernetes cluster without virtualization or a container registry

Generating a full-stack application from a database

Generating a REST API from a database

RFCs and asynchronous-first culture

Writing a SQL database from scratch in Go: 4. a database/sql driver

Writing a SQL database from scratch in Go: 3. indexes

Writing a SQL database from scratch in Go: 2. binary expressions and WHERE filters

Studying foreign languages with inbox zero

Reviewing the Surface Book 2

Writing a SQL database from scratch in Go: 1. SELECT, INSERT, CREATE and a REPL

A minimal REST API in Java

Writing a lisp compiler from scratch in JavaScript: 6. an x86 upgrade

Confusion and disengagement in meetings

Interpreting Go

Administering Kubernetes is hard

Unit testing C code with gtest

Writing an x86 emulator from scratch in JavaScript: 2. system calls

Writing a lisp compiler from scratch in JavaScript: 6. LLVM system calls

Writing an x86 emulator from scratch in JavaScript: 1. a stack and register machine

Tail call elimination

Writing a lisp compiler from scratch in JavaScript: 4. LLVM conditionals and compiling fibonacci

Responsibility and ownership

Interpreting TypeScript

Writing a web server from scratch: 1. HTTP and sockets

Writing a simple JSON path parser

Writing a lisp compiler from scratch in JavaScript: 3. LLVM

AOT-compilation of Javascript with V8

Windows

Writing a lisp compiler from scratch in JavaScript: 2. user-defined functions and variables

Writing a lisp compiler from scratch in JavaScript: 1. lisp to assembly

On NYC, Tokyo and Seoul

Why (and how) to read books

Compiling dynamic programming languages

btest: a language agnostic test runner

Writing to be read

Writing a simple JSON parser

Finishing up a FreeBSD experiment

Book Review: ANSI Common Lisp

Starting a minimal Common Lisp project

Interview with the D Language Blog: BSDScheme

First few hurdles writing a Scheme interpreter

Deploying FreeBSD on Linode unattended in minutes

Walking through a basic Racket web service