Beet Box

OpenGL is needlessly hard... but not impossible

Thu, 07 Aug 2025 17:10:41 -0400

Since around 2020, I’ve tinkered with writing a custom game engine three separate times, each time in an attempt to create a new 2D game. Why a custom engine? Because I wanted to learn how to do it.

I began with moderngl in Python. By the time I was able to render a tilemap and move a character around the screen, I tired of the project and couldn’t find motivation to continue. More than a year later, I gave a different game a shot with raylib bindings for Go, and I made a bit more progress. But to my own detriment, I’m a picky person.

The Family Compute Center

Thu, 19 Jun 2025 20:24:25 -0400

This article is written for those who are unfamiliar with Plan 9 and the 9P protocol, especially if you manage the devices for your household.

The Family Computer

If you grew up some time between 1980 and 2010, you likely had a family computer. Around the year 2004, as the PC became more popular, my family went from having two computers in the house to three.¹ For just about every family I know, computing trends followed this path, to a fault. As a result of this blind rush towards personal computing, the way we use computers has become expensive, finicky, and artificially limited. We just don’t think of it that way.

You Don't Need All That Code

Thu, 05 Jun 2025 10:53:16 -0400

Many blog articles and social media posts are shared online to demonstrate programming “patterns”. This isn’t a new phenomenon, but I only recently realized that most of these posts include code that accomplishes nothing. In the following sections, I will share examples I’ve found (written in Go) juxtaposed with the code actually required to accomplish the task.

The singleton pattern

type Service interface {
	Do()
}

type EmailService struct{}

func (e *EmailService) Do() {
	fmt.Println("Sending email...")
}

// Service Registry holds registered services
type ServiceRegistry struct {
	services map[string]Service
}

func NewRegistry() *ServiceRegistry {
	return &ServiceRegistry{
		services: make(map[string]Service),
	}
}

func (r *ServiceRegistry) Register(name string, s Service) {
	r.services[name] = s
}

func (r *ServiceRegistry) Get(name string) Service {
	return r.services[name]
}

// Usage
func main() {
	reg := NewRegistry()
	reg.Register("email", &EmailService{})
}

If you don’t look too closely, this looks pretty impressive. I mean, it’s a lot of code! It has to be doing something useful, right? If we take the poster’s word for it, this demonstrates the singleton pattern.

Simple Software

Thu, 15 May 2025 16:01:59 -0400

In my previous post, I remarked that the unifying concept behind my development philosophy is simplicity. Of the many considerations in writing software, performance, reliability, and predictable orthogonal features readily come to mind. How might simplicity be a unifying concept to these considerations and dozens of others?

It comes down to the fact that software is produced by and for people. If software is to be well understood, it needs to be simple enough for a person to grasp. Is it possible to make software performant if you don’t understand it? Is it possible to make software reliable if you don’t understand it? Is it possible to add predictable orthogonal features to a program if you don’t understand it?

Things I Appreciate About Plan 9

Sun, 16 Feb 2025 22:08:45 -0500

A few weeks ago I got a hold of a Dell OptiPlex and installed 9front on it. I’d like to share some things I appreciate about the system after having used it for around twenty hours.

rio

Having used tiling window managers for several years, I was surprised at how much I enjoy rio. The transition to a mouse controlled workflow was made easy by its thoughtful design. For those unfamiliar, window operations are mostly handled through a menu brought up by clicking and holding button three on the mouse. Of course, this eliminates noise and redundancy from window decorations, but there is something more I like. Rio remembers what option you picked last, and preselects it for you upon initializing the menu. That means repeated window operations become easier. This is contrary to the interface presented by Windows, macOS, and many X11 desktop environments, where decorations on the window require precision clicks for each interaction. On those systems, closing two windows in a row is no easier than closing a single window. The same can be said for resizing them as well. If you’re curious as to what that looks like, here is a quick recording.

To New Graduates: Introduction

Wed, 03 Jul 2024 15:29:49 -0400

Simple Software

Embarking on a career in software development presents new challenges, goals, and rewards, regardless if you’ve completed any formal software engineering program. I received a bachelors degree in computer science in 2020, and spent months interning during the four-year program. Despite this, the things I came to learn from working full-time have built upon the fundamentals of my college education in ways I could never have predicted. Over the course of the next six posts in this series, I hope to make an impression of how my values and mentality have developed in the four years since completing my degree.

Do Not Fear Systems Programming

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

First time with low level networking

In my junior year of college, I took a computer networking course. It was my introduction to C++, glibc, sockets, and other topics, covered in around six assignments. These assignments included making a chat program, and a client and server for a subset of FTP.

At that point, I had written HTTP servers, but had never dealt with raw bytes going over sockets. The beginning was intimidating, but the course and professor primed my intrigue. After the final, I had changed from avoiding systems programming to being distantly interested.

What to Test

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

What to test (with examples in Go)

When first exposed to automated testing, many people wonder what code they should test. The following article focuses on what to test and is not a guide to using the Go testing package. The code comes from real solutions to a kata on codewars.com.

The Kata

Let’s imagine we are writing code for our startup that provides software for making computations with odd numbers. Our first task is to write a function that finds which integer within a slice appears an odd number of times. Here is our solution:

Work Updates

Sun, 07 May 2023 00:00:00 +0000

A Pleasant Work Reflection in May.

I last wrote about some frustrations I encountered with a new project and database at work. Towards the end of my post, I remarked on using an ML inspired language like OCaml for extra compile time guarantees. I couldn’t be happier to say that since February, I have been working almost exclusively in Go and F#.

This post may be informational, but mostly serves as a way for me to express gratitude for languages and tools I’ve been using recently.

Languages Blocking Language

Sun, 20 Nov 2022 00:00:00 +0000

Software developed for businesses is usually comprised of many layers. Many are familiar with the concept of front end, authentication, back end, and database layers. Front end, back end, and databases allow many choices of language, framework, or hosting. Authentication has its fair share of choices, but as far as I’ve seen, few protocols are promoted.

A standard authentication pattern

The best supported authentication protocols I’ve come across for intracompany services include

I Love Errors

Wed, 28 Sep 2022 00:00:00 +0000

I LOVE ERRORS. I LOVE ERRORS. I LOVE ERRORS.

Seriously, I do. In an environment where errors are inevitable, how do we embrace them? Errors permeate every part of our programs, but usually this isn’t easy to notice. Often, potential errors hide in our programs, and leap out at inopportune moments during runtime.

Provided we cannot eliminate errors, it would be great to know exactly when they can happen, and make guarantees about our programs. We want to avoid hiding errors with syntax and language rules if these practices confuse our understanding of a program’s execution. Luckily this is simple, and it can be done in any language, but is only considered idiomatic in a handful of popular ones.

Open Source Without GitHub

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

For better or for worse, GitHub has become a ubiquitous part of open source software. In this post, I’m going to talk about how to break away from GitHub, and federalize open source.

The convenience of one platform

It’s impossible to deny that one of the reasons GitHub is so popular is likely because many features are packaged together. Forking projects, publishing personal repos, contributing changes, and tracking issues are all included on the platform. To break away from GitHub, I’ve personally had to give up some of this perceived convenience. My projects, hosted on a personal Gitea server, have issue tracking, pull requests, and forks. But, of course, no one would want to create yet another online account on my site to contribute changes.

Ruby Footguns

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

Exploring Ruby Metaprogramming Footguns

The last few weeks, I’ve been learning different languages to see what’s popular outside my regular sphere. My journey took me to lots of articles written by Ruby enthusiasts, and the common usage of metaprogramming. Plenty of languages support metaprogramming, but I’ve seen very few communities use and encourage it actively. It’s even used in considerably “Enterprise Projects” such as RSpec and Active Record.

In an effort to have fun with metaprogramming, I’ve created a project of intentional Ruby Footguns. This project is not a point against metaprogramming or meant to showcase potential problems, it is simply meant to make me laugh… or facepalm.

Go, One Year Later

Mon, 21 Mar 2022 20:00:00 -0400

Three years of Go, one year of rigorous use. What’s the lesson?

When I began learning Go, I generally avoided languages that felt different from what I knew. I had mainly been developing in Python and Java, and the lack of Exceptions in Go stopped me from giving it a serious attempt for years. In a completely expected 180, after 4 years of using Go, it’s style of error handling has become one of my favorite features. In this article, I want to share several of my other favorite things I’ve been taught while practicing with Go.

My Favorite ECS Game Engines

Sat, 29 May 2021 15:00:00 -0500

Personal Favorite ECS Game Engines

Over the last 8 months, I’ve been writing an ECS engine in Python for Happy Wizard. It’s been a great learning experience, and I’ve managed to happily surpass my expectations.

Though I will continue developing the engine and Happy Wizard, I’ve had the desire to complete a game and focus on developing game mechanics rather than an engine.

I’ve opted to look for a simple, existing ECS engine to use and share my thought process of considering each for you to adapt or critique.

Considering Debian and Arch

Mon, 12 Apr 2021 09:00:00 -0500

Deciding between two great distributions

I’ve used many Linux distributions over the last 4 years, and as I learned more, their differences narrowed to just:

The package manager
The available packages
The frequency of package updates and system upgrades

I love the Arch package manager, and between the official packages and the AUR, I have access to every package that I need. I appreciate how up to date everything is, but lately, I’m feeling the trade-off of needing to update so frequently.

Error Handling in Rust and Go

Sat, 27 Mar 2021 19:00:00 -0500

Handling errors in popular languages

The first three years I spent programming, the only error handling I knew was the exception. Raising, throwing, or catching exceptions was the way I handled bad input in my programs.

It wasn’t until I took a course using C++ that I saw other methods of signaling errors. C++ has exceptions, but we often used C libraries that would return error codes as integers. I thought this was odd, but put up with the constraints of the “old language”.

Saving Time With the Unix Philosophy

Sun, 28 Feb 2021 17:00:00 -0500

How Unix programs save me time

In the last six months or so, I’ve been delving into minimalist programs provided in my distributions default packages. By minimalist programs, I mean that they do one task well, and interact with other programs, just as the Unix Philosophy dictates. They are extensible, and become more useful when interacting with other programs. By doing so, they never need to duplicate features of other programs.

Code Formatting in Neovim for Beginners

Fri, 23 Oct 2020 10:00:00 -0500

Easing the cluttered mind

When developing software, I like to remove choices from my workflow. This may sound limiting, but if you remove the right choices from your development process will be maximally streamlined.

Recently, I noticed that formatting my code style was taking up too much of my development time. In pertinence to whitespace, curly braces, ternary operations, import order, and identifier names I’ve always had a consistent style, but enforcing it was a chore. The less time I spend worrying about those tasks, the more “brain cycles” I can spend on writing features, tests, and bug fixes. If linting and formatting is not new to you, you can skip here to see how to accomplish it in neovim.

4 Great Qualities of Codewars

Sun, 17 May 2020 10:00:00 -0500

My experience with Codewars

I was recommended by a professor early in my final semester to participate on websites such as Codewars, TopCoder, and other programming challenge websites with our ACM chapter. Since the semester ended up being so busy and coming to an early end, I was only able to try out these websites a few weeks ago. I’ve spent the most time on Codewars and want to share a few things that I appreciate about the site with you.

My Introduction to ECS

Thu, 14 May 2020 10:00:00 -0500

My discovery of ECS (entity component system)

I developed my first game, SpaceMail, with GameMaker Studio and GameMaker Studio 2. During the rework, I decided to use the Godot engine to cut my dependency on Windows. On both implementations, I used an object-oriented approach, as that’s what I had been taught in college.

The Amethyst game engine

I hadn’t heard of any other approach to game development and hadn’t imagined there would really be another simple approach. I only discovered ECS when my interest in Rust began. After using C++ in my networking class in college, I wanted to harness the power of low-level languages. I had nothing against the language C or C++, but what I struggled with was my inability to find proper documentation for libraries I wanted to use. Every reference or guide seemed either too antiquated or assumed I knew more than I did. This is where Rust shined for me. The Rust book itself was a massive help in picking up the language, and it seemed like every library I was interested in had decent documentation as well!

New Beginnings

Mon, 11 May 2020 20:51:00 -0500

Introduction to the rebranding of BeetBox

Hello, everyone! I’ve just recently completed my final semester of college, and I am looking forward to the time I will have in the evenings to work on my own projects again.

You may also notice that I am in the process of rebranding from beetboxgames.com to beetbox.io. I feel that change better reflects the official DBA and also gives me room to develop different kinds of software under this name.