Hello, World! on Rodaine

Go Module Rename & V2 Release

Tue, 16 May 2023 00:00:00 +0000

Today, I’m working on a project that intends to both rename a Go module and cut a v2 release (all while keeping main as the default branch). Why do both? Essentially rebranding without losing existing links.

In any case, before attempting this level of shenanigans, I wanted to make sure that it worked (spoiler alert: it did). Below are the steps I followed that got me there using a dummy repository:

A sh, shebang, and pipefail fail

Tue, 10 Nov 2020 00:00:00 +0000

It could be argued this falls squarely under RTFM, but in any case this was a bit of a wild ride.

At work, we have a piece of software that receives a shell script via an API and executes it. Simple enough. The script looked something like this:

#!/usr/bin/env bash
set -eu
# do some real work
echo "done!"

I needed to do some refactoring in that script. Mostly out of habit, I also added the pipefail option alongside my changes.

Static vs Dynamic Linking in Go

Tue, 03 Nov 2020 00:00:00 +0000

Ran into some linking weirdness with a couple of Go binaries from a seemingly innocuous change. Suppose you have some code that depends on some C bindings. The simplest such program would be:

package main

import "C"

func main() { /* … */ }

Building this on linux/amd64, you get a dynamically-linked binary:

$ go build -o my.bin

$ file my.bin
my.bin: … , dynamically linked, …

To make this static, you can tell go build to pass the right flags to the C linker:

git checkout -

Fri, 23 Oct 2020 00:00:00 +0000

I am already familiar with cd -, which I use often to toggle between two directories. In zsh with setopt AUTO_CD, this is even shorter: -. Mechanically, it’s pretty simple. When you cd into a directory, the previous directory is first set to $OLDPWD. A call to cd - swaps $PWD and $OLDPWD. Easy-peasy.

So, definitely chuffed to discover git checkout - toggles between branches the current and last branch! How it operates is a bit more complicated.

Break The Golang Context Chain

Thu, 30 Jul 2020 00:00:00 +0000

Go 1.21 Update: Apparently alongside me writing this article, the Go project was tracking this very same issue. Comments in the thread bring up some very valid concerns with this pattern beyond the caveats I cover below, but ultimately the feature is now part of the Go 1.21 changeset as context.WithoutCancel.

Recently, I recalled a useful pattern that’s cropped up a few times at work. API handlers (think http.Handler), include a context.Context tied to the connectivity of the caller. If the client disconnects, the context closes, signaling to the handler that it can fail early and clean itself up. Importantly, the handler function returning also cancels the context.

The X-Files: Avoiding Concurrency Boilerplate With golang.org/x/sync

Wed, 15 Aug 2018 00:00:00 +0000

Go makes concurrent programming dead simple with the go keyword. And, with its “share memory by communicating” mantra, channels perform as a thread-safe mechanism for IO between threads. These primitives more than meet the demands of most parallel tasks.

But sometimes workloads need extra coordination, particularly around error propagation or synchronization. For example, goroutines often need access to a shared yet thread-unsafe resource. Enter the standard library’s sync package with WaitGroup, Once, and Mutex. For the brave of heart, sync/atomic beckons. These utilities along with channels annihilate data races, but can result in a lot of nuanced boilerplate. Wouldn’t it makes sense to lift this code into portable abstractions?

The X-Files: Controlling Throughput with rate.Limiter

Mon, 22 May 2017 00:00:00 +0000

In this first X-Files post, I’ll cover the simple yet powerful golang.org/x/time/rate. This package provides a Limiter that controls throughput to an arbitrary resource. There’s a ton of utility in rate, and to show its virtues, I will use it to enforce an SLA on an HTTP service.¹

SLAs and Rate Limiting

When creating a new service, it is prudent to specify a service level agreement, or SLA. This promises an expected availability given some throughput from consumers. The benefits of an SLA are twofold. First, it provides a metric by which the success of a service is measurable. Is it exceeding expecations, or are changes necessary to achieve the SLA? Second, it is enforceable as a means to protect upstream dependencies (like a database) from a cascading failure. One of the simplest ways to impose such an SLA is rate limiting incoming requests.

The X-Files: Exploring the Golang Standard Library Sub-Repositories

Sun, 21 May 2017 00:00:00 +0000

This post will be the start of The X-Files, a blog series exploring the Go sub-repositories located at golang.org/x/*. Chances are, you may not have heard them called that before or know where they came from. Introductions are in order…

A brief origin story

Go promises, with reasonable exceptions, that its compiler and standard library will remain forward-compatible for all minor releases of the Go 1 language specification. This is incredibly refreshing, especially if you’ve ever used a framework or language that seems to break the world on every patch release. While perhaps this makes Go boring, it permits developers to confidently use the language and stdlib, leaving the core team to focus on performance in the compiler, optimizations to the garbage collector, and other quality-of-life improvements.

Asynchronously Split an io.Reader in Go (golang)

Sat, 25 Apr 2015 00:00:00 +0000

I have fallen in love with the flexibility of io.Reader and io.Writer when dealing with any stream of data in Go. And while I am more or less smitten at this point, the reader interface challenged me with something you might think simple: splitting it in two.

I’m not even certain “split” is the right word. I would like to receive an io.Reader and read over it multiple times, possibly in parallel. But because readers don’t necessarily expose the Seek method to reset them, I need a way to duplicate it. Or would that be clone it? Fork?!

Develop Locally with WordPress

Mon, 14 Oct 2013 00:00:00 +0000

There seems to be a common complaint that working on WordPress plugins and themes locally is difficult to accomplish. If you only need to manage a handful of plugins or a couple themes, the tedium of setting up a dev environment isn’t too complicated; you would probably just have a single install of WP on a MAMP server. As my 8th-grade english teacher would say: done, like a cupcake!

Things start to get real messy, though, when you manage 20+ client projects including custom themes, plus a slew of shared plugins between them. Throw in source control (this should go without question, but I hope you’re using source control), and you have a nightmarish franken-MAMP that requires so much overhead to switch between themes and plugins it’s just not worth the effort. Next thing you know, you’re cowboy-coding on a live site in an alleyway with an ancient MacBook with broken (, - and [ keys. Or so I’ve been told…

Add A Custom WordPress Admin Contextual Help Menu To Your Plugin Or Theme

Wed, 25 Sep 2013 00:00:00 +0000

New post on the CNP Blog today covering a little-known (or perhaps little-used) feature of the WordPress Admin: custom contextual help tabs…

If you are familiar with the WordPress admin, you probably noticed the “Help” tab at the top right of nearly every screen. Clicking this little gem reveals a series of helpful topics related to the current page. For example, on the Dashboard, the tab offers an overview of what’s currently displayed, how to navigate the admin in general and what the different boxes on the screen do. This information is invaluable to a new user of WordPress and stays politely out of the way for the more experienced.

Experimenting with Canvas and requestAnimationFrame

Tue, 17 Sep 2013 00:00:00 +0000

See the Pen by @rodaine on CodePen.

Recently at work, I was checking out some designs for a client’s print piece, and was struck by this mesmerizing geometric pattern in the background. I mentioned to Taylor Gorman that it’d be awesome if – when these designs were translated to their site – the background was animated similar to the old bezier screensaver that used to come with Windows (it might still do?).

How to Report a Bug to a Web Developer

Tue, 10 Sep 2013 00:00:00 +0000

Over on the CNP Blog, I contributed a post meant specifically for our clients: a guide on how to report bugs to web developers:

Oftentimes, this process is slowed, to the frustration of everyone involved, by a lack of information about the problem. So I implore you, dear reader, to take a few minutes to familiarize yourself with the following questions and the reasons why they are important to debugging a website. If you can answer any of these, your developer will be grateful and will likely be able to make the changes faster…

Untangle HTML and Javascript using Dependency Injection

Tue, 16 Jul 2013 00:00:00 +0000

On the CNP Blog today, I wrote a post outlining a technique for dependency injection in JavaScript. We’ve all been there in a JS project: a series of simple, innocuous event bindings explodes into thousands of lines of unmanageable code so reliant on the markup that making changes potentially generates more bugs than it fixes. Hyperbole? Perhaps not:

For small projects with minimal JavaScript, abstraction of this nature is unnecessary, but as soon as the project grows to more than a few hundred lines with many moving parts, managing the code and its relationship to the markup becomes exponentially more difficult. Implementing changes, new features and bug fixes might have unintended side effects that slow down development and produce serious code smell. By decoupling the DOM from the JavaScript and using dependency injection to associate functionality with the elements on the page, we can easily improve the quality of our code and make it more flexible, testable and reusable across projects.

404: Not Found

Mon, 01 Jan 0001 00:00:00 +0000

About Me