Posts on Jake Worth

Genuinely Care

Mon, 29 Jun 2026 10:24:22 -0400

I often reflect on a conversation from years ago with a former Army boss. It’s foundational to how I understand leadership. He said that being a leader means you have to “Genuinely care.”

Leave a Trace

Thu, 18 Jun 2026 10:40:18 -0400

Always leave something behind. If you find something interesting, leave a trace that you were there.

You Learn a Codebase by Changing It

Thu, 28 May 2026 14:26:41 -0400

How do I “get up to speed” in a new codebase? Changing it.

Avoid Hasty Caching

Tue, 26 May 2026 15:00:01 -0400

Approach caching with caution.

Become a Product-First Software Engineer

Fri, 01 May 2026 10:00:45 -0400

I think many engineers would be better contributors if they started to think more about the customer impact of their work.

On commenting and approving pull requests

Wed, 22 Apr 2026 11:06:20 -0400

After reviewing a lot of pull requests, I’ve settled on a simple default: if my comments are all nitpicks, suggestions, questions, or non-blocking issues, I leave them and approve the PR at the same time.

Incremental Dependency Upgrades

Mon, 20 Apr 2026 17:20:05 -0400

When possible, I prefer to upgrade dependencies incrementally rather than making several version jumps. So, we try not to go from React 16 to 19. We go from 16 to 17, then to 18, and finally to 19.

The Risks of Jumping Multiple Versions

It’s very tempting to jump to the latest release. It feels like time travel; putting your application on the latest in the fewest number of steps. What’s not to like?

Dependencies Go Forward

Mon, 20 Apr 2026 17:12:04 -0400

A policy I favor with dependency management: go forward. Going backward is an exception that we must plan to remedy.

Example

Consider a CVE in a dependency at version 5.0 (v5.0). We’re advised that v6.0 and v4.0 are safe. Which way should we go, forward or backward?

We want to default to forward. Even if we’ve been on v4.0 before and know it is compatible. Even if we aren’t sure that v6.0 is “solid” or if it takes some code changes to implement.

Catastrophic Mistakes Are a Team Failure

Mon, 20 Apr 2026 12:11:33 -0400

If people can make catastrophic mistakes on your team, the process is broken.

CI/CD and Engineer Morale

Mon, 20 Apr 2026 11:41:19 -0400

Why do software teams push continuous deployment so strongly? One of the most important and least discussed reasons is engineer morale.

Tradeoffs of Permanently Forking a Library

Fri, 03 Apr 2026 15:54:06 -0400

Permanently forking a library is something I’ve observed on several teams. But, there are tradeoffs that aren’t always obvious.

A Missing README Isn't a Missing README

Sun, 29 Mar 2026 09:32:47 -0400

A missing README is rarely just missing documentation. It usually signals other things, too.

Better Developer Experience With Friday Reboots

Wed, 11 Mar 2026 09:57:50 -0400

A developer experience practice I’ve recently picked up is routine Friday reboots of my workstation. I think this can make your workflow (and even perhaps your life as an engineer?) a little better.

How I Run a Fully-Remote Software Engineering Standup

Wed, 04 Mar 2026 10:31:38 -0500

I’ve been participating in fully-remote software standups every day for over a decade, and over the past two years, leading them, too. Here’s how I run the best standup meetings that I can.

How I Read 44 Books Last Year

Tue, 24 Feb 2026 16:10:54 -0500

Do you want to read more? Over a decade, I’ve been on a journey from casual to power-reader. In this post, I’d like to share the ideas and techniques that have helped me read more.

Favorite Ideas from "It Doesn't Have to Be Crazy at Work"

Fri, 20 Feb 2026 08:40:45 -0500

I recently re-read It Doesn’t Have to be Crazy at Work by Jason Fried and David Heinemeier of Basecamp. Here are some of my favorite ideas.

"What's Wrong With This Idea?"

Wed, 11 Feb 2026 09:43:43 -0500

One of my favorite problem-solving questions is: “What’s wrong with this idea?” It drives the conversation away from why the idea might work, and toward why it might fail. That perspective is invaluable when building.

Things I Check Before Opening a PR

Sat, 07 Feb 2026 14:58:34 -0500

What is a programmer but a series of PRs (pull requests)? I optimize PRs to introduce the best code I can, be easy to review, and document my work so I can make sense of it in the future. Here are some things I always check before opening a PR.

Why sleep Is Risky in Production Code

Thu, 05 Feb 2026 08:00:51 -0500

You might have heard that using blocking, waiting code, e.g., sleep in many languages, is discouraged. Why?

How to Unabstract an Abstraction

Sun, 01 Feb 2026 12:46:52 -0500

Abstractions in code are easy to add and challenging to remove. Sometimes we feel stuck with them. But the good news is, you can back out of almost any abstraction with the right mindset.

Building with MCP, for Real

Fri, 23 Jan 2026 09:23:29 -0500

This year I built several Model Context Protocol (MCP) servers to support ongoing R&D. Here’s my report.

Learning to Program in 2026

Fri, 16 Jan 2026 12:00:19 -0500

If I had to start over as a person who wanted to become a professional programmer, in 2026, what would I do?

Things I Don't Know, As of 2026

Tue, 13 Jan 2026 11:25:29 -0500

Here’s a list of the things that I’d like to learn about and have chosen not to specialize in (yet), as of 2026.

Getting It Right the First Time

Mon, 05 Jan 2026 07:51:03 -0500

There’s an enviable quality of great engineers I’ve known: they seem to get things right the first time. When you ask them to do something, and they say “It’s done”, it is, almost always. How?

Running Great Refinement Meetings

Mon, 01 Dec 2025 11:18:17 -0500

This year I’ve run over 25 Scrum refinement meetings; here’s what I’ve learned.

Prioritization for Engineers: Rank Every Work List

Thu, 23 Oct 2025 13:46:50 -0400

Anytime you’re making a list at work, rank it.

Acceptance Criteria That Actually Work

Tue, 30 Sep 2025 03:37:56 -0400

Acceptance criteria, or AC, describe what a feature or bugfix does. Writing them is an art, and some AC work much better than others. So, how do we make them work? By including a little more detail.

Get Better at Debugging by Making Predictions

Tue, 23 Sep 2025 10:16:28 -0400

Shift to a proactive mindset by making predictions before any experiments in a debugging session.

Raise the "I'm Stuck" Flag

Wed, 10 Sep 2025 14:16:30 -0400

Consider this scenario. You’ve been given some work, and you’re stuck. Hours have become days. You’ve exhausted the internet. You’re starting to backtrack, delete work, and start over. Feeling defeated. To make matters worse, you haven’t told anybody.

Debugging Is a Story

Tue, 09 Sep 2025 13:27:03 -0400

Today I want to talk about a way I think about debugging: as a story that we tell to ourselves and each other.

Learning JavaScript Promises the Feynman Way

Mon, 25 Aug 2025 12:08:06 -0400

Want to learn a tricky topic and sharpen your learning skills at the same time? In this post, I’ll use the Feynman Learning Technique— a method of learning complex things by explaining them simply— with a sprinkle of LLM magic, to deepen my understanding of JavaScript promises.

"Don't Stay Stuck" Digital Guide Launch

Tue, 12 Aug 2025 09:33:04 -0400

I’m proud to announce the launch of my digital guide to software debugging, Don’t Stay Stuck: A Debugging Guide for Rising Engineers!

A Talk on Twelve Factors

Fri, 01 Aug 2025 13:48:58 -0400

Today I gave a talk to my team about the Twelve-Factor App Methodology.

A Kaizen for Knowledge Work

Wed, 16 Jul 2025 09:00:30 -0400

Confluence was messy. Our documentation felt outdated, hard to navigate, and unreliable. Rather than scrap everything and start over, I decided to try something different: a Kaizen.

Generate the Data. Worry Later.

Mon, 07 Jul 2025 11:58:44 -0400

A suggestion about data: generate it now, and figure out curation later.

Custom Ipsum for Real-World Testing

Fri, 27 Jun 2025 16:00:28 -0400

Pastures which are subject to overflow should be avoided. All lambs born in April or May should be drenched about August or September following, to be certain of ridding them of worms that may later cause their death.

This is output from a tool I built called Veterinary Ipsum. It’s something I’ve created a few times: a Lorem Ipsum generator specific to my company’s business domain.

Banishing "Random" for Better Software Communication

Tue, 17 Jun 2025 12:19:04 -0400

“I’m still getting this random 404.”

Want to sound pro? Banish “random” from your software engineering vocabulary.

Why I Write for Software Engineers and Engineering Leaders

Wed, 11 Jun 2025 09:47:19 -0400

Eight years ago I wrote a post called You Should Blog. In it, I made an argument that I still believe in: public, professional writing is something every engineer should try. Today, I want to share why I write, and have for over a decade.

Four Things I've Changed My Mind About in Engineering

Thu, 29 May 2025 09:20:14 -0400

I think a mark of a great engineer is being willing to change one’s mind when presented with new information. Here are four technological things I’ve changed my mind about.

How I Approach Feature Requests

Wed, 14 May 2025 17:40:42 -0400

Receiving feature requests is part of running a software team. Here’s how I handle them.

Don't Guess

Tue, 29 Apr 2025 09:30:56 -0400

This is a response to “Don’t Guess” from the excellent “The Best Programmers I Know” by Matthias Endler. My goal is to crystallize my understanding of this trait.

Your Software Is Confusing

Mon, 07 Apr 2025 10:16:44 -0400

If something in your software is confusing to a customer, it is confusing.

Why I'm "All In" on TypeScript

Wed, 26 Mar 2025 10:47:45 -0400

I’ve added TypeScript to several projects I’ve worked on. In this post, I’d like to discuss why I think TypeScript is essential and document my expectations around it.

Two-Follow-Up Rule for Closing Support and Internal Tickets

Tue, 04 Mar 2025 09:28:10 -0500

I recently learned a practice for customer communication that I’d like to document. It’s called “Hit It Twice.”

It's Tradeoffs All the Way Down

Wed, 19 Feb 2025 10:11:37 -0400

One common trait among early-career programmers is seeing technology choices in black-and-white. I’ve been there. “Redux is awesome!” “Nested ternaries are terrible!” As you advance as a programmer, for better or worse, you start to see almost everything as a trade-off.

"I Don't Understand" Debugging

Thu, 13 Feb 2025 09:52:51 -0400

My definition of “I don’t understand” debugging.

How to Start a Meetup Group (Lessons from Running One for 10 Years)

Mon, 03 Feb 2025 00:00:00 +0000

I’ve been organizing Meetups for a decade, starting with Vim Chicago and Chicago Elixir, and now running Maine JS from Portland, Maine. In honor of our most recent Meetup, here’s my practical guide on how to start a Meetup group, based on what’s worked for me.

My Annual Review 2024

Tue, 31 Dec 2024 00:00:00 +0000

Here’s my annual review covering 2024.

Hard-Won Software Development Habits

Wed, 27 Nov 2024 10:19:47 -0400

This post is about how to write software well. It was inspired by this post with a similar title. Read it and write yours.

Ship Earlier to Learn What Matters

Sun, 24 Nov 2024 10:16:49 -0400

TONY: We should take this outside.

Being the Third Engineer

Wed, 16 Oct 2024 13:37:01 -0400

I was the third engineer hired by my company, not counting our technical co-founder. I like that position, and it seems to play to my strengths.

Getting Comfortable With Discomfort in Software Engineering

Tue, 03 Sep 2024 00:00:00 +0000

Today I’d like to talk about a quality that’s essential to success as a computer programmer. Let’s call it “comfort with discomfort.” As programmers, we live in this unsettling space. Here are some thoughts on discomfort and tips for dealing with it skillfully.

Decoupling Design From Engineering

Thu, 29 Aug 2024 11:55:49 -0400

Often, when you work as an engineer on a small team, you don’t have dedicated designers on staff. How can you deliver beautiful, intuitive software without designers? Here’s a trick that helps me: decoupling my design work from my engineering work.

The Secret to Being a 10x Engineer

Fri, 26 Jul 2024 00:00:00 +0000

Our industry has a concept of “10x engineers”, individual contributors who have the impact of ten colleagues. How can you become one? I’ll try to answer that in this post.

Find Every Debugging Trail Marker

Mon, 17 Jun 2024 00:00:00 +0000

If you’ve ever watched me debug, you might think I’m moving slowly. That’s because I try hard to find every marker on the debugging trail. I believe this is one of the most valuable skills in debugging.

How I Review Code, Part 2

Thu, 06 Jun 2024 00:00:00 +0000

Reviewing code is tricky. When I’m doing it, I’m trying to achieve a few things at once. In this post, I’d like to document the ways I try to add value via code reviews.

How to Deliver Code Every Day

Thu, 15 Feb 2024 00:00:00 +0000

I recently calculated that I merge 0.8 pull requests every day into my team repo. Let’s round up and say I merge about one PR every day, delivering one or more features to production. I like this velocity, and in this post, I’ll explain how you can achieve it yourself.

Practical Ways to 'Learn in Public' Now

Sun, 28 Jan 2024 00:00:00 +0000

I’ve been a practitioner of Shawn Wang’s ‘Learn in Public’ for years. In this post, I’ll share a list of ways I’ve found to learn in public.

Reflections on Ten Years Professionally Programming

Tue, 09 Jan 2024 00:00:00 +0000

I recently hit a decade of professional programming. I’d like to take a moment here and reflect on what I’ve learned.

My Annual Review 2023

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

Here’s my annual professional review covering 2023.

Master the Fundamentals First

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

When I was learning to program, I was fortunate to pair with very experienced engineers. One day while coding, I said: “I think we need to use Ruby’s map method, but I’m not sure how that works. Let me look it up.”

Later, my pair offered some feedback: “You can’t be looking up map. You need to know how all of Ruby’s Enumerable methods work.”

"What Would Finishing This Today Look Like?"

Thu, 09 Nov 2023 00:00:00 +0000

When I don’t feel like I’m making sufficient progress at work, I have a favorite technique: asking “What would finishing this today look like?”

Absence Of Color Is Better Than the Wrong Color

Mon, 06 Nov 2023 00:00:00 +0000

A design principle that’s crept into my programming could be summarized as:

“Absence of color is better than the wrong color.”

Product Technique: Asking 'What's the Why?'

Mon, 30 Oct 2023 00:00:00 +0000

One of my favorite product hacks is asking: “What’s the why?”

Write Boring Code

Wed, 13 Sep 2023 00:00:00 +0000

Write a little bit of code, and you may come to an unsettling realization: there are multiple ways to do almost any programming task. How do we choose between several that work? I manage this uncertainty with a guideline: writing boring code. In this post, I’ll try to explain what boring means to me.

Take the Big Project

Wed, 06 Sep 2023 00:00:00 +0000

Something I’ve learned as an engineer: when presented with the option of working on a big project, or doing anything else, take the big project.

Thinking of Bugs in Classes

Sun, 03 Sep 2023 00:00:00 +0000

We spent the time writing tests, and yet, a bug survived. Should we just stop writing tests? No, but we should maybe write better tests, and think about them differently.

Why Great PRs Are Great: Pull Requests Templates

Mon, 14 Aug 2023 00:00:00 +0000

Have you ever seen a pull request that seems to completely explain itself? It’s a real artifact. I don’t know the project, yet I understand it. How can we get results like this on every pull request, from every developer on the team, every time?

Don't Ask for Advice; Ask for a Code Review

Wed, 09 Aug 2023 00:00:00 +0000

Here’s some advice about programming I’ve found useful: “Don’t ask for advice; ask for a code review.” In this post, I’d like to explore what I think this adage means.

From Booleans to Strings in Frontend State

Fri, 04 Aug 2023 00:00:00 +0000

When it comes to controlling frontend presentation, developers often rely on booleans. However, this approach can be limiting. In this post, I’ll explore the drawbacks of using booleans and introduce a more versatile alternative: plain old strings with type safety.

The Case Against "Try This" Debugging

Mon, 26 Jun 2023 00:00:00 +0000

In many group debugging sessions I’ve joined, a major technique being deployed is something I call “Try This” debugging. In this post, I’d like to talk about this anti-pattern, and consider a better way.

Absolute Imports in TypeScript and React: A Practical Guide

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

Absolute imports are an essential developer experience feature for me in any JavaScript application. In this post, I’ll explain what they are, how to use them, and why they matter.

My Daily Programming Routine as a Senior Software Engineer

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

Over the past decade, I’ve settled into a daily programming routine that helps me stay productive. It centers on code review, moving tickets forward, finishing in-progress work, and documenting what I learn. Here’s the exact workflow I use.

Variable Name Antipatterns Named and Explained

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

There are only two hard things in Computer Science: cache invalidation and naming things. – Phil Karlton

Let’s talk about variable name antipatterns!

Cold Water for Your Code Coverage

Tue, 28 Mar 2023 00:00:00 +0000

Code coverage, the percentage of your code covered by automated tests, is a metric associated with quality. In this post, I’d like to investigate this association. And pour some cold water on it.

Does ChatGPT Mean Software Engineering Is Over?

Sun, 26 Mar 2023 00:00:00 +0000

Here’s an argument that’s gaining momentum in my field: AI will eliminate or greatly reduce the programming profession.

One-Sentence Summaries of Popular Technology Books

Tue, 21 Mar 2023 00:00:00 +0000

Here are some one-sentence summaries of books that have helped me understand programming and technology.

How to Run an Agile Retrospective for Leaders

Wed, 15 Mar 2023 00:00:00 +0000

Retrospectives are one of my favorite engineering team practices. In this post, I’ll explain why and how I run retros.

Type Your TypeScript Library Functions

Wed, 01 Mar 2023 00:00:00 +0000

There’s been a lot of recent discussion in the TypeScript community about typing functions. These arguments tend to take binary positions: always type your functions, or never type them unless the compiler demands it. Which is the best option?

The Power of CRUD Operations Explained with SQL

Thu, 12 Jan 2023 00:00:00 +0000

CRUD is an acronym that’s used a lot in web and mobile development. Frontend engineers in particular might wonder what it means and why we use it. In this post, I’ll explain CRUD using PostgreSQL, and talk about why it’s important.

How to Create a Timer or Polling in React with setInterval

Thu, 29 Dec 2022 00:00:00 +0000

Have you ever wanted to create a timer in a React app? This could be in support of a UI timer or polling. In this post, I’ll explain how to create a timer effect in a React application using hooks and setInterval.

My Feature Writing Template: Given/When/Then

Tue, 20 Dec 2022 00:00:00 +0000

When preparing feature development work, I write Gherkin-style tickets, which follow the “Given/When/Then” format. Many people call these stories, and I do, too. This technique is incredibly effective! But why? In this post, I’ll try to answer that question.

Button, Link, or Neither? Three Principles for Clarity and Accessibility

Sat, 03 Dec 2022 00:00:00 +0000

Which HTML elements should we be giving a user to click? In this post, I’ll share some best practices for clickable elements.

All My Best Tips For Expertly Reviewing Your Own Code

Sat, 12 Nov 2022 00:00:00 +0000

Great developers review their own code often and effectively. In this post, I’ll share a checklist of all my best tips for maximizing this important practice.

Deliver a Great Standup Report as an Engineer

Wed, 09 Nov 2022 00:00:00 +0000

I’ve been lucky to have worked with some great engineers, and one thing that they tend to do exceptionally well is reporting about their work at meetings. Today I’d like to summarize what I think makes a great standup report.

How to Write a Resume for Transitioning to Programming

Thu, 27 Oct 2022 00:00:00 +0000

As a mentor at Code Platoon, I’ve been able to help many people transition into programming. In this post, I’d like to focus on a vital part of that process: crafting your transitioning-to-tech resume.

Solving Exercism's Resistor Color Trio in TypeScript

Wed, 26 Oct 2022 00:00:00 +0000

Today I completed the ‘Resistor Color Trio’ TypeScript exercise on Exercism. Here’s my solution.

Vim Scratchpad Part 2

Wed, 26 Oct 2022 00:00:00 +0000

Today, I’d like to dive deeper into a part of my practice: using a persisted text file for jotting things down. In this post, I’ll explain the ‘why’ behind this technique, and provide an updated version of it.

Buy the Best Hardware You Can

Tue, 25 Oct 2022 00:00:00 +0000

Some advice I offer people entering the programming profession is to buy the best hardware you can. You’re going to need it.

Solving Exercism's Resistor Color Duo in TypeScript

Mon, 24 Oct 2022 00:00:00 +0000

Today as a code kata I completed the ‘Resistor Color Duo’ TypeScript exercise on Exercism. Here’s my work.

Print Last Exit Code

Fri, 21 Oct 2022 00:00:00 +0000

The exit code of a command in a Unix-based system is an important and easy-to-miss piece of data. It isn’t printed to standard out; you have to go looking for it. I find it useful to inspect this information when debugging or considering chaining unfamiliar commands.

You Can't Change Nothing

Fri, 21 Oct 2022 00:00:00 +0000

I saw a meme this week: a person debugging code, “My code doesn’t work. Let’s change nothing and run it again.”

This is something that I’ve done. It seems pointless. But that’s not quite correct.

Read the Docs

Wed, 19 Oct 2022 00:00:00 +0000

When learning a new language or framework, the first thing I do is read the official documentation cover-to-cover.

The Factory Pattern, Explained in Ruby

Mon, 17 Oct 2022 00:00:00 +0000

In this post, I’ll explain what factories are and why you want them, using Ruby.

Default to Programming Convention

Fri, 14 Oct 2022 00:00:00 +0000

Trying to enforce unconventional coding preferences on a team is an uphill battle. When in doubt, default to convention.

How to Introduce New Ideas

Thu, 08 Sep 2022 00:00:00 +0000

How do you introduce new ways of working? We want to bring a new idea to our engineering teams, such as a new command-line configuration, testing tool, or design pattern. But engineers can be discerning and stubborn customers. The idea needs to stand on its own. And, you have to sell it.

Computers Can Be Understood

Tue, 06 Sep 2022 00:00:00 +0000

A big mental leap I made early in my programming was starting to view computers as something that could be understood.

Vim Scratchpad

Thu, 25 Aug 2022 00:00:00 +0000

Today I’d like to share a small part of my practice: using a persisted scratchpad text file for jotting things down.

Improve Your API Documentation Workflow with Dash

Sun, 21 Aug 2022 00:00:00 +0000

One of my all-time favorite programming tools is Dash by Kapeli. In this post, I’ll share some tips for leveraging this fantastic program.

Prefer Real Data For Software Development

Thu, 18 Aug 2022 00:00:00 +0000

When testing with data, I prefer realistic data rather than random data.

How Luck Played a Role in my Career

Mon, 15 Aug 2022 00:00:00 +0000

I believe that luck is part of every professional journey. Here’s a sampling of the luck I’ve had.

All My Best Debugging Tips

Fri, 05 Aug 2022 00:00:00 +0000

This is a list of all the best debugging tips I’ve picked up over the years. Some of these might seem obvious, yet we forget them when it counts. Debugging is a skill. You have to bring every tool you have to the job.

Tmux Application Startup Script

Thu, 28 Jul 2022 00:00:00 +0000

My development environment depends on several processes running. Here’s how I’ve scripted this setup.

Recognizing and Repairing a Broken Mental Model

Mon, 25 Jul 2022 00:00:00 +0000

Perhaps you’re familiar with this scenario: you’re debugging and stuck. You’ve Googled, read some blog posts and docs. You return to your search engine, type some characters, and then something strange happens: the search engine autocompletes your question, and the results are all purple because they have been visited by you. I’ve come to recognize this moment as always a symptom of a broken mental model.

Retros Need Action Items

Tue, 19 Jul 2022 00:00:00 +0000

Action items are small, defined, actionable TODOs to follow up on after the meeting. An example: “close all pull requests opened more than 90 days ago.” Agile retrospectives should produce many of these.

Better Than 'foo'

Wed, 13 Jul 2022 00:00:00 +0000

There’s almost always a better variable name or value than ‘foo’. It’s useful as a debugging placeholder, but it almost never belongs in production code, even and especially in automated tests.

Database Migration Checklist

Mon, 11 Jul 2022 00:00:00 +0000

I think a great database migration is: correct, atomic, reversible, consistent with the style of the application, and (mostly) uncoupled from your application and RDBMS.

Logging an Object in JavaScript

Thu, 07 Jul 2022 00:00:00 +0000

When printing a JavaScript value to the console, I suggest using an object literal over the raw value.

Why Ruby?

Thu, 30 Jun 2022 00:00:00 +0000

Why should someone learn Ruby in 2022? Ruby was my first programming language, and although I’ve drifted elsewhere, I write Ruby every day. Many people in my network are Ruby diehards. As a result, it’s been a long time since I’ve gotten the chance to sell someone on Ruby.

What Are the Tradeoffs of Passing Objects as React Props?

Mon, 27 Jun 2022 00:00:00 +0000

A common React pattern is to pass an object as a prop. Let’s consider the ways this can be used and tradeoffs of each.

Naive Implementation: The Art of Artless Programming

Thu, 23 Jun 2022 00:00:00 +0000

A naive implementation is a programming technique that prioritizes imperfect shortcuts for the sake of speed, simplicity, or lack of knowledge.

Authentication vs. Authorization

Tue, 21 Jun 2022 00:00:00 +0000

Authentication and authorization are two distinct concepts. Yet, I’ve found they’re sometimes used interchangeably. In this post, I’d like to define these terms.

Spell Checking with Vim: Tutorial and Best Practices

Wed, 15 Jun 2022 00:00:00 +0000

I write each post for this blog in Vim. Writing in the terminal makes me feel like a programmer, even when I’m not specifically programming. In this post, I’ll share how I spellcheck in Vim.

How to Write a Perfect Bug Report (With Template)

Mon, 13 Jun 2022 00:00:00 +0000

Bugs are part of software. Reporting bugs well is a necessary skill in an ever-growing number of job titles. In this post, I’d like to explain how to write a perfect bug report and offer some bug-reporting best practices.

Make a Prediction

Wed, 08 Jun 2022 00:00:00 +0000

Imagine you’re debugging, and you’re stuck. I have a technique that’s going to help. Think of an action you might take. Predict what will happen when you take that action. Take the action. Check if you were right or wrong, consider that information, and repeat.

Desire Paths in Software

Sun, 05 Jun 2022 00:00:00 +0000

We’ve all seen a desire path. They are footpaths created by erosion from human and animal traffic that communicate a wish for a path that doesn’t exist. When you walk on a paved path toward a destination and notice a shortcut in the earth, that’s a desire path. It’s the way people go, rather than the way we would wish them to go.

Spend More Time Thinking Hard

Wed, 01 Jun 2022 00:00:00 +0000

Ben Kuhn’s ‘Think Real Hard’ shares a problem-solving checklist from the scientist Richard Feynman:

Write down the problem.
Think real hard.
Write down the solution.

On its face, this advice is ridiculous. If only we just sat and thought about the problem, we’d win a Nobel Prize like Dr. Feynman!

PostgreSQL Polymorphism

Mon, 30 May 2022 00:00:00 +0000

Scenario: you need a database record that can belong to one record or another, but not both. Polymorphism and exclusivity. One approach is to create a polymorphic-style association at the data layer. By doing so, you’ll get data integrity built in, rather than trusting it will be enforced by each tenant at the application layer.

Goodbye Shared Dotfiles

Wed, 25 May 2022 00:00:00 +0000

A lot of people start programming with shared dotfiles, copied from a team or online. I did. Maybe you’re ready to move on; how would you do that?

Organizing React Components

Mon, 23 May 2022 00:00:00 +0000

You’re creating a React app, and want to organize your components. Or maybe you’re working in a legacy codebase, with many components in one directory, and you want to better organize them. In this post, I’ll document an approach to this problem that has worked for me.

On Starting Over

Wed, 18 May 2022 00:00:00 +0000

I used to have a bad habit when working alone: I’d start a feature, begin doubting my approach, throw away my work, and start over from scratch. Sometimes more than once. The result? Wasted energy, abandoned code, confusion about what I had and hadn’t implemented, and repetitive rework. This post is a collection of thoughts on this practice.

How to Identify the Breaking Commit With Git Bisect

Tue, 17 May 2022 00:00:00 +0000

Some code is broken, and you can’t figure out why. Maybe there are a lot of changes, and identifying the breaking change seems impossible. Or, maybe you’re curious about how things break in your organization. The tool you need is git-bisect.

Commit Part of a File in Git

Fri, 06 May 2022 00:00:00 +0000

You’ve been working on a big set of changes, and haven’t committed to Git yet. Now, you want to commit some, but not all, changes to a file. Let’s look at adding patches.

You Have to Get Fast to Get Good at Programming

Fri, 06 May 2022 00:00:00 +0000

Great programmers aren’t fast because they’re great. They’re great because they’re fast.

Only One Way Out of a Function

Mon, 02 May 2022 00:00:00 +0000

A programming style I try to practice could be described as: “there should be only one way out of a function.” Early returns can often cause more confusion than they’re worth. When possible, I avoid them in favor of a single return.

Am I Too Old to Become a Programmer?

Thu, 28 Apr 2022 00:00:00 +0000

“The best time to plant a tree was twenty years ago. The second best time is now.” – Chinese proverb

I mentor adults who are learning to program after serving in the military. Some are in their late twenties, and some are twice that age. A common concern is that they are too old to be changing careers to programming.

It's Harder to Read Code Than Write It

Mon, 25 Apr 2022 00:00:00 +0000

In Things You Should Never Do, Part I, Joel Spolsky narrates Netscape’s ruinous decision to rewrite their browser from scratch. This introduced the following concept to me: “It’s harder to read code than to write it.” I believe this is true. Today I’d like to explain why.

The Problems With Code Screenshots

Tue, 19 Apr 2022 00:00:00 +0000

Screenshots of code are common in developer communication, but they come with real drawbacks. Here’s why I try to avoid them.

Hash Fetch Instead of If/Else

Sat, 16 Apr 2022 00:00:00 +0000

Conditional logic has its place, but often there’s a better alternative. Today, we’ll look at a Ruby solution: a hash with .fetch.

First Get It Working, Then Make it Look Good

Wed, 13 Apr 2022 00:00:00 +0000

I recently completed a winter survival course where we built shelters in just ten minutes with only the contents of our packs. The pack I brought was nearly empty, so I made a tent out of my parka. It was ugly, but it could have saved my life. How does this apply to software? When building a feature, first get it working, then make it look good.

My psql Config

Tue, 12 Apr 2022 00:00:00 +0000

RC files, thought to stand for “run command” files, are read by a program during startup. The file that configures the PostgreSQL REPL psql is called .psqlrc. In this post I’ll share my personal psql configuration.

Solved! How to Exit Vim "Ex" Mode

Wed, 06 Apr 2022 00:00:00 +0000

How does one exit Vim “Ex” mode? But first… how did you even get into “Ex” mode?

How to Read a Stack Trace

Tue, 05 Apr 2022 00:00:00 +0000

A stumbling block for many people when debugging is reading the stack trace. Today I’d like to discuss this important skill.

RSpec.describe vs. describe: Which Should I Use?

Sat, 02 Apr 2022 00:00:00 +0000

Ruby’s RSpec describe block has two common syntaxes. Which should you use?

Your Demo Doesn't Need Auth

Fri, 01 Apr 2022 00:00:00 +0000

When building a demo application, I believe you can often skip authentication.

How Urgent Is This Bug?

Wed, 30 Mar 2022 00:00:00 +0000

I remember the first bug that I shipped to production. I was upset that I’d broken something and was anxious to fix it. But I noticed something curious: the calm demeanor of a senior mentor helping me. They refused to meet my intensity. While the world burned, they wanted to instead discuss the bug and its relative importance.

Debugging Tip: Learning From Bugs

Fri, 25 Mar 2022 00:00:00 +0000

You were stuck, and now you aren’t. Congratulations! Before you move on, it’s vital to stop and learn from it. It’s the best way I know to get better and spare your mind for increasingly harder problems.

How to Make Renames Easy

Tue, 22 Mar 2022 00:00:00 +0000

Names in software are hard. But what’s worse than a bad name? Sticking with it because you can’t change it. I want us all to be able to effortlessly and fearlessly fix bad names. That’s the topic of this post.

How to Read Postgres Docs

Mon, 21 Mar 2022 00:00:00 +0000

Have you ever tried to read the documentation for a Postgres command? Although many consider Postgres’ docs best-in-class, they include conventions that might challenge newbies. In this post, I’ll paraphrase Postgres’ conventions page to help us understand what the documentation for a command is saying.

Stop Studying, Start Building

Wed, 16 Mar 2022 00:00:00 +0000

If I could give one piece of advice to anyone learning to program: build.

Which Operating System Is the Best for Programming?

Mon, 14 Mar 2022 00:00:00 +0000

Which operating system is the best for programming? This is a perennial question in code boot camps where I’ve taught. I think students see the choice as a fork in the road, and they want pick the right direction. I don’t think there is a right direction. When you’re starting out, my advice is to try each one and choose for yourself.

Autoformat Your Code

Thu, 10 Mar 2022 00:00:00 +0000

Auto-formatting code is good, and you should be doing it all the time. Why? It helps you write better code in real-time, preempt trivial discussions, and maybe even democratize programming.

How I Review Code

Sun, 06 Mar 2022 00:00:00 +0000

Code reviews are important on many teams. Do them well, and your code ships quickly and safely. Do them poorly, and your code ships slowly and riskily. I try to contribute good code reviews. In this post, I’ll share my process.

How I Make Sure I Understand a Feature Before Building

Wed, 02 Mar 2022 00:00:00 +0000

I think the most important factor in consistent delivery is understanding the work. When you understand the work, you build what the stakeholder wants, better and faster.

Don't Stay Stuck

Tue, 01 Mar 2022 00:00:00 +0000

We’ve all seen this: a frustrated coworker hunched over a computer after hours, flailing alone against some impossible bug. Go home, coworker. Don’t stay stuck.

Why Vim

Wed, 23 Feb 2022 00:00:00 +0000

I’ve been using, teaching, and stanning Vim since almost the beginning of my programming career. Yet, when asked to explain this preference, I stumble. In this post, I’d like to explore why I love Vim.

On Disabling Tests

Tue, 22 Feb 2022 00:00:00 +0000

Today I want to talk about a common technique: disabling failing tests to allow a feature to ship. Maybe sometimes you gotta do it. But long-term I think it causes more problems than it solves.

Before You Abort, Count to Ten

Tue, 15 Feb 2022 00:00:00 +0000

Here’s a trick that that has helped me as a programmer: before doing anything major, like killing a process, stop and count to ten.

Avoid Similar Variable Names

Mon, 14 Feb 2022 00:00:00 +0000

A common, problematic convention I see in Ruby tests are variable names like this:

user_a = create(:user, last_log_in: today)
user_b = create(:user, last_log_in: last_year)

Refining Your Terminal Aliases

Thu, 10 Feb 2022 00:00:00 +0000

Any command you type out manually, or even tab-complete a few times, can be shortened. A common shortening technique is the terminal alias. Here are some tips that help me write better aliases and cut my terminal keystrokes.

Ruby's Frozen String Literal Comment: YAGNI

Wed, 09 Feb 2022 00:00:00 +0000

Open a production Ruby file, and you’ll often see this magic comment at the top.

# frozen_string_literal: true

Today I’d like to argue that most Ruby files do not need this comment. YAGNI— You Aren’t Going to Need It.

Why I Don't Point Agile Bug Tickets

Mon, 07 Feb 2022 00:00:00 +0000

When I create Agile bug tickets, I leave the story points blank. Why? Two reasons: pointing bugs creates the wrong incentives, and bugs are hard to estimate.

Weekly Summary Technique for Software Engineers

Fri, 04 Feb 2022 00:00:00 +0000

“What did you do this week?” I’ve written a weekly summary for myself and my teams for years. It helps me think through my work and shows people what I’m working on. In this post, I’ll explain how to use this tool.

Opt Into Beta

Wed, 02 Feb 2022 00:00:00 +0000

Here’s a technique I’ve used on launches: instead of a big scary waterfall, or, in tandem with a phased release, let customers opt into a new feature.

How to Find a Programming Mentor

Mon, 31 Jan 2022 00:00:00 +0000

I have collected a group of mentors over the years. I call on them frequently to talk through tough problems. I think I’m better at my job because of this regular, impartial outside feedback. I’d wish this for everyone! In this post, I’ll try to reverse-engineer the path I took to get here.

Use a Dev Email

Sat, 29 Jan 2022 00:00:00 +0000

An engineering technique I recommend: when you sign up for any service, even on a side project that’s just getting off the ground, create an email group called dev@<your-domain.com> that forwards to you and any other technologists, and use that email to sign up.

How to Answer Questions on Stack Overflow

Thu, 27 Jan 2022 00:00:00 +0000

Here’s my simple framework for answering questions on Stack Overflow that reach and help people and earn reputation.

Want Better Automated Tests? Hard-Code Your Expectations

Tue, 25 Jan 2022 00:00:00 +0000

Hard-coded test expectations have many benefits that I’ll explore in this post.

Presence is Boolean

Mon, 24 Jan 2022 00:00:00 +0000

When possible, I prefer to use the presence of data to represent a boolean, rather than a boolean itself.

Be a Better Technical Consultant by Saying "I Think That..."

Wed, 19 Jan 2022 00:00:00 +0000

An idea I find useful as an individual contributor is starting my consulting with this phrase: “I think that…”. The idea is to let your arguments stand on their own, rather than appealing to your experience or other authorities.

Bug Reports Are Gold

Sat, 15 Jan 2022 00:00:00 +0000

Me: Hey, I’m experiencing an issue with your software. Here’s a detailed bug report.

SAAS Engineer: What you’re describing isn’t possible.

Narrator: But it was possible.

This is a frustrating, unproductive snippet of a conversation I’ve had a few times in my career. What can we learn? Treat bug reports like gold.

Why Getting Good Solves Most Career Problems

Wed, 13 Oct 2021 00:00:00 +0000

What should you focus on at the beginning of your programming career? My unflashy answer is: being really good at programming.

How to Organize JavaScript Imports

Mon, 30 Aug 2021 00:00:00 +0000

The import statements at the top of a JavaScript component file can be a confusing, duplicative, churning mess. Is there a way to organize them that makes sense and scales? In this post, I’d like to share the way I handle this detail.

Write Better Code by Knowing When Not To Refactor

Thu, 26 Aug 2021 00:00:00 +0000

When I review code, I sometimes request that refactoring changes be removed. Even when I think the changes are are objective improvements, and even when they support my personal preferences. My reasoning? Refactors are not free.

The Tutorial Anti-Pattern

Tue, 24 Aug 2021 00:00:00 +0000

Here’s a scenario: you’re applying for your first tech job. You’ve found a bunch of hands-on tutorials and you’re speeding through them. When you finish, you upload the code to Github and add a new line to the ‘Projects’ section of your resume. Maybe you even deploy the code as a production website. My advice: stop.

Consultancy Cycles

Wed, 04 Aug 2021 00:00:00 +0000

Working at a quality software development consultancy like Hashrocket early in your programming career could be a game-changing move.

What is the Sub Claim of a JSON Web Token?

Fri, 02 Apr 2021 00:00:00 +0000

Today I’d like to explain the sub, or subject, registered claim of a JSON Web Token.

Augmenting an Object With the Proxy Pattern

Fri, 26 Feb 2021 00:00:00 +0000

Let’s look at the proxy pattern in Ruby.

Do the Hard Things First

Mon, 25 Jan 2021 00:00:00 +0000

A concept that I admire is ‘Doing the Hard Thing First’ via Ben Orenstein. Ben described on the Art of Product Podcast Episode 50. Here’s my summary:

Choose the hard part of the problem, the part you’re unsure about, the part that success depends on, and solve that first!

Exercism Raindrops in Python

Sun, 06 Dec 2020 00:00:00 +0000

I’ve been learning a bit of Python this Fall to facilitate conversations with a mentee. In this post, I’m going to share the first Python function I’ve ever written, a solution to the Exercism challenge ‘Raindrops’.

Programming Resources for Beginners

Sat, 05 Dec 2020 00:00:00 +0000

There is a glut of programming information online. You can’t read it all, and you shouldn’t, because much of it is outdated, wrong, or irrelevant to you.

So, what is the signal in this noise? I recommend aggregators, blogs, pair programming. And I offer a gentle recommendation against tutorials.

My Annotated Vim Configuration File

Thu, 26 Nov 2020 00:00:00 +0000

I love Vim. Folks who’ve programmed with me, or attended a Vim Meetup when I was an organizer, can attest. When I was learning to code, getting fast at Vim changed everything for me. After almost a decade using this editor, here are my personal configurations.

Essays on Programming I Think About a Lot

Thu, 29 Oct 2020 00:00:00 +0000

Programming is a new and abstract field, and so we place great emphasis on ideas. When I find one that sticks with me, I end up sharing it again and again. These are some of my favorites.

My Development Roadmap

Tue, 20 Oct 2020 00:00:00 +0000

I’ve been working on a development roadmap for my projects, and wanted to share my process. Consider this my recipe to turn an idea into software.

You Have New Mail

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

Here’s a familiar scenario: you open a new terminal, and before the prompt appears, you see the following.

You have new mail.

What’s going on here?

Duplicate your Development Branch for QA

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

I’m working on a team where we keep a clone of the development branch (the main place where work is done), used to deploy to a QA environment. The benefits of this branching technique are:

clone is isolated from work
It’s easy to tell what was deployed to QA– clone is the source of truth

How I Clean Up JavaScript Dependencies

Mon, 03 Aug 2020 00:00:00 +0000

Unused dependencies are bad: they increase the size of your project, slow down your processes, require upgrades, and send incorrect messages to fellow developers about what’s important. Make your project better by periodically auditing your dependencies, and removing those that are unused.

My Annual Review 2019

Tue, 31 Dec 2019 00:00:00 +0000

Here’s my annual professional review covering 2018.

Technologist Reading List

Sat, 28 Sep 2019 00:00:00 +0000

Here’s my list of favorite programming books.

A Short Introduction to Test-Driven-Development (TDD)

Wed, 11 Sep 2019 00:00:00 +0000

I’ve practiced TDD (Test-Driven-Development) a lot and feel knowledgable about when it’s useful and when it isn’t. In this post, I’d like to summarize what I’ve learned.

Pangram in TypeScript

Mon, 29 Jul 2019 00:00:00 +0000

I’ve been doing Exercism’s TypeScript exercises, and wanted to share my pangram-checking utility.

JavaScript Equality

Tue, 17 Jul 2018 00:00:00 +0000

A few weeks ago, I built an app with React.js and create-react-app that I call ‘JavaScript Equality’. View deployment here. This application demonstrates the JavaScript value-comparison operators == and ===. It’s inspired by the JavaScript Equality Table.

A Git Workflow to Keep Branches Current and PRs Clean

Wed, 11 Jul 2018 00:00:00 +0000

My current favorite command line alias is mgrim, composed of four other aliases. Here’s what it is, and what it does.

Comprehensive Instructions

Mon, 09 Jul 2018 00:00:00 +0000

A user opened an issue in Tilex last week that I spent a significant amount of time thinking about and talking about (thanks JB) before responding to. Here’s the truncated request:

May I ask you to compile a step-by-step list to set up a running TIL instance?

The Universal Programming Language

Sun, 17 Sep 2017 00:00:00 +0000

Recently I tried to answer a question that I think is common to consider when you’re first learning about computer programming. I’ll paraphrase:

Why can’t there be an “universal” programming language that serves all purposes?

How I Talk: My Guide to Tech Public Speaking

Wed, 09 Aug 2017 00:00:00 +0000

I’ve been giving technical talks for a few years, and I’m speaking at the Vim Chicago Meetup next month about integrating React with Vim. In this post, I’m going to use that opportunity as an excuse to document my speaking process.

Execution Credibility: Ship, Then Signal

Wed, 19 Jul 2017 00:00:00 +0000

As soon as you can, just do the thing you have to do, and respond with: “It’s done.”

Don't Build Every Feature

Mon, 19 Jun 2017 00:00:00 +0000

There’s a detail about Today I Learned some might find unusual: we never added a way to delete posts from the site. Why ignore a basic CRUD feature? We didn’t ignore it. It was intentionally omitted.

Work Small

Sat, 10 Jun 2017 00:00:00 +0000

Write programs that do one thing and do it well. –The Unix Philosophy

I believe in working small.

What We Learned Porting a Rails App to Phoenix

Mon, 05 Jun 2017 00:00:00 +0000

Tilex, our Phoenix port of Today I Learned, is coming really well. After a personal hiatus for RailsConf prep, I’m back full-swing. My coworkers have really been bringing quality commits as well, and I feel we are very close to a successful port.

You Should Blog

Sat, 11 Feb 2017 00:00:00 +0000

I created this blog to reflect on my code and development as a programmer. In that spirit, I’d like to make a pitch to anybody reading: you should blog.

Reset an Ecto Heroku Postgres Database

Sat, 07 Jan 2017 00:00:00 +0000

We introduced some breaking database changes to our Phoenix port of Today I Learned on Friday; today I deployed them to staging. Resetting an Ecto Heroku database, with new seed data, turned out to be a little tricky, and I wanted to document what I learned.

Vim Nonrecursive Mappings

Sat, 17 Dec 2016 00:00:00 +0000

My first PR to a new Vim plugin was merged this week, check it out, adding non-recursive Vim mappings to vim-termbux.

Porting TIL from Rails to Phoenix: Initial Commits

Tue, 29 Nov 2016 00:00:00 +0000

Last week, I started a new project: porting Today I Learned from Ruby on Rails to Phoenix (Elixir).

Learn to Test

Fri, 15 Jul 2016 00:00:00 +0000

What is a skill one could learn to set themselves apart from other entry-level programmers? Testing.

Why Elixir?

Wed, 06 Jul 2016 00:00:00 +0000

I’ve been learning and using Elixir lately, and loving it. More than once, I’ve been asked some version of the question: why are you learning Elixir? What makes this language unique? I thought I’d take a moment and try to distill my rationale.

Writing Elixir Sigils

Mon, 04 Jul 2016 00:00:00 +0000

Sigils are a mechanism for working with textual representations in Elixir. If you’ve ever made an array of Strings in Ruby with %w(), the API is similar. A neat feature of sigils is that we can make custom variants, or override existing Kernel variants. The latter is generally discouraged.

How and Why to Squash Your Pull Request

Sun, 03 Jul 2016 00:00:00 +0000

Many pull requests go through a cycle: programmer opens pull request, maintainer gives feedback, programmer makes changes, repeat until ready to merge, maintainer merges. Prior to the merge, the pull request can be messy, full of reverts, fixups, and WIP commits. In the end, those commits are noise. We can tell a better story by squashing the branch.

Recreating Elixir's Enum.sum

Thu, 30 Jun 2016 00:00:00 +0000

I’m learning Elixir, and today as an exercise, I was challenged to recreate Enum.sum using recursion. Here’s my solution.

Server Side Sorting in Ruby

Tue, 28 Jun 2016 00:00:00 +0000

Recently a friend asked me this question about server-side sorting in Rails. Here’s the question and my answer.

Keyword, Match, and Region in VimScript

Wed, 20 Apr 2016 00:00:00 +0000

After a recent talk I gave that included VimScript, an attendee asked a question about the differences between keyword, match, and region following syn in a Vim syntax highlighting file. Here’s my answer.

From One End to the Other in Ruby

Sun, 06 Mar 2016 00:00:00 +0000

A while back I tackled the following programming challenge:

From One End to the Other: Find the smallest possible (positive) integer that ends in a six such that if that six is removed and placed in front of the remaining digits of the number, the resulting number will be four times as large as the original.

Vim Buffer Problem

Sun, 06 Mar 2016 00:00:00 +0000

A few weeks back I tackled the following programming challenge from my colleague Josh Branchaud:

Vim Buffer

I open up a new Vim buffer and type all the numbers 1 to 10,000, separated by spaces. Then, my cat walks on the keyboard and somehow activates a substitution command that replaces all the ‘0’ digits (zeros) with spaces. If I now sum up all the numbers in the buffer, as delineated by spaces, what is the total?

Building a Markov-Chain MVP in Ruby

Fri, 11 Sep 2015 00:00:00 +0000

Project announcement! Last night I built a Markov Chain-generated novel, titled Ceramic Nation.

The N + 1 Problem

Sun, 22 Feb 2015 00:00:00 +0000

Recently, I was thinking about the N + 1 problem. N + 1 is a performance issue in a web application, where a method call unleashes a torrent of database queries.

Ruby Symbol#to_proc

Fri, 31 Oct 2014 00:00:00 +0000

What does &: mean in Ruby? In this post, I’ll explain.

The Case for One Computer Monitor

Mon, 31 Mar 2014 00:00:00 +0000

I have one computer monitor on my desk. Not long ago, this was common, but today, many people have two, three, or four monitors. In this post, I’d like to make the case that most professional programmers can use just one monitor.