J3RN's Blog

Avoiding a GenServer Pitfall

Sat, 01 Nov 2025 00:00:00 +0000

Firstly, what is a GenServer? #

GenServer, short for “generic server”, is a type of process within BEAM (Erlang, Elixir) applications that can hold state and respond to requests; much like a web server, in a way. For instance, you could create a GenServer that you could handle requests to store blog posts as well as other requests to list or read those blog posts—but those request would have to be made within the BEAM VM rather than with a web browser. Within BEAM applications, the two primary purposes of GenServers are to execute code asynchronously and act as a store of shared, mutable state.

My API Integration Methodology

Sun, 27 Jul 2025 00:00:00 +0000

The code examples in this post are in Elixir, and some of the design aspects are Elixir-specific, but the concepts are translatable to most languages.

A common aspect of modern web applications is the need to communicate with other web applications in what is usually referred to as “API integrations”. For example, consider Stripe. Stripe is a payment processor service that handles the complicated parts of accepting payments. If your app is being extended to have a checkout experience for customers, you might integrate with Stripe to accomplish that.

Paper Review: Compiling Routines by Richard K. Ridgway, 1952

Tue, 17 Jun 2025 00:00:00 +0000

Compiling Routines #

Richard K. Ridgway, 1952 #

Compiling Routines is a short paper (3 paged of text, 2 pages of figures) that describes one of the first compilers, termed “A-0”. A-0 is also referred to as “the antique compiler” in the paper as, apparently, newer compilers had been developed.

Object Orientation and the Limits of Metaphor

Sun, 13 Apr 2025 00:00:00 +0000

Roughly ten years ago, I was very excited about object orientation. Which made me somewhat late to the party; glowing pronouncements of how object orientation was going to solve the software complexity crisis had flooded industry publications some two decades prior. Regardless, in 2014, I was trying to explain to a friend why objects were so grand.

“Objects model the real world,” I said, grabbing a pencil off the table and holding it up. “For instance, I could create a Pencil class, representing the Platonic idea of Pencil, and this would be an instance of it.” I, like any modern person, did not actually subscribe to Platonism. “And it’s able to do stuff, which we refer to as ‘methods’. For instance,” I said, scribbling on a piece of paper, “it might have a ‘write’ method, for writing things.”

Revealing Reveal

Sun, 17 Nov 2024 00:00:00 +0000

Disclaimer: A limitation of the work that I’m describing in this post is that it may only be useful to sighted persons and is enhanced by being not colorblind. This post discusses a tool that displays code within colored boxes. The current implementation provides titles on the boxes which might be of use to those without (color) vision, but I have not verified it with a screen reader. I will strive in my future work to create tools that are of use to the (color)blind community.

Why I Still Use JavaScript's then

Wed, 04 Sep 2024 00:00:00 +0000

With ECMAScript 2017, JavaScript gained the async and await keywords as a new way to deal with Promises. The traditional way to work with Promises was with the methods then, catch, and finally, like so:

const fetchResource = () => {
 return fetch("https://example.com/api/resource")
 .then((res) => handleResponse(res))
 .catch((err) => handleError(err))
 .finally(() => cleanup());
};

The above function:

fetches a data from a server using the venerable fetch function, which returns a Promise,
calls the then method on the Promise returned from fetch to configure it such that if the Promise “resolves” (completes successfully), the handleResponse function is invoked with the “resolved” value (here, an HTTP response),
calls the catch method on the Promise returned from then which configures it such that if the Promise “rejects” (is unsuccessful), the handleError is invoked with the reject value (some kind of error),
calls the finally method on the Promise returned from catch which configures it such that the cleanup function is always invoked regardless of whether the Promise resolves or rejects.

Technically, the catch and finally method are wrappers around then that specialize it for different scenarios and allow programmers to convey intent more easily.

Demystifying .NET Terminology

Wed, 26 Jun 2024 00:00:00 +0000

So much modern technology is built with Microsoft’s .NET, it seems inevitable that I would have to learn about it eventually. When I did, I found so much of the terminology confusing; things had overlapping names and nothing seemed consistent. This table hopefully helps you (and me!) keep it all straight.

Name	Description
.NET	The "application platform" for all other technologies listed here. It consists of: The Common Language Runtime (or CLR) Libraries (standard lib type stuff; i/o, dates and times, etc) Compiler SDK and tools "App stacks" such as ASP.NET Core and Windows Forms
.NET Framework	A closed-source, Windows-only version of .NET that is deprecated. It's last version is .NET Framework 4.8.1, released in 2022.
.NET Core	A newer implementation of .NET that is open source and cross-platform (Windows, Linux, and macOS). Since .NET Framework is deprecated, it is commonly referred to as just ".NET". The latest version as of writing is .NET Core 8.0.
ASP.NET	ASP.NET is a web framework extending .NET for making web services. The term can refer to the original ASP.NET, the closed-source, .NET Framework version which, naturally, is also deprecated, or ASP.NET Core, the newer, open-source version targeting .NET Core.
ASP.NET Core	The newer, open-source, cross-platform web framework.
Entity Framework	An Object-Relational Mapping (ORM) library for .NET. The story with Entity Framework is very similar to the story with ASP.NET; it was originally shipped as part of .NET Framework, but has been split off and has been superseded by Entity Framework Core.
Entity Framework Core	The newer, open-source, cross-platform ORM.

I’ll add more terms as I encounter them!

Why Fedora Silverblue?

Tue, 05 Mar 2024 00:00:00 +0000

This post is largely based on a write-up I gave to a friend about why I recommended Fedora Silverblue as their first Linux distribution. I assume no knowledge of Linux here.

I’ve been using Linux-based operating systems (termed “Linux distributions”, “Linux distros”, or just “distros”) since about 2011. I’ve hopped between many distros, and for some years would switch distros every few months. Lately, though, I’ve been quite content to use only one distro for my daily desktop use, Fedora Silverblue.

Let it Crash?

Mon, 12 Feb 2024 00:00:00 +0000

In the BEAM ecosystem (Erlang, Elixir, Gleam, etc), there’s a common idiom:

Let It Crash #

And your first reaction to this is probably astonishment, because crashing is, generally-speaking, not ideal. In traditional, single-threaded systems, a crash means that your program dies and—in server settings—it’s then the responsibility of some other service (SystemD or Kubernetes or whatever) to notice that your program has died and restart it. In the event that this process was non-redundant (which is, itself, bad), this may result in downtime. However, in BEAM languages this is usually not the case; business logic is typically executed by BEAM worker processes¹ which are isolated from all other BEAM processes. If one BEAM process crashes, all the other processes keep going². Furthermore, these processes are usually “supervised” by a Supervisor which will detect the crash and start a replacement process, if necessary.

The Four Part Migration

Thu, 11 May 2023 00:00:00 +0000

If you’ve been writing relational database-backed applications for long enough, you’ve needed this. The situation is common enough: You have a some kind of web application, you don’t want to have any downtime, and you need to make a breaking change to your schema.

Breaking changes come in several forms: renaming a column, changing its type, or even just changing the format in which you store data (e.g. normalizing phone numbers), etc. What these cases have in common is that once the change is made, the code that relied on the way that things were will no longer function. For instance, when a column is renamed, code that’s looking for the data under the old name won’t work. Code looking for data under the new name won’t function either until the rename is complete.

Debugging Elixir with Erlang's dbg

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

Sometimes, either in local development or on a production server, you want to see when a given function is called, what arguments it is being called with, and what it’s returning. Let’s say that you have a MyApp.Widgets.show_widget?/1 function which consumes a widget and returns a boolean indicating whether or not that widget should be shown to the user. However, the logic contained in there is pretty complicated and—worse—you don’t know really where it is called from anyway.

Readability vs Comprehensibility

Sun, 04 Sep 2022 00:00:00 +0000

For me, clarity is composed of two smaller ideas: readability and comprehensibility. Neither of these words have widely-accepted definitions in software engineering, so for the purposes of this article, I will define them like so:

readability: ability for a reader to recognize the syntactic constructs in a body of code.
comprehensibility: ability for a reader to discern the what a body of code does at a high level.

Readability #

The LISP family of programming languages have reached the pinnacle of readability.

Elixir GenServers vs Agents

Sat, 06 Aug 2022 00:00:00 +0000

Just as Protocols are an abstraction built upon Behaviours, Agents are an abstraction built upon GenServers. While GenServers can serve a wider variety of purposes, Agents serve a single purpose: storing state.

GenServer #

The Elixir documentation for GenServer summarizes them as such:

A GenServer is a process like any other Elixir process and it can be used to keep state, execute code asynchronously and so on. The advantage of using a generic server process (GenServer) implemented using this module is that it will have a standard set of interface functions and include functionality for tracing and error reporting. It will also fit into a supervision tree.

Focusing on What Matters

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

Update 2025-07-12: I merged two sections, Stability and Availability, into one section, Usability, that also encompasses topics such as accessibility. I also updated some paragraph structures and removed the intro because it was weak.

What matters? #

The reason that we write software in the first place is to create solutions to problems¹. Around the world, every day people face problems that can be solved by computers. A person might want to know “What are the chances it will rain tomorrow?” A statistical model can provide a reasonable estimate. A person might want to know “If I have a loan at 3%, how much will I pay in interest over the term of the loan?” Accounting software can answer this question.

Profiling Elixir for Advent of Code

Sun, 05 Dec 2021 15:34:07 -0500

Every now and again, you may run into a problem that isn’t hard to solve using functional programming, but which is hard to solve quickly using functional programming. For me, today, that problem was Advent of Code, Day 5.

If you’re participating in Advent of Code and you haven’t yet solved Day 5, this is your last chance to leave the page without spoilers. You have been warned!

The Problem #

You are provided with a list of lines of hydrothermal vents on the ocean floor. These lines are represented by start and end coordinates, such as 0,9 -> 5,9. In this example, this means that there are hydrothermal vents at coordinates 0,9, 1,9, 2,9, 3,9, 4,9, and 5,9. Interestingly, two “lines” of vents may intersect or overlap, which create areas of increased concern.

Truly Declarative: Logic Programming

Sat, 30 Oct 2021 10:21:19 -0400

While reading through Miran Lipovača’s excellent Learn You a Haskell, I came across the following problem:

Which right triangle that has integers for all sides and all sides equal to or smaller than 10 has a perimeter of 24?

To demonstrate some properties of different programming languages, I’ll solve this problem in three languages embodying three different paradigms:

C (imperative and procedural)
Haskell (functional)
Prolog (logic and constraint)

C #

The general approach I’ll be taking here is to generate every set of possible lengths fitting the constraints (namely being integers between 1 and 10) and then check to see if the other two conditions are met (being a right triangle, having a perimeter of 24).

Elixir Behaviours vs Protocols

Thu, 14 Oct 2021 22:40:42 -0400

As developers begin learning Elixir, they often have a very understandable confusion around the difference between Elixir’s behaviours and protocols. These are similar constructs, but with important differences.

Behaviours #

Behaviours are conceptually quite simple:

A behaviour module defines a set of functions and macros (referred to as callbacks) that callback modules implementing that behaviour must export.

For instance, a commonly used behaviour is GenServer, used like so:

Exciting Changes Coming in Elixir 1.12

Wed, 14 Apr 2021 15:10:00 -0500

José recently announced the availability of Elixir 1.12.0 rc.0, a precursor to the full Elixir 1.12.0 release which should come within the next month or so. This update consists primarily of developer quality-of-life improvements. In his announcement, José elaborated on a few changes, but I couldn’t help but feel that some exciting changes were relegated to footnotes. As such, I’m dedicating this post to trawling through the full changelog and shining a spotlight on a few of my favorite changes.

The Agile Myth

Sat, 06 Mar 2021 15:10:00 -0500

Writing a criticism of Agile after the word “Agile” has been pronounced dead by one of its authors may seem like overkill, but nothing has put a stop to the software industry’s glut of Agile certifications, occupations of “doing Agile”, and every engineering manager I’ve ever spoken to saying “Oh, yes, we do Agile here.” I could write an entire blog post haranguing the profiteering and narcissistic industry (see Dave Thomas’ post linked above), but today I want to dive deeper, take a hard look at the original document, and ask “Who actually does this?”

The Harmful Duality of Elixir's nil

Sun, 13 Dec 2020 20:46:00 -0500

The Problem #

Have you ever written code like this?

def get_address(address_id) do
 case Addresses.get(address_id) do
 nil -> {:error, :address_not_found}
 val -> {:ok, val}
 end
end

I have. This pattern is commonly used to make the value that Ecto.Repo.get/3 returns (a struct or nil) play well with Elixir’s with construct. Since Ecto.Repo.get/3 will always return some single value, a nil check is required to determine whether that value indicates a success or a failure. Doing this check inline is somewhat clumsy:

Escaping from Ruby Blocks

Wed, 18 Oct 2017 12:00:00 -0400

Guard Clauses #

Once upon a time, Rubocop taught me to love guard clauses. When I first started learning to program, I was deeply conflicted about guard clauses. On the one hand, guard clauses can prevent the need to have deeply nested ifs. On the other hand, it can be hard to remember the context deep into a method without being able to reference the enveloping ifs (similarly to RSpec contexts). In any case, Rubocop wants me to use guard clauses, so I do.

To Monkey Patch Ruby

Thu, 25 Aug 2016 16:07:49 -0400

This is the first of a series of posts I intend to write in a new “J3RN vs J3RN” style. Essentially, I will be stating a problem with two or more possible solutions, taking both sides in turn, and hopefully ultimately reaching a well thought out solution to the problem.

The Problem #

For my Time Tracker application, I want to have a pretty date and time picker. However, Ruby only natively understands a handful of formats and “American date”, the format used by the pretty date and time picker, is not one of them.

Interpolating Ruby Strings

Fri, 19 Dec 2014 22:14:25 -0500

Let’s talk about interpolation. Sure, you probably know the Ruby string interpolation syntax:

arg = "world"
puts "Hello #{arg}!" #=> "Hello world!"

This syntax is pretty useful. However, it has it’s limitations. Let’s say that we are generating strings that are almost the same each time, but with each, one word changes. How are you going to do this now?

My first inclination was something like this:

template = "Today the weather is \#{ weather }"
weather_strings = {}

["warm", "cloudy", "windy"].each do |weather|
 weather_strings[weather] = template
end

It’s not hard to see why weather wasn’t interpolated into the strings. Well, it occurred to me shortly thereafter that ERB might be the right way to go with this.

Portfolio

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

Developer Tooling

Viz
Visualize the call graph for Elixir codebases. Especially helpful for debugging and discovering unusual codepaths!
Source
Reveal
Reveal the hidden structure in code. A helpful tool for junior programmers.
See it Source
tree-sitter-gleam
Grammar to construct a concrete syntax tree (CST) from Gleam code.
Source

Toys & Games

Conway's Game of Life
The classic cellular automata.
See it Source
QuAnts
A two-dimensional reverseable cellular automata.
See it Source
Darwin's Game of Evolution
A complicated cellular automata where each cell contains detailed state, including food, size, and rules for how to interact with other cells in the grid.
See it Source

Why do you dress that way?

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

I get asked this a lot, so I wrote a glorified FAQ page. #

The original reason was social engineering lite. Occasionally I would have to dress up for events in high school, and I noticed that when I did people treated me differently. There’s a ton of research into subconscious biases that’s honestly really fascinating, but suffice it to say that police officers are usually nicer to well-dressed people that they pull over.

J3RN's Blog

Avoiding a GenServer Pitfall

Firstly, what is a GenServer? #

My API Integration Methodology

Paper Review: *Compiling Routines* by Richard K. Ridgway, 1952

Compiling Routines #

Richard K. Ridgway, 1952 #

Object Orientation and the Limits of Metaphor

Revealing Reveal

Why I Still Use JavaScript's then

Demystifying .NET Terminology

Why Fedora Silverblue?

Let it Crash?

Let It Crash #

The Four Part Migration

Debugging Elixir with Erlang's dbg

Readability vs Comprehensibility

Readability #

Elixir GenServers vs Agents

GenServer #

Focusing on What Matters

What matters? #

Profiling Elixir for Advent of Code

The Problem #

Truly Declarative: Logic Programming

C #

Elixir Behaviours vs Protocols

Behaviours #

Exciting Changes Coming in Elixir 1.12

The Agile Myth

The Harmful Duality of Elixir's nil

The Problem #

Escaping from Ruby Blocks

Guard Clauses #

To Monkey Patch Ruby

The Problem #

Interpolating Ruby Strings

Portfolio

Developer Tooling

Viz

Reveal

tree-sitter-gleam

Toys & Games

Conway's Game of Life

QuAnts

Darwin's Game of Evolution

Why do you dress that way?

I get asked this a lot, so I wrote a glorified FAQ page. #

Paper Review: Compiling Routines by Richard K. Ridgway, 1952