Matt Rickard

most popular engineering startups misc ai all

11-26-23

Drawbacks of Moving to the Edge

11-03-23

Lessons from llama.cpp

10-29-23

On Mixing Client and Server

10-28-23

Infrastructure as Code Will be Written by AI

10-22-23

Retrieval Augmented Generation

10-20-23

Pitfalls of File-based Routing

10-17-23

The Inner-Platform Effect

10-15-23

Why Is the Frontend Stack So Complicated?

10-12-23

Nagle's Algorithm

10-07-23

Incentives Behind Programming Languages

10-03-23

Pitfalls of Database Migrations

10-01-23

Lessons From Debugging

09-27-23

Is Data Still a Moat?

09-22-23

Good Enough Abstractions

09-21-23

Automate (But Automate Last)

09-07-23

Raft: The Distributed Systems Algorithm

09-03-23

Technical Metrics to Track in Engineering Orgs

09-02-23

TypeScript Type System Hacks

08-23-23

Copy and Paste Libraries

08-14-23

Why Tailwind CSS Won

08-07-23

Majority Rule Developers

08-02-23

Data Versioning

07-29-23

Git Merge Strategies and Algorithms

07-15-23

Scale to Zero for AI Workloads

07-14-23

Stop Overengineering

07-11-23

Why Frameworks Fail

07-05-23

Avoiding Footguns

07-03-23

Myths About ORMs

06-26-23

Platform Engineering vs. DevOps

06-23-23

What Comes After Kubernetes?

06-19-23

06-02-23

Practical Dependency Management for Developers

05-30-23

Templating Magic Isn't Free

05-27-23

Prompt Engineering is Configuration Engineering

05-23-23

The Local Development Story

05-21-23

The New Tax on Engineering Against the Grain

05-09-23

Why Declarative Build Systems Aren’t Popular

05-07-23

On-Demand Package Manager

05-05-23

ReLLM: Exact Structure for Large Language Model Completions

05-04-23

05-03-23

The Python Family of Languages

05-02-23

WebGPU and the New OS

04-29-23

React Component as the API

04-25-23

16 Lessons from the Tanenbaum–Torvalds Debates

04-24-23

Tanenbaum–Torvalds Debates, Part 1

04-23-23

The ptrace syscall

04-22-23

Building a Kernel From Scratch

04-08-23

The Path Dependence of YAML

03-31-23

Reflections on 10,000 Hours of DevOps

03-28-23

Kubernetes as a Dev Tool

03-20-23

Framework-Defined Infrastructure

03-19-23

The Missing Semester of CS

03-16-23

On OpenAI's Kubernetes Cluster

03-13-23

On Prompt Injection

03-12-23

Local LLaMA on a Mac M1

03-06-23

Applications, Services, and Workflows Overload

02-21-23

02-17-23

Interfaces for Uncertainty

02-13-23

Blurring Language Boundaries

02-07-23

Docker Without Docker

02-06-23

Applications of Gall's Law

02-04-23

01-30-23

The Frontend Bundling Cycle

01-29-23

Type-Safe API Calls: tRPC vs. gRPC

01-26-23

What Doesn't Fit in Git

01-24-23

Workflow Engine Paradigms

01-23-23

Prompt Engineering Shouldn't Exist

01-21-23

How to Version an API

01-18-23

Rebuilding in Rust

01-16-23

The Problem with Drag-n-Drop Infrastructure

01-08-23

Fine-Tuning an OCR Model

12-22-22

Backward Compatibility

12-18-22

12-16-22

Docker as a DevTool Platform

12-14-22

LAION, The Pile, and more datasets

12-13-22

Abstracting the Infrastructure

12-10-22

An Ideal CI/CD System

12-04-22

The Frontend Ouroboros

11-30-22

Do Cold Starts Matter?

11-29-22

Sharing a Notebook

11-28-22

Fuzzy Databases

11-26-22

Technical Posts Overview and Roundup

11-22-22

Why Do Configuration Changes Cause Outages?

11-17-22

Windows Subsystem for Linux

11-13-22

11-12-22

What is a Token? A Technical Explanation

11-09-22

What are Containers?

11-04-22

Mastering the Command Line

10-29-22

Deploy Early, Deploy Often

10-27-22

The Inner Dev Loop

10-24-22

Kubernetes Interfaces

10-22-22

Exploiting Protocols for Fun

10-19-22

AI Scaling Laws

10-11-22

Why Is NixOS Popular Again?

10-10-22

Where Logic Lives

10-07-22

eBPF File Watching

10-06-22

Reentrancy Attacks

10-05-22

Perceptual Hashing

10-01-22

The Promise of Write Once, Run Anywhere

09-29-22

Thoughts on GitHub Actions

09-23-22

Infrastructure Defined Software

09-22-22

09-21-22

Rust, C++, or Carbon?

09-20-22

It's Just a Tarball

09-17-22

Google Infra For Everyone Else in 2022

09-15-22

When To Roll Your Own X

09-13-22

GraphQL Trades Complexity

09-12-22

TensorFlow vs. PyTorch

09-11-22

Recursive-length Prefix (RLP)/Simple Serialize (SSZ)

09-10-22

SQLite Doesn't Use Git

09-09-22

Materializing Results

09-08-22

The Lost Art of System Administration

09-07-22

Performance Comes Last

09-06-22

Two Approaches to Prompt Engineering

09-05-22

09-04-22

Libraries > Languages

08-30-22

The Commoditization of Large Language Models: Part 2

08-27-22

It's Harder to Read Code Than Write It

08-26-22

Developer Platform Table Stakes

08-20-22

Webhooks Aren't So Bad

08-19-22

The Issues with Buildpacks

08-17-22

Tradeoffs in API Design

08-15-22

Cloud Native Localhost

08-14-22

Towards Granular Compute

08-12-22

The Unreasonable Effectiveness of Makefiles

08-10-22

Developers Should Deploy Their Own Code

08-07-22

Component-driven Markup

08-05-22

Will v8 Isolates Coexist With Containers?

08-04-22

The End-to-End Principle in System Design

08-02-22

Open-Source and Quadratic Funding

08-01-22

The New Wave Frontend Toolchain

07-30-22

A First-Class Language Package Manager

07-27-22

Lisp and Spreadsheets

07-25-22

Defensible Machine Learning Model Naming

07-24-22

Fault-Tolerant Design

07-23-22

Non-Obvious Docker Uses

07-22-22

Pull Request is Now the Unit of Review

07-21-22

Presentation Next to Code

07-19-22

The Quick Uptake of ARM on Cloud

07-18-22

Stacked Pull Requests

07-14-22

The Story of CP/M

07-11-22

07-10-22

SSH: Less Relevant In the Cloud

07-08-22

Smart Contract Immutability

07-06-22

How Kubernetes Broke Git

07-05-22

Commoditization of Large Language Models

07-04-22

What Comes After Git

07-03-22

A Look Into My Development Stack

06-29-22

16 Bell-Curve Opinions on Engineering

06-28-22

History of Version Control Systems: Part 3

06-27-22

History of Version Control Systems: Part 2

06-26-22

History of Version Control Systems

06-22-22

How to Use GitHub Copilot Effectively

06-21-22

Least Common Denominator APIs

06-20-22

Every Sufficiently Advanced Configuration Language is Wrong

06-18-22

Plaintext Protocols

06-17-22

Thoughts on RSS

06-14-22

Don't Use Kubernetes, Yet

06-09-22

Are Platform Teams Dead?

06-05-22

Fallacies of Distributed Systems

06-02-22

A Napkin Architecture of Ethereum Interfaces for Developers

05-31-22

Programming to the Interface

05-27-22

ETL vs. Platform Extensibility

05-25-22

Text to Image Diffusion Models

05-23-22

A Universal Package Manager

05-22-22

Smart Contract Language Runtimes

05-21-22

A Short Primer on eBPF

05-17-22

SQLite Renaissance

05-16-22

PaaS Design Principles

05-15-22

The Problem of Sharing Code

05-12-22

Null Programming Philosophy

05-11-22

Future of Passwords

05-10-22

Request for Product: Typescript Docker Construct

05-08-22

Code Managed Service is Coming For Static Sites

05-07-22

Taking on Good Technical Debt

05-06-22

Elevator Data Structures and Algorithms

05-03-22

Miner Extractable Value

05-02-22

{Java,Py}Script

04-25-22

04-20-22

Serverside, or Clientside WASM?

04-15-22

Schema-driven Development

04-13-22

Accidentally Turing Complete

04-12-22

Why So Many Outages?

04-11-22

Language Server Protocols

04-10-22

Plan9: Everything is (Really) a File

04-05-22

Scaling Ethereum: Horizontal/Vertical

04-04-22

Zero Knowledge Proofs

04-03-22

Configuration-to-Code

04-02-22

Engineering Against the Grain

03-31-22

03-27-22

Elliptic Curve Cryptography for Beginners

03-25-22

03-23-22

SaaS is the New Microservices

03-20-22

Embrace. Extend. Extinguish.

03-18-22

Developer Velocity

03-17-22

03-15-22

GitHub Isn't About Code

03-14-22

youtube-dl and Google

03-12-22

Blockchain Trade-offs: Part 3 – Incentives

03-11-22

Blockchain Trade-offs: Part 2 - Privacy

03-10-22

Blockchain Trade-offs

03-07-22

Environment Parity

03-06-22

Wire Protocols and APIs

03-05-22

SPAs weren't a mistake

03-04-22

Latency Numbers You Should Know (2022)

02-28-22

Year 2038 Problem

02-27-22

Software Convention in Consistency

02-25-22

Squash, Merge, or Rebase?

02-18-22

Spectrum of Reproducibility

02-17-22

Shodan and Port-Knocking

02-15-22

Compiled Configuration Stack

02-12-22

Algorithmic Fairness

02-11-22

Why TypeScript for Infrastructure?

02-09-22

Optimization is Fragile

01-29-22

Software Half-Life

01-26-22

Source Code Generation

01-25-22

The Declarative Trap

01-22-22

Software Mullets

01-21-22

Embedded DevOps Teams

01-19-22

Technical Perfection and Irrelevance

01-18-22

Layer Above, Layer Below

01-14-22

Code or Issues in DevOps Platform(s)?

01-13-22

AWS is Not a Dumb Pipe

01-05-22

VPN as a Dev Tool

01-03-22

Pair Programming Doesn't Scale

01-02-22

Increasing Bus Factor

12-27-21

Developer Network Effects

12-23-21

Lost Art of Arch Linux

12-22-21

Hunting Bugs with Bisect

12-19-21

The Real Fix for Log4j Isn't a Patch.

12-18-21

Next-Gen Terminals

12-12-21

Is Open Source Free Riding Bad?

12-11-21

U-Shaped Utility of Monorepos

12-09-21

Toolchain Sprawl

12-04-21

If It Can Be Compiled, It Will Be

12-03-21

Every DevOps Company is an Observability Company

11-30-21

On Centralization

11-26-21

Netlify, Vercel, and AWS Amplify

11-23-21

Shortcomings of Diff3

11-22-21

11-20-21

How to Comment Your Code

11-19-21

The Terrible UX of Git

11-17-21

GitHub's Missing Package Manager

11-16-21

The Collision Course of Databricks and Snowflake

11-12-21

A Browser for Developers

11-10-21

Open Infrastructure

11-09-21

Open-sourced GPT-J

11-07-21

Where is the Edge?

11-05-21

The Next Design Systems

10-27-21

Data Planes and Control Planes

10-22-21

Scoping Developer Tools

10-21-21

IDE as a Platform

10-20-21

Agent vs. Agentless Future

10-19-21

A Short History of the M1 Chip

10-17-21

Alternative Data on Developer Products

10-16-21

Top-Down JAMStack vs. Cloud

10-15-21

The GitLab Upgrade

10-14-21

Takeaways From JetBrain's Developer Survey 2021

10-13-21

Templating: When to Move Along the Heptagon

10-12-21

Kubernetes in the Data Stack

10-10-21

10-09-21

The Changelog Podcast #463

10-08-21

Open Source Reckoning

10-06-21

10-05-21

The Birth & Death of JavaScript

09-30-21

What is RISC-V?

09-26-21

Developer Experience

09-25-21

Knuth and McIlroy Approach a Problem

09-22-21

The Unbundling of the Software Developer

09-21-21

The Problems with "Cloud-Prem"

09-19-21

Remote Developer Environments are Cool Again (Kind of)

09-18-21

Laws of Software Evolution

09-17-21

Infrastructure as SQL

09-16-21

The Data Stack As a Snowflake

09-15-21

How to Calculate a CIDR

09-12-21

Frustrations of Modern Development

09-11-21

Software Treadmills

09-10-21

09-09-21

Ten Things I Look For In a Code Review

09-07-21

09-01-21

An Overview of Docker Desktop Alternatives

08-31-21

Your Integration Tests are Too Long

08-30-21

SaaS Isolation Patterns

08-29-21

Buying IPv4 Addresses

08-26-21

Incremental Compilation in Build Systems

08-24-21

What Low-Code Lacks

08-23-21

Keep Your API Surface Small

08-22-21

Nine Circles of Dependency Hell

08-19-21

Tracking Cyclomatic Complexity

08-17-21

One Month of Using GitHub Copilot

08-16-21

DRY Considered Harmful

08-15-21

08-11-21

Growing Your Open Source Project: Part 3 – Users

08-10-21

Growing Your Open Source Project: Part 2 – Community

08-09-21

Growing Your Open Source Project: Part 1 – Contributors

08-08-21

Service Reliability Math that Every Engineer Should Know

08-07-21

Coding Classical Latin

08-06-21

Confessions of an Internal Tool Builder

08-05-21

Unexpected Developer Trends

08-02-21

Reflections on 10,000 Hours of Programming

07-30-21

How Multiplayer Data Structures Work

07-27-21

Kubernetes Maximalism

07-25-21

The IKEA Effect in Software Development

07-23-21

Functions as a Service

07-20-21

Open-Source and Firm-Specific Training

07-19-21

In Defense of the Jupyter Notebook

07-18-21

07-17-21

Ship Thesean Software

07-15-21

A Personal Internet

07-14-21

Everything is a Graph

07-12-21

Package Managers and Developer Productivity

07-10-21

07-04-21

Makers of Patterns: Part 2

07-03-21

Maker of Patterns: Part 1

07-02-21

What is WebAssembly?

07-01-21

What is MicroSaaS?

06-30-21

Jevons Paradox and Software Efficiency

06-27-21

Code Transparency

06-26-21

Machine Learning Operations (MLOps), Convergent or Divergent?

06-23-21

Live Programming

06-19-21

The End of Per-node Pricing

06-18-21

Software Wants to be Simple

06-15-21

Declarative vs. Imperative

06-14-21

Diseconomies of Scale at Google

06-05-21

The Developer Economy

06-04-21

APIs Will Disrupt Rpa. This Is Obvious to Engineers.

06-03-21

Organic Cloud Infrastructure

06-01-21

Docker Is a Compiler

03-15-21

ScapeNet: Real-time object detection in RuneScape

02-04-21

07-08-20

Virgo: a Graph-based Configuration Language

02-22-19

6 Open Source Licenses That You Shouldn't Use

01-10-19

An Alternative to the Dockerfile

01-02-19

The Heptagon of Configuration

10-22-18

Should Your Developers Work in the Cloud?

10-11-18

Fast Kubernetes Development with File Sync and Smart Rebuilds

10-06-18

Unit Testing with the Kubernetes Client Library