How we overvalue the wrong technology and novel aspects of interface design at the expense of substantial gains to our productivity.
A lightweight and stack agnostic operational technique for easy visibility into production systems.
Why and how to put limits and rate limits on your web services. Introducing redis-cell.
Error handling and fragility; or why a worker pool belongs in Go's standard library.
The missing README for how to get started with Postgres development.
The case for a concerted effort to build a powerful, but streamlined, platform on AWS.
Building a static site on AWS with a global CDN, free HTTPS with automatic certificate renewal, and a CI-based deployment process powered by GitHub pull requests.
Notes on the language after spending a few weeks building a large project in it.
Getting a certificate that most browsers would accept used to be difficult and expensive, but that's changing as we enter a relative golden age of web encryption. Read this for options for getting certificates issued for free.
Some of my favorite practices and ideas from almost four years at Heroku.
Using backslash commands in psql to navigate and describe object hierarchy in Postgres and Redshift.
Crunching running data with prepared statements in Postgres.
Implementing rate limiting using Generic Cell Rate Algorithm (GCRA), a sliding window algorithm without a drip process.
A set of general guidelines to consider when designing a alerts for a production system.
How Postgres' concurrency model coupled with long-lived transactions can degrade the performance of indexes on hot tables in your database.
A short write-up on findings, limitations, and opinion on Kinesis after a month in production.
Splitting and merging in action.
On guaranteeing order with the bulk put API of an event stream.
A simple mechanism for managing changes to a web API and to help cheapen the disposal of prototypes.
A few words on the Unix philosophy of building small programs that do one thing well, and compose for comprehensive functionality.
Learn how to start encrypting dotfile secrets with GPG, and some techniques for getting those encrypted files integrated with your toolchain.
Understanding the benefits of Golang's restrictive (but simple) import and package management system.
An exercise of discovery around how to extend the shell's API.
Data warehouses aren't just for the enterprise! Let's examine a few of their basic characteristics, and build some examples with Go/Ruby and Postgres.
If you find that the price tag for a Fuji-official adapter ring for the X100S is a little hard to swallow, this 5-minute hack will save you 90%.
A quick tour through some of the fundamentals of JSON Schema and Hyper-schema, and how they can be applied to building APIs.
Stubbing distributed services with Sinatra-based services stubs and enabling stronger constraints with JSON Schema.
Useful distinction or new buzzword? Comments on 200-500 line services.
Interactors by a different name.
When the use of an anti-pattern is considered beneficial.
When building an app against a web API, do you pull in their SDK or just make raw HTTP calls? Here are a few reasons that I avoid SDKs when I can.
In search for (and the discovery of) an alternative to BreakTime.
How the page almost transitioned successfully to the digital world, but is in decline in the modern context of new media. The lessons that we can learn from this age-old design element, and why we should hope for its re-emergence.
A logging format used inside companies such as Heroku and Stripe which is optimal for easy development, consistency, and good legibility for humans and computers.
A set of patterns to make APIs more accessible to developers; lowering the barrier of entry for new users, and easing the maintenance of consuming applications.
Designing scope for Heroku OAuth, and a brief tour of other implementations on the web.
How we build minimal, platform deployable, Rack service stubs to take the pain out of developing applications that depend on an extensive service-oriented architecture.
A simple pattern for tracing requests across a service-oriented architecture by injecting a UUID into the events that they produce.
Most of my older work can be found on Mutelight.