Senior Engineering Architect on Ryan M. Poe

A 64x64 Weather Display for a Divoom

Sat, 03 Jan 2026 00:00:00 +0000

I have a nifty Divoom Pixoo-64 on my desk that I got for Christmas a few years back. It’s a 64x64 LED display that can show pixel art, animations, the time, etc. But if you don’t mind code, it can show whatever you want. I wanted it to show the weather in a specific way that I liked.

The Divoom on my office wall

The result: a little serverless function that generates a 64x64 pixel image with the current temperature, forecast, date, and time. It runs on Cloudflare Workers now, though it started as a Netlify function back in July 2023.

Engineering Year in Review Guide

Fri, 02 Jan 2026 00:00:00 +0000

For our team’s final 2025 meeting, I made a nice 2025 end-of-year report on our code entropy over the past year, with a focus on recognizing the contributions of our team. Sharing this guide for anyone who might want to do something similar.

It’s nice to have a snapshot of what a team accomplished in code form: code commits, PR reviews, cross-repo work, security patches, dependency updates - it all adds up to something worth celebrating.

Breakdance: Automating parts of our SDLC

Mon, 29 Dec 2025 00:00:00 +0000

At WorkTango, a pull request (PR) moves through a predictable lifecycle:

Developer opens a PR against the main branch (master, in our case)
CI runs (tests, linting, type checking)
At least one approving review required (more for certain files via CODEOWNERS)
All status checks must pass
When ready, the developer adds a GitHub label (breakdance) to request auto-merge
On merge: commits are squashed into a single commit
Commit title = PR title (must contain a Jira ticket, e.g., WT-12345)
Commit description = extracted from the PR body’s “Commit Message” section

This keeps our git history clean: one commit per PR, meaningful messages, traceable to Jira.

ESM and `__dirname`

Sun, 14 Jul 2024 00:00:00 +0000

As a Node/TypeScript engineer constantly trying to prune build tools and layers of complexity away, I find ECMAscript modules quite the difficulty hurdle. A lot of the little rules and differences between ESM and CJS have deep technical reasons behind them, many of which I’m sure are difficult to explain.

One of those is the whole “where’s my __dirname and __filename?!” kerfuffle. And it’s probably instructive.

You can’t simply use __dirname in ESM to get a filesystem directory. The standard was written for browsers, not file systems. Sure, there’s a convention that overlaps file system semantics onto URLs. But there’s no guarantee that https://website.com/my/path overlays onto /var/www/my/path.

Testing as thinking

Thu, 21 Dec 2023 00:00:00 +0000

I got to thinking about all of the ire I often see directed toward Test Driven Development (TDD). Developers tend to consider the “write the test first” dogma to be unhelpful–too picky for people who actually want to ship products.

I totally understand. Nobody likes something that exists only as a set of obtrusive, mechanical, seemingly regressive rules. (This is tilting at windmills, though. Nobody got fired for forgetting to write their test before their implementation.) I don’t want to even sell you on test-first engineering. I almost never do that!

TypeScript types from a database connection

Wed, 08 Nov 2023 00:00:00 +0000

There are a whole lot of NodeJS ORMs and/or DB management drivers to choose from:

Objection
Sequelize
Knex
Prisma
Hasura
Raw mode (PG2, node-mysql, SQLite, etc.)
TypeORM
Kysely
Mongoose
Waterline (Sails)
MikroORM

I’ve used most of them at some point, either professionally or in side projects. Over time, I’ve developed a preference against treating my schema shape (in code) as the primary artifact of my database designs. You know what I mean: the entities folder, with 30-75 files tucked in under it, each representing one or more database table as some sort of class, or object, usually crawling with decorators. Sometimes your ORM might actually write migrations from those entities.

LLM Glossary for People Who Build Stuff

Sat, 07 Oct 2023 00:00:00 +0000

I’ve done a number of AI-related projects. Nothing huge, and nothing from the metal, like training models. (I don’t have a year’s salary to set on fire!) If you don’t do a ton of Python (I don’t), some of the techniques appear at first glance magical. They’re referenced in arxiv papers with fancy names like “embeddings,” or “quantization,” as if to whisper “this is above your pay grade 😉.”

Nonsense.

Most of the jargon in the LLM space exists because it hasn’t yet made its way out of academia. I have an extreme bias against gate-keeping language (which, as useful as jargon can be, often functions to keep the plebs out), but that’s another story. For those of us looking to use LLMs to build neat things, the learning curve can look like a cliff.

Testing your GitHub CODEOWNERS file

Thu, 06 Jul 2023 00:00:00 +0000

I just realized after a few months that our GitHub code owners file wasn’t properly covering our migration files. I trust our code owners, and the misconfiguration is purely my fault. And, luckily, we didn’t lose any data to my mistake. No harm, no foul.

But now it’s time to get serious with this. I made the change expecting it to work one way, but it worked another way. I didn’t test it. To fix it, the first step is asking “How do I test it?” Turns out, there’s a package for that!

The Structural Problems with Abstractions

Wed, 19 Apr 2023 00:00:00 +0000

Abstractions are a wonderful software development tool, allowing one to take common business rules and consolidate them into a centralized location for improved testability and reuse. We trade complexity in multiple locations for complexity in a central place, so that our top-level function doesn’t need to understand all the intricacies of the underlying, abstracted tooling.

Yet, even the best abstractions come with a cost in terms of understanding. Your average (strawman) Java code bases are a wonderland of deeply-nested, extremely abstract concepts like the famed FactoryFactoryFactory. The person who built the FactoryFactoryFactory, knows full well how it works and why it’s necessary. Everyone else? Enjoy your six months of onboarding, retreading every inevitably under-documented design decision your forebears made.

What are generics?

Mon, 10 Apr 2023 00:00:00 +0000

Developers unfamiliar with robust type systems that support generics might see the following code as a huge “WTF…”

export function filterUndefined<TArrayElementType>(
  theArray: readonly (TArrayElementType | undefined)[]
): Exclude<TArrayElementType, undefined>[] {
  if (!theArray) {
    return [];
  }
  return theArray.filter(
    (item): item is Exclude<TArrayElementType, undefined> => !isUndefined(item)
  );
}

function isUndefined(subject: unknown): subject is undefined {
  return subject === undefined;
}

The semantics you see, e.g., <TArrayElementType>, after filterUndefined is what’s known as a generic. Generics let consumers of your API pass types known to them, but not by us, so that your API can work with and later utilize those passed-in types. Think of them like function arguments for types.

⚒️ Coalesce!

Fri, 24 Mar 2023 00:00:00 +0000

At WorkTango, we mandate 100% code coverage. Over the years, we have found a few handy, type-safe helpers to help us save on writing test cases where the scenario would add no value.

The Problem

Consider this function:

interface Attribute {
  name: string;
  displayName?: string; // <-- Optional
}

/**
 * Given an at tribute, returns its display name if present. Otherwise, returns
 * the attribute's name.
 */
function getAttributeDisplayNameOrName(attribute: Attribute): string {
  return attribute.displayName || attribute.name;
}

We use static analysis tools to determine coverage branches. This function, because it uses what is in effect a ternary, has two logical branches: the displayName branch, and the name branch. (It’s roughly equivalent to attribute.displayName ? attribute.displayName : attribute.name.) To achieve 100% coverage, our test cases (assuming Jest) would need to be:

Type Safe Object Access

Sun, 04 Apr 2021 00:00:00 +0000

The Problem

In our codebase over at KazooHR.com, we generate all of our code with @graphql-codegen. We use those types (mostly) as the canonical records for our business objects in the frontend (and for a lot of backend operations). Generating this code automatically gives us type safety for most of our backend and frontend code.

We also enforce 100% code coverage. At first, it was onerous, but everyone quickly becomes very good at Jest, so that the bus factor is actually rethinking code so that it’s more easily testable. This rethinking almost always results in cleaner, terser, and more functional code and tests. It’s slower at first, but pays off HUGE in the long run.

Code Quality and Formatters

Wed, 06 Feb 2019 00:00:00 +0000

We should respect process. Is exists to provide accountability and known pipelines for the movement of features from your development box to production sites.

But.

Code quality and standards are often difficult to make a business case for. Why should we carve out time to improve years of unprofessional, difficult-to-read code when there will be no actual improvement to what we deliver to customers?

In addition, lot of developers have very strong opinions about what counts as “readable” code. Have mercy on you if you have to decide between tabs or spaces when two developers have strongly-held opinions on one or the other; or whether four spaces or two is appropriate.

Sublime Text 3 from the command line

Tue, 21 Aug 2018 00:00:00 +0000

Sublime Text 3 is awesome. I won’t talk about that now.

What I did want to quickly blog about is the command line utility. I’ve got a nice long list of bash aliases that I’ll blog about sometime in the future. One thing I wanted was a way to launch Sublime from the command line. In my search, I found Olivier Lacan’s nice writeup about setting up the Sublime CLI. It’s simple.

RequireJS and Magento 2

Wed, 12 Apr 2017 00:00:00 +0000

Magento2 uses RequireJS to load its javascript. The library is made to be a browser-based solution to a classic problem in frontend development: how to incorporate third-party dependencies in your javascript. Rather than having to place a page’s dependencies in script tags in each page’s header, RequireJS handles everything for you asynchronously, allowing your javascript to define its own dependencies, and allowing a progressive-enhancement-oriented workflow. More of a visual learner? Check out this article in YouTube video form: RequireJS and Magento2!

A Magento 2 Frontend Workflow

Fri, 07 Apr 2017 00:00:00 +0000

This short tutorial assumes you have Magento2 installed and ready to go. I’m using a local install on OSX, but these same commands and principles will work if you install Mage2 via Docker or Vagrant, as well. Note: for a visual dive into this subject, check out the YouTube video I made on the subject, A Magento2 Frontend Workflow. Magento2 ships with LESS because its easy to use PHP to compile LESS into CSS. When they made that architectural decision, there was no PHP SCSS implementation. Mage2 aims to have as few requirements as possible, however, so they want to ensure you can run Magento on a standard LAMP box. But you can’t really do quick changes if you need Mage2 to compile your static assets. The php bin/magento setup:static-content:deploy command takes minutes to compile. So to increase the development speed, Mage2 ships with a Grunt build process for those who want to take advantage of it.

When to Use CSS Grids

Mon, 20 Mar 2017 00:00:00 +0000

If you haven’t heard about CSS Grids yet, what are you doing? Go read about them, now! Support for them just dropped in the evergreen browsers, save Safari, which is due out in April. That means that by the end of the year, we could see as high as 50-70% support. (I just made this number up.)

But as I’ve been working with a designer on what this means, and how we can best use CSS grids, I’ve come across a few limitations and things to be aware of before fully adopting CSS grids as the Swiss Army knife of layout tools…

Magento 1.x Directory Structure Guide

Fri, 19 Aug 2016 00:00:00 +0000

This past week, I’ve been taking a crash-course in Magento 1.x. I’ve been thoroughly impressed that it runs a fairly sophisticated ORM that implements an ActiveRecord-like API in an otherwise DataMapped pattern. It only calls a record’s resource handler (which saves the data to the database) when you call a row’s save() method. Pretty cool stuff. But holy moly, what a complex, spaghetti-like system. It took me forever (nearly 4 solid days) to finally figure out where I could find a module’s code, view files, and configuration. So I decided to share the guide I wrote up on it. TLDR; Magento makes you put your modules in three primary places: