At ZipRecruiter my team is
hard at work making Kubernetes our production platform. This is an incredible
effort and I can only take the credit for very small parts of it. The issue
that I was tasked with most recently was to verify and transform Kubernetes
manifests; this post demonstrates how to do that reliably.

I’ve been spending some time the past couple of weeks playing with some of my
personal Go tools. Nearly
everything I did involved concurrency, for a change. I’ll document how I did it
and some of the wisdom I’ve gathered from others here.

At work I’m building a little
tool to write data from AWS Secrets
Manager
to a directory on disk. I wrote a little package to write the secrets
atomically, because that seemed safest at the time. In retrospect just writing
each file atomically probably would have been good enough. Code and discussion
are below.

A few weeks ago when I was reading The
Go Programming Language I was reading about buffered channels and had a gut instinct
that I could write some code taking advantage of them in a precise way.
This was the comical code that came out of it.

Yesterday I wanted to graph some data by date but I didn’t want to mess with
spreadsheet software or other graphing libraries. I reached for gnuplot after
hearing good things over the years. The results were great.

This post is the fifth in my series about supervisors. The
firsttwo posts were about traditional supervisors. The third was
about some more unusual options. The fourth was about the current most
popular choices. This post is about some of the unusual trends I’ve noticed
during my three year long obsession with supervisors.

This is the latest in my apparently unending series about
supervisors. While the firsttwo posts were about
“traditional supervisors,” the third was about a few odd variants, both
good and bad. This post is about the current reigning champions: Upstart and
systemd.

On Monday I began a series about supervisors. It
mostly covered the most basic Supervisors out there, daemontools,
daemontools-encore, runit, and perp. This post will cover the more
advanced generation, which includes s6 and nosh.

At my talk at YAPC a few weeks ago I discussed some technology at
ZipRecruiter that’s called the read/write splitter (or more often the
rwsplitter or simply the splitter.) I have intended to write about this for a
long time and the fact that I was unable to refer to a blog post for the talk
finally convinced me that I must.

A year ago, when I was on paternity leave, I decided that I needed to be better
at time management. I think that my inspiration was simply the recommendation
of the book, Getting
Things Done by Alfie John. Having used the
GTD system for about a year, I feel comfortable writing about it.

At ZipRecruiter we write “a
lot” of logs, so actually looking at the logs can be a lot of work. Amazon
Athena provides a nice solution, and recently an API was (finally) provided to
allow us to use it in our code. I wrote some code recently to leverage the API.

Last time I blogged about vim
sessions I showed a cool pattern for making
sessions more generally useful. There was a bug in my example that hamstrung
the technique, so I’ll be sharing and updated version here.

I have recently been working on honing a lot of my tools, and a coworker, Andrew
Ruder, mentioned using Denite.nvim for selecting more than simple directories.
I decided to investigate using it instead of builtin file selection mechanisms.
I was surprised at the result.

Note: while this post is still worth looking at for comparing how you can
define various lists for vim, the performance issues turned out to be unrelated.
See my new post for more details.

I wrote a plugin on Friday to making orienting yourself in a large piece of code
easier. The short version is that with the new plugin
lost.vim you can call :Lost or use the
gL mapping to find your bearings.