Matt Rickard
About
Posts
Subscribe
Matt Rickard
About
Posts
Subscribe

most popular engineering startups misc ai all

10-03-23

Pitfalls of Database Migrations

10-02-23

Generative Interfaces

10-01-23

Lessons From Debugging

09-30-23

Compression / Learning Duality

09-29-23

Is AI a Platform Shift?

09-28-23

Passkeys, Crypto, and Signing AI Content

09-27-23

Is Data Still a Moat?

09-26-23

Multi-Modal AI is a UX Problem

09-25-23

Observer-Expectancy at Scale

09-24-23

LLMs as System 1 Thinkers

09-23-23

The Fundamental Attribution Error

09-22-23

Good Enough Abstractions

09-21-23

Automate (But Automate Last)

09-20-23

09-19-23

Customized End User Software (with AI)

09-18-23

Five Principles from Renaissance Technologies

09-17-23

Moving Upmarket

09-16-23

The Age-old Resistance to Generated Code

09-15-23

09-14-23

Undetectable AI

09-13-23

The New Economics of Generating Code

09-12-23

The Inevitability of Scope Creep

09-11-23

Fine-tuning Stable Diffusion XL with Personal Photos

09-10-23

The Low-Hanging Fruit

09-09-23

Beyond Prompt Engineering

09-08-23

The Hardware / Software Cycle

09-07-23

Raft: The Distributed Systems Algorithm

09-06-23

The Widgetification of Apple

09-05-23

Type Constraints for LLM Output

09-04-23

09-03-23

Technical Metrics to Track in Engineering Orgs

09-02-23

TypeScript Type System Hacks

09-01-23

Capital Intense AI Bets

08-31-23

Imputavi, Computavi, Putavi.

08-30-23

Llama 2 in the Browser

08-29-23

The Contrarian Strategy of OpenAI

08-28-23

GitHub Inbox as GTM

08-27-23

AI and Text-First Interfaces

08-26-23

The Business Source License

08-25-23

The Free Lunch of Model Distillation

08-24-23

Adding Constraints

08-23-23

Copy and Paste Libraries

08-22-23

Beating the Average

08-21-23

A Model API Gateway for 20+ LLMs

08-20-23

08-19-23

The Truth About GPU Utilization

08-18-23

Directly Responsible Individuals

08-17-23

Akin's Laws of Spacecraft Design

08-16-23

What is a Prompt Engineer?

08-15-23

Learning Via Negativa

08-14-23

Why Tailwind CSS Won

08-13-23

My Everyday LLM Uses

08-12-23

Dark Mode and Marginal Benefit

08-11-23

08-10-23

Deterministic, Structured LLM Output

08-09-23

08-08-23

A Fine-Tuning Marketplace

08-07-23

Majority Rule Developers

08-06-23

NVIDIA's CUDA Monopoly

08-05-23

Prescriptive vs. Descriptive Feedback

08-04-23

Focus On What Could Go Right (Not Wrong)

08-03-23

Apple's Hidden Social Network

08-02-23

Data Versioning

08-01-23

Automatic and Universal Adversarial Prompts

07-31-23

Minimum Effective Dose and Discrete Outcomes

07-30-23

07-29-23

Git Merge Strategies and Algorithms

07-28-23

Modern Samizdat Libraries

07-27-23

07-26-23

Black Swan Theory

07-25-23

Optimizing $Model.cpp

07-24-23

Commonplace Books

07-23-23

Virtual Machines and Path Dependence

07-22-23

On Getting Married

07-21-23

The RLHF Advantage

07-20-23

Robots.txt for LLMs

07-19-23

Why Did Meta Open-Source Llama 2?

07-18-23

Diffusion of Innovation

07-17-23

Literate Programming with LLMs

07-16-23

Schopenhauer's 36 Stratagems for Winning Arguments

07-15-23

Scale to Zero for AI Workloads

07-14-23

Stop Overengineering

07-13-23

Hard Launches vs. Soft Launches

07-12-23

Virtualized Linux on macOS Internals

07-11-23

Why Frameworks Fail

07-10-23

Categorization and Classification with LLMs

07-09-23

Towards Technical CEOs

07-08-23

ActivityPub, Decentralization - Do Users Care?

07-07-23

The Anti-AI Movement

07-06-23

Customer Obsession is the Only Winning Strategy

07-05-23

Avoiding Footguns

07-04-23

Where AI Fits in Engineering Organizations

07-03-23

Myths About ORMs

07-02-23

Google Search's Death by a Thousand Cuts

07-01-23

The Circular Startup Economy

06-30-23

Personal Lessons From LLMs

06-29-23

Overcoming LLM Hallucinations

06-28-23

Monopolizing Useless Resources

06-27-23

06-26-23

Platform Engineering vs. DevOps

06-25-23

Model Evaluation is (Still) An Art

06-24-23

Clear, Simple, and Wrong

06-23-23

What Comes After Kubernetes?

06-22-23

No Feature is Free (Especially AI Ones)

06-21-23

Mixture of Experts: Is GPT-4 Just Eight Smaller Models?

06-20-23

The LLaMA Ecosystem

06-19-23

06-18-23

Unforced Errors

06-17-23

The Low-Background Steel of AI

06-16-23

Why Does Every AI Cycle Start With Chat?

06-15-23

A Token Efficient Language for LLMs

06-14-23

Keep The Main Thing The Main Thing

06-13-23

ControlNet QR Codes

06-12-23

It’s Too Early To Call Winners in AI

06-11-23

The Last Innings of Web 2.0

06-10-23

Biography of an Idea

06-09-23

The Myth of the AI Infrastructure Phase

06-08-23

LLMs For Software Portability

06-07-23

ChatGPT Plugins Don't Have PMF

06-06-23

Levels of Autonomy in AI Agents

06-05-23

The Problem with Tokenization in LLMs

06-04-23

What Diffusion Models Can Teach Us About LLMs

06-03-23

Sequence and Version Control Models

06-02-23

Practical Dependency Management for Developers

06-01-23

The End of Public APIs

05-31-23

Faster Horses: AI Products That Companies Think They Want

05-30-23

Templating Magic Isn't Free

05-29-23

AI Means More Developers

05-28-23

Two Years of Daily Blogging

05-27-23

Prompt Engineering is Configuration Engineering

05-26-23

05-25-23

A List of Things I Was Wrong About

05-24-23

The ChatGPT Plugin Specification

05-23-23

The Local Development Story

05-22-23

Twitter and the Idea Maze

05-21-23

The New Tax on Engineering Against the Grain

05-20-23

05-19-23

On Regulating AI

05-18-23

05-17-23

A List of Leaked System Prompts

05-16-23

Intercloud Brokers

05-15-23

React LLM: Run Models in the Browser with Headless Components

05-14-23

Context-Free Grammar Parsing with LLMs

05-13-23

Taylor Swift and Launch Cadence

05-12-23

StackOverflow/ChatGPT

05-11-23

Self-hosted Compilers and Bootstrapped AI

05-10-23

Unix Philosophy for AI

05-09-23

Why Declarative Build Systems Aren’t Popular

05-08-23

The New AI Moats

05-07-23

On-Demand Package Manager

05-06-23

Second-level Thinking

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

05-01-23

Applications of Category Theory

04-30-23

Implementing LLMs in the Browser

04-29-23

React Component as the API

04-28-23

Why Multi-Cloud Failed

04-27-23

Principle of Least Astonishment

04-26-23

Probabilistic Data Structures and LLMs

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-21-23

Autonomous LLM Agents Are At Least 10 Years Out

04-20-23

Peanut Butter Manifesto (2006)

04-19-23

Sandbox Your Prompts

04-18-23

Stochastic/Deterministic

04-17-23

Jevons Paradox and LLMs

04-16-23

Everyday Fourier Transforms

04-15-23

On The Shortness Of Life

04-14-23

Synthetic Data From Compilers

04-13-23

Foundational Models Are Not Enough

04-12-23

Imperative, Declarative, Interrogative, and Exclamatory Interfaces

04-11-23

But / Therefore

04-10-23

A List of 1 Billion+ Parameter LLMs

04-09-23

No GPUs before Product-Market Fit

04-08-23

The Path Dependence of YAML

04-07-23

Buyers in the Foundational Model Stack

04-06-23

Internet Magic Numbers

04-05-23

A High-level LLMOps Architecture

04-04-23

Reasons To Do a Startup

04-03-23

The Automation Frontier

04-02-23

Why Open-Source a Model?

04-01-23

Consumption Pricing Units in AI

03-31-23

Reflections on 10,000 Hours of DevOps

03-30-23

The AI Partnership Race

03-29-23

A Hacker's Guide to LLM Optimization

03-28-23

Kubernetes as a Dev Tool

03-27-23

Code, not Chat, in Generative AI

03-26-23

Distributed Systems and AI

03-25-23

Necessary Conditions for an App Store Monopoly

03-24-23

03-23-23

Are Incumbents Accruing All The AI Value?

03-22-23

Model Arbitrage

03-21-23

Modeling Context Length vs. Information Retrieval Cost in LLMs

03-20-23

Framework-Defined Infrastructure

03-19-23

The Missing Semester of CS

03-18-23

The Value of Software Generalists

03-17-23

Foundational Models Are Commodities

03-16-23

On OpenAI's Kubernetes Cluster

03-15-23

Choosing the Right Model

03-14-23

Gell-Mann Amnesia

03-13-23

On Prompt Injection

03-12-23

Local LLaMA on a Mac M1

03-11-23

Automatic1111 and AI Aggregators

03-10-23

03-09-23

Chain of Thought Paradigms in LLMs

03-08-23

Data Local Machine Learning

03-07-23

03-06-23

Applications, Services, and Workflows Overload

03-05-23

Will The AI Stack Be Open Or Closed?

03-04-23

The Stoic Arrow

03-03-23

Product Windows

03-02-23

ChatML and the ChatGPT API

03-01-23

The Bundling of the Software Developer

02-28-23

Shells and Distribution

02-27-23

More Art than Science

02-26-23

Wrong Sequences For Startups

02-25-23

Commoditization of Large Language Models: Part 3

02-24-23

Taxonomy of Startup Risk

02-23-23

The Connectors/Loaders Trap

02-22-23

Erdős Vocabulary

02-21-23

02-20-23

Amdahl's Law and Optimization

02-19-23

Why Python Won't Be the Language of LLMs

02-18-23

Nix Is Fighting The Last War

02-17-23

Interfaces for Uncertainty

02-16-23

Why ChatGPT Needs AuthZ

02-15-23

Ask Yourself Dumb Questions

02-14-23

Carrying a Dozen Problems

02-13-23

Blurring Language Boundaries

02-12-23

LLM Ops, Part 1

02-11-23

What Won't Change

02-10-23

Multi-Model vs. Multi-Cloud

02-09-23

Should OSS Projects Have Telemetry?

02-08-23

Reactive Strategy

02-07-23

Docker Without Docker

02-06-23

Applications of Gall's Law

02-05-23

Composable Models

02-04-23

02-03-23

If It Doesn’t Ship, It Doesn’t Exist

02-02-23

Optimal Stopping Theory

02-01-23

Future is Not Evenly Distributed

01-31-23

Zero Interest Rate Policy Phenomena

01-30-23

The Frontend Bundling Cycle

01-29-23

Type-Safe API Calls: tRPC vs. gRPC

01-28-23

Overview of GPT-as-a-Backend

01-27-23

Eisenhower Priority Matrix

01-26-23

What Doesn't Fit in Git

01-25-23

Cloud Services Ranked: Build vs. Buy

01-24-23

Workflow Engine Paradigms

01-23-23

Prompt Engineering Shouldn't Exist

01-22-23

01-21-23

How to Version an API

01-20-23

01-19-23

Cloud Spend Breakdown

01-18-23

Rebuilding in Rust

01-17-23

All Models Are Wrong (But Some Are Useful)

01-16-23

The Problem with Drag-n-Drop Infrastructure

01-15-23

Output vs. Outcome

01-14-23

Garbage In, Garbage out?

01-13-23

Winning Ugly and The Metagame

01-12-23

Minix and nanoGPT

01-11-23

Fully Managed Infrastructure

01-10-23

Lessons from the Last AI Cycle

01-09-23

01-08-23

Fine-Tuning an OCR Model

01-07-23

Semi-Organic Growth

01-06-23

What's Next After NextJS

01-05-23

RPA: The Human Interface

01-04-23

The Implications of More Developers

01-03-23

Counterfactuals

01-02-23

01-01-23

Top Posts of 2022

12-31-22

2023 Predictions

12-30-22

Local AI: Part 2

12-29-22

Local AI: Part 1

12-28-22

Reflections on 2022 Predictions

12-27-22

Proebsting's Law

12-26-22

Turing Social: Twitter, For Bots

12-25-22

12-24-22

Shortest Time-to-Launch

12-23-22

Software Rewrites

12-22-22

Backward Compatibility

12-21-22

ML Developer Experience

12-20-22

The Architecture of Mastodon

12-19-22

How Did Microsoft Win Back Devs?

12-18-22

12-17-22

The Fall of Freenode

12-16-22

Docker as a DevTool Platform

12-15-22

AI-driven Interfaces

12-14-22

LAION, The Pile, and more datasets

12-13-22

Abstracting the Infrastructure

12-12-22

Lessons from Lensa

12-11-22

12-10-22

An Ideal CI/CD System

12-09-22

12-08-22

Spam Filtering AI Content

12-07-22

Google Takeout and Data Portability

12-06-22

Stack Overflow Bans ChatGPT

12-05-22

Will LLMs Disrupt Google Search?

12-04-22

The Frontend Ouroboros

12-03-22

A Conversation with ChatGPT

12-02-22

Apple's Enemies

12-01-22

11-30-22

Do Cold Starts Matter?

11-29-22

Sharing a Notebook

11-28-22

Fuzzy Databases

11-27-22

Human-in-the-Loop and Other AI Mistakes

11-26-22

Technical Posts Overview and Roundup

11-25-22

Schelling Point

11-24-22

Showing Up Every Day

11-23-22

The Cloud Tax Implications

11-22-22

Why Do Configuration Changes Cause Outages?

11-21-22

Excel for Developers

11-20-22

Will Twitter Fail?

11-19-22

Generative AI Value Chain

11-18-22

Amazon's Distributed Computing Manifesto (1998)

11-17-22

Windows Subsystem for Linux

11-16-22

Solving the Simple Case

11-15-22

On the Mastodon Experiment

11-14-22

11-13-22

11-12-22

What is a Token? A Technical Explanation

11-11-22

11-10-22

Information Barbell

11-09-22

What are Containers?

11-08-22

11-07-22

What Happens to Infra Engineers?

11-06-22

Generational Advantages

11-05-22

UGC: User-Generated Code

11-04-22

Mastering the Command Line

11-03-22

Man in the Arena

11-02-22

Who Pays? The Twitter Blue Check

11-01-22

What If Google Builds This?

10-31-22

Facebook's Culture Book (2012)

10-30-22

And Yet it Moves

10-29-22

Deploy Early, Deploy Often

10-28-22

Ethereum RPC as a Service

10-27-22

The Inner Dev Loop

10-26-22

Apple's Ad Positioning

10-25-22

Daily is the Product

10-24-22

Kubernetes Interfaces

10-23-22

Moat By Induction

10-22-22

Exploiting Protocols for Fun

10-21-22

AI Will Write Most Code

10-20-22

Cloud Repatriation or Not?

10-19-22

AI Scaling Laws

10-18-22

Richard Feynman and Narrative

10-17-22

SEC, Gensler, and Crypto

10-16-22

10-15-22

Getting Stuck in the Past

10-14-22

Short Taxonomy of Open-Source Strategies

10-13-22

The Middle Squeeze

10-12-22

A Personal Training Corpus

10-11-22

Why Is NixOS Popular Again?

10-10-22

Where Logic Lives

10-09-22

On Web Clipping

10-08-22

Risk vs. Uncertainty

10-07-22

eBPF File Watching

10-06-22

Reentrancy Attacks

10-05-22

Perceptual Hashing

10-04-22

Free Compute and Replit

10-03-22

Screenshots as the Universal API

10-02-22

The Steffen Boarding Method

10-01-22

The Promise of Write Once, Run Anywhere

09-30-22

Why Stadia Failed

09-29-22

Thoughts on GitHub Actions

09-28-22

Simple Group Theory

09-27-22

Is Ethereum a Dumb Pipe?

09-26-22

Startup Ideas I've Considered

09-25-22

Hard to Compute, Simple to Verify

09-24-22

What's an MVP in 2022?

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-19-22

Standards, Protocols, and Platforms

09-18-22

Is GitHub a Social Network?

09-17-22

Google Infra For Everyone Else in 2022

09-16-22

09-15-22

When To Roll Your Own X

09-14-22

The Innovator's Paradox

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

09-03-22

Parallelizing Programs on the Blockchain

09-02-22

The Unbundling of Twitter

09-01-22

Low-end Disruption of AWS

08-31-22

Why Does Google Kill So Many Products?

08-30-22

The Commoditization of Large Language Models: Part 2

08-29-22

08-28-22

Timeline of Early Email

08-27-22

It's Harder to Read Code Than Write It

08-26-22

Developer Platform Table Stakes

08-25-22

The Value is in the API

08-24-22

Value Accrual in the Crypto Infra Stack

08-23-22

A Short List of Cognitive Biases

08-22-22

r/K Startup Theory

08-21-22

Tool-driven Scientific Revolutions

08-20-22

Webhooks Aren't So Bad

08-19-22

The Issues with Buildpacks

08-18-22

Friction as a Proxy for Value

08-17-22

Tradeoffs in API Design

08-16-22

Teams, Slack, and Discord in Retrospect

08-15-22

Cloud Native Localhost

08-14-22

Towards Granular Compute

08-13-22

The Ethereum Merge

08-12-22

The Unreasonable Effectiveness of Makefiles

08-11-22

Growing the Pie

08-10-22

Developers Should Deploy Their Own Code

08-09-22

Sanctioning a Smart Contract

08-08-22

Braess's paradox

08-07-22

Component-driven Markup

08-06-22

On Unoptimizing

08-05-22

Will v8 Isolates Coexist With Containers?

08-04-22

The End-to-End Principle in System Design

08-03-22

Sufficiently Decentralized

08-02-22

Open-Source and Quadratic Funding

08-01-22

The New Wave Frontend Toolchain

07-31-22

07-30-22

A First-Class Language Package Manager

07-29-22

Brooks in Reverse

07-28-22

Don't Be Scared of Cloud Lock-in

07-27-22

Lisp and Spreadsheets

07-26-22

Adverse Selection Examples

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-20-22

Choosing Esoteric Technology

07-19-22

The Quick Uptake of ARM on Cloud

07-18-22

Stacked Pull Requests

07-17-22

Shannon's Demon

07-16-22

IaC: Strength or Weakness for Cloud Providers?

07-15-22

Sybil Attacks on Airdrops

07-14-22

The Story of CP/M

07-13-22

Hotelling's Law and Differentiation

07-12-22

Distribution in a Downturn

07-11-22

07-10-22

SSH: Less Relevant In the Cloud

07-09-22

So Easy You Could Run It Yourself

07-08-22

Smart Contract Immutability

07-07-22

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

07-02-22

Giving Up Decentralization: Scalability Trilemma

07-01-22

Does Financial Policy Matter?

06-30-22

The Centralization of dYdX

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-25-22

Asset-lite in an Asset-Heavy Business

06-24-22

06-23-22

Panic of 1907/2022

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-19-22

Is Snowflake a Platform?

06-18-22

Plaintext Protocols

06-17-22

Thoughts on RSS

06-16-22

Convergence of DBaaS and BaaS

06-15-22

Path of Least Resistance

06-14-22

Don't Use Kubernetes, Yet

06-13-22

The Last Question

06-12-22

The Cost to Participate In Decentralized Networks

06-11-22

Work Expands to Fill the Space

06-10-22

Web3's Eternal September

06-09-22

Are Platform Teams Dead?

06-08-22

The Surprising Linearity of GitHub Star Growth

06-07-22

The Centralization of Skype

06-06-22

Usage-based Pricing in a Downturn

06-05-22

Fallacies of Distributed Systems

06-04-22

Datadog's State of Serverless

06-03-22

06-02-22

A Napkin Architecture of Ethereum Interfaces for Developers

06-01-22

Product Velocity of Alternative Cloud Platforms

05-31-22

Programming to the Interface

05-30-22

Interface Decomposition in Cloud

05-29-22

Payment for Order Flow in Web3

05-28-22

One Year of Daily Blogging

05-27-22

ETL vs. Platform Extensibility

05-26-22

Computer Tips For Everyday People From a Software Engineer

05-25-22

Text to Image Diffusion Models

05-24-22

List of All Oblique Strategies

05-23-22

A Universal Package Manager

05-22-22

Smart Contract Language Runtimes

05-21-22

A Short Primer on eBPF

05-20-22

Crypto Without Blockchains

05-19-22

Streaming Applications

05-18-22

05-17-22

SQLite Renaissance

05-16-22

PaaS Design Principles

05-15-22

The Problem of Sharing Code

05-14-22

Stablecoin Depegging

05-13-22

Why Did Heroku Fail?

05-12-22

Null Programming Philosophy

05-11-22

Future of Passwords

05-10-22

Request for Product: Typescript Docker Construct

05-09-22

The Economics of Seinfeld

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-05-22

API Aggregators Aggregating Aggregators

05-04-22

Correlation vs. Causation

05-03-22

Miner Extractable Value

05-02-22

{Java,Py}Script

05-01-22

The M:N API Problem

04-30-22

Ethereum Transaction Fees

04-29-22

04-28-22

What's Holding Monorepos Back?

04-27-22

Path Dependence

04-26-22

Improving Twitter

04-25-22

04-24-22

Innovation Tokens

04-23-22

Permissionless Reckoning

04-22-22

Chekhov's Gun of Product Development

04-21-22

Why Do Protocols Win?

04-20-22

Serverside, or Clientside WASM?

04-19-22

Less Sticky SaaS

04-18-22

Only the Paranoid Survive

04-17-22

Stitching Together SaaS

04-16-22

Annus Mirabilis

04-15-22

Schema-driven Development

04-14-22

Cathedral and Bazaar Startups

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-09-22

Every Unix Command Becomes a Startup

04-08-22

Backwardation and Contango

04-07-22

Shift Left: Observability at the Edge

04-06-22

NFT and Email Spam

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

04-01-22

Type 1 and Type 2 Errors

03-31-22

03-30-22

Lagging vs. Leading Indicators

03-29-22

On Standardized Tests

03-28-22

Threat of the Hard Fork

03-27-22

Elliptic Curve Cryptography for Beginners

03-26-22

Carthago Delenda Est

03-25-22

03-24-22

How to Negotiate a Car Lease

03-23-22

SaaS is the New Microservices

03-22-22

Working on the Right Problems

03-21-22

Trends from The Enterprise 30

03-20-22

Embrace. Extend. Extinguish.

03-19-22

03-18-22

Developer Velocity

03-17-22

03-16-22

Problems with Daylight Saving Time

03-15-22

GitHub Isn't About Code

03-14-22

youtube-dl and Google

03-13-22

Sword of Damocles

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-09-22

Exponential Trends

03-08-22

Ignore Sunk Costs

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)

03-03-22

03-02-22

03-01-22

Giving It Away For Free

02-28-22

Year 2038 Problem

02-27-22

Software Convention in Consistency

02-26-22

Why First Mover Advantage is Overrated

02-25-22

Squash, Merge, or Rebase?

02-24-22

Remote Work Zealotry

02-23-22

02-22-22

Don't Ship an Architecture

02-21-22

Total Cost of Ownership and Crypto

02-20-22

Order of Magnitudes

02-19-22

Regression to the Mean

02-18-22

Spectrum of Reproducibility

02-17-22

Shodan and Port-Knocking

02-16-22

What is Dog Fooding, Fish Fooding a Product?

02-15-22

Compiled Configuration Stack

02-14-22

Cutting Out the Middleman

02-12-22

Algorithmic Fairness

02-11-22

Why TypeScript for Infrastructure?

02-10-22

Rickard's Law of Eponymy

02-09-22

Optimization is Fragile

02-08-22

02-07-22

Platform vs. Publishers

02-06-22

Onion Futures Act and Saturated Channels

02-05-22

Commoditized Trust

02-04-22

02-03-22

Behind the $325mm Blockchain Hack

02-02-22

Rethinking the PDF

02-01-22

Okta's 2022 Business at Work

01-31-22

Keynesian Beauty Contest

01-30-22

Building the VPC Layer for Cloud

01-29-22

Software Half-Life

01-28-22

Flying-Car Syndrome

01-27-22

Dumb (and Free) Interchange

01-26-22

Source Code Generation

01-25-22

The Declarative Trap

01-24-22

S3 Isn't Getting Cheaper

01-23-22

Negative Value Features

01-22-22

Software Mullets

01-21-22

Embedded DevOps Teams

01-20-22

Antitrust Opportunity

01-19-22

Technical Perfection and Irrelevance

01-18-22

Layer Above, Layer Below

01-17-22

01-16-22

Notes from Behind the Cloud

01-15-22

Best Tech Acquisitions of All Time

01-14-22

Code or Issues in DevOps Platform(s)?

01-13-22

AWS is Not a Dumb Pipe

01-12-22

Reversing the Chicago River

01-11-22

Veto Power and Decision-Making Process

01-10-22

Too Cheap to Meter

01-09-22

Maxwell's Equations and Bridges

01-08-22

The Story of Adobe

01-07-22

Wordle: What's the Best Starting Word?

01-06-22

Losing Sleep Over Java

01-05-22

VPN as a Dev Tool

01-04-22

Strategy Beyond Markets

01-03-22

Pair Programming Doesn't Scale

01-02-22

Increasing Bus Factor

01-01-22

Antifragile in 2022

12-31-21

2022 Predictions

12-30-21

Expert Networks

12-29-21

Open Customer Data

12-28-21

Russell Conjugation and The Great Rebranding

12-27-21

Developer Network Effects

12-26-21

Virtual Reality this Christmas

12-25-21

Capturing Digital Identity

12-24-21

Ownership in the Twenty-First Century

12-23-21

Lost Art of Arch Linux

12-22-21

Hunting Bugs with Bisect

12-21-21

Twitch's Gini Coefficient

12-20-21

12-19-21

The Real Fix for Log4j Isn't a Patch.

12-18-21

Next-Gen Terminals

12-17-21

12-16-21

Top 10 Posts of 2021

12-15-21

90% of Everything is Crap

12-14-21

Unused Gift Cards are Great Business

12-13-21

Metaverse and Other Words from Science Fiction

12-12-21

Is Open Source Free Riding Bad?

12-11-21

U-Shaped Utility of Monorepos

12-10-21

The Leopard of Kilimanjaro

12-09-21

Toolchain Sprawl

12-08-21

Hollywood Accounting

12-07-21

Direct Registration System (DRS)

12-06-21

The Toyota Production System

12-05-21

It's Impossible to Design a Watch that Only Tells Time

12-04-21

If It Can Be Compiled, It Will Be

12-03-21

Every DevOps Company is an Observability Company

12-02-21

The Most Entertaining Outcome is the Most Likely

12-01-21

Jane Jacobs and Software Engineering

11-30-21

On Centralization

11-29-21

Achilles and the Tortoise

11-28-21

Calculating Willingness to Pay

11-27-21

Browse Now, Pay Later

11-26-21

Netlify, Vercel, and AWS Amplify

11-25-21

Cloud Marketplaces

11-24-21

The Sailing Ship Effect

11-23-21

Shortcomings of Diff3

11-22-21

11-21-21

The Gordian Knot

11-20-21

How to Comment Your Code

11-19-21

The Terrible UX of Git

11-18-21

Being Wrong on Hacker News

11-17-21

GitHub's Missing Package Manager

11-16-21

The Collision Course of Databricks and Snowflake

11-15-21

Mining Crypto on My M1 Max

11-14-21

No Time to Read Bad Books

11-13-21

The Goat Behind the Door

11-12-21

A Browser for Developers

11-11-21

How to Beat Google Search

11-10-21

Open Infrastructure

11-09-21

Open-sourced GPT-J

11-08-21

11-07-21

Where is the Edge?

11-06-21

The Cloud Cost Era

11-05-21

The Next Design Systems

11-04-21

Rich Barton and Zillow

11-03-21

11-02-21

Niche Communities

11-01-21

I Miss The Programmable Web

10-31-21

Chesterton's Fence

10-30-21

Cloud Growth in 2021

10-29-21

10-28-21

Technical Wedges

10-27-21

Data Planes and Control Planes

10-26-21

Kelly Criterion

10-25-21

Remote Work for Developers

10-24-21

Solving Supply Chain with a Tweet

10-23-21

How Complex Systems Fail

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-18-21

Zuckerberg on Platforms

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-11-21

Calculating SaaS Retention

10-10-21

10-09-21

The Changelog Podcast #463

10-08-21

Open Source Reckoning

10-07-21

10-06-21

10-05-21

The Birth & Death of JavaScript

10-04-21

Sales Compensation at GitLab

10-03-21

10-02-21

Egregious Egress and Disruption

10-01-21

The Puzzling Corporate Archaeology of MIPS

09-30-21

What is RISC-V?

09-29-21

Extending Applications with WebAssembly

09-28-21

A Hypothesis is a Liability

09-27-21

Go-to-market Strategy

09-26-21

Developer Experience

09-25-21

Knuth and McIlroy Approach a Problem

09-24-21

Commoditizing Your Complements in the Cloud Era

09-23-21

A Public Public Company

09-22-21

The Unbundling of the Software Developer

09-21-21

The Problems with "Cloud-Prem"

09-20-21

Thinking Like a Contrarian With Counter-Positioning

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-14-21

Email is Back in Vogue

09-13-21

Net Dollar Retention

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-08-21

The Mother of All Demos

09-07-21

09-06-21

09-05-21

09-04-21

Are Ideas Getting Harder to Find?

09-03-21

Product-Led Sales Efficiency at GitLab

09-02-21

Different Types of Software Containers

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-28-21

08-27-21

The Clever Hans Effect

08-26-21

Incremental Compilation in Build Systems

08-25-21

The Map is Not The Territory

08-24-21

What Low-Code Lacks

08-23-21

Keep Your API Surface Small

08-22-21

Nine Circles of Dependency Hell

08-21-21

History of Silicon Valley: 1891-1956

08-20-21

Potential Energy in Startups

08-19-21

Tracking Cyclomatic Complexity

08-18-21

Hire for slope, not Y-Intercept

08-17-21

One Month of Using GitHub Copilot

08-16-21

DRY Considered Harmful

08-15-21

08-14-21

Cheap and Expensive

08-13-21

Non-Consensus Right

08-12-21

Signaling Against Asymmetric Markets

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-04-21

Real Options Valuation

08-03-21

Silence Dogood and the Ben Franklin Effect

08-02-21

Reflections on 10,000 Hours of Programming

08-01-21

Economics of Bundling and Unbundling

07-31-21

07-30-21

How Multiplayer Data Structures Work

07-29-21

07-28-21

Don't Break the Chain

07-27-21

Kubernetes Maximalism

07-26-21

How to Spot a Made Up Number

07-25-21

The IKEA Effect in Software Development

07-24-21

Why The Dow Jones is a Lousy Index

07-23-21

Functions as a Service

07-22-21

Orthogonal or Parallel Problems

07-21-21

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-16-21

A History of 'Welcome, seriously' Ads

07-15-21

A Personal Internet

07-14-21

Everything is a Graph

07-13-21

The Potato Paradox

07-12-21

Package Managers and Developer Productivity

07-11-21

JEDI Mind Tricks

07-10-21

07-09-21

Avoiding People at Work

07-08-21

07-07-21

07-06-21

Dynamics of Switching Costs

07-05-21

High-Velocity Decision-Making

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-29-21

Steven P. Jobs and Pixar Employees Buy Pixar

06-28-21

Survivorship Bias

06-27-21

Code Transparency

06-26-21

Machine Learning Operations (MLOps), Convergent or Divergent?

06-25-21

Foundational Products

06-24-21

How Startups Grew by Platform Hacking

06-23-21

Live Programming

06-22-21

Reducing Errors in Decision-Making

06-21-21

First Principles

06-20-21

Platform Advantage: Velocity

06-19-21

The End of Per-node Pricing

06-18-21

Software Wants to be Simple

06-17-21

Observations of the Lindy Effect

06-16-21

Everything is a Browser

06-15-21

Declarative vs. Imperative

06-14-21

Diseconomies of Scale at Google

06-13-21

Asynchronous Communication

06-12-21

The Post-Modern Web

06-11-21

Why Developers Will Win the Creator Economy

06-10-21

Build a Team of Rivals

06-09-21

Comparative Advantage and Why PMs Shouldn't Write SQL Queries

06-08-21

The Case For XCode Cloud

06-07-21

Problem Solving Techniques from Math

06-06-21

Getting to Market With Rails

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-02-21

Usage or Subscription Pricing

06-01-21

Docker Is a Compiler

05-31-21

Inorganic Growth at Zynga

05-30-21

05-29-21

What's Measured Gets Managed

05-28-21

Why Do Companies That Sell APIs Have Such Low Churn Rates?

03-15-21

ScapeNet: Real-time object detection in RuneScape

02-04-21

12-12-20

Sales Calculus, Part 1: Scaling

07-09-20

Is Technology Making Us More Productive?

07-08-20

Virgo: a Graph-based Configuration Language

07-05-20

The Negative Operating Cycle

02-26-19

Reproducibility in Practice

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-08-18

Offline is a Feature, Not a Product

10-06-18

Unit Testing with the Kubernetes Client Library