This article is mirrored on my blog.

I have been working on a voxel-based game for the last several months. As part of its development, I created a binary versioning and migration system that I haven't seen before.

Game data goals

Arguably the most important aspect of a game's technical architecture is its data model. The choice of the data model has wide-ranging impacts on iteration speed, development time, game design, player experience, performance, and more.

I had several goals in mind when deciding this game's data model:

• No loading screens. Computer hardware has gotten to the point where gigabytes of data can be read from SSDs in a single second. With discipline, I should be able to calculate when my game can display its first playable frame (i.e., from launching the executable to regular gameplay) based on how much data I need to load and how fas

This post is mirrored on my blog.

It has been a while since I talked about my dynamic environment work mentioned in this post inspired by this post. I thought I would give an update, although unfortunately I don't have great news.

My modifications

The approach I settled on for enabling a dynamic environment in a compiled C world was building off of Tiny C Compiler.

I made several changes to TCC for environments, including:

• Custom allocators for guaranteeing relative reference offsets will be valid
• Functions to expose ELF symbols so the environment can decide which symbols to re-use from the live environment
• Automatically convert "local" symbols to be PC relative instead, allowing the envir

This post is mirrored on my blog.

I started my morning off with Alan Kay's talk Programming and Scaling. There are several things I agree with and disagree with in that talk. It got me thinking about software as a whole, and my part to play in it.

Background

I have long been a fan of Jonathan Blow and Casey Muratori. Two talks in particular have been especially influential for me:

• Preventing the Collapse of Civilization by Jonathan Blow, which argues that technology does not naturally progress, and can regress and even collapse.
• The Thirty Million Line Problem by Casey Muratori, which points out the problem of software growing larger than can be comprehended.

My other programming hero, John Carmack, has a differen

This post is mirrored on my blog.

I have been hard at work on my dynamic environment based on Tiny C Compiler. It has been going worse than I hoped. I am attempting to static link SDL 2 with an application I want to test the dynamic environment on. I am soldiering on, and hope to have something useful before the end of the month. If I can't get it by then, I may need to look for other options. It has been an uphill battle mainly because these tools were never intended to be used this way, but provide enough value that rewriting from scratch doesn't feel like a viable option for me.

Cakelisp itself has some new features worth mentioning.

File and line macros

I added (this-file) and (this-line) macros to Cakelisp's runtime macro library. These macros replace their invocation with the filename as a string or the Cakelisp line num

This article is mirrored on my blog.

News

It has been nearly a month since my last post, and there have been some interesting developments.

RSS now supported

This blog now has RSS generated. I wrote the generator in Cakelisp, of course. You should be able to add this blog to your favorite feed reader by entering https://macoy.me as the URL. Note that HTTP is not supported, so depending on your feed reader's defaults, you will likely need to specify the https:// rather than just macoy.me.

Comments on Linker-Loader

My post on bringing a dynamic environment to C was on the front page of Hacker News a few weeks ago. The post got a good amount of positive comments, which was rew

This article is mirrored on my blog.

In my last article I wrote about integrated development environments. Lately, I have been thinking about how regular applications would benefit from being easy to modify. Imagine every application also included a development environment tailored to the application.

Stop Writing Dead Programs by Jack Rusher captures a lot of where my head is at here. There is a huge amount of value both for the user and the developer in pursuing this.

Trivial and natural modifiability

Emacs is the only program where I truly feel that I can naturally modify it. The code for any function in the system can be quickly and easily navigated to. Modifying the code is as easy as making my changes to the text, then highlighting it and "eval

This article is also available on my blog.

I spend a lot of time thinking about development tools. In this article I want to discuss integrated development environments. These are programs that provide text editing (usually code) as well as a variety of features tailored to making the software development process smoother.

Why you should care

Better tools can make the development process more efficient. This doesn't just save you time, but also changes what you are willing to do.

A good text editor is at the core of writing code, but it is only the start. The more integration you can perform, e.g. by making your editor aware of your language of choice and its symbols, building the program directly from the editor, and even debugging and visualizing program execution in the editor, the more seamless and natural develop

This post is mirrored on my blog.

Cakelisp is now developed here. The GitHub branch is already stale, and I do not plan on mirroring to GitHub. While I had many reasons for migrating, the straw that broke the camel's back was Copilot, which in order to resist I must keep my code off of GitHub entirely.

Migration progress

The GitHub migration I planned has gone slower than I expected.

I didn't have an urgent reason to move, so I admittedly took my time with it. It is annoying work as well:

• I had to go repository-by-repository and verify I had mirrored them to my Gitea instance properly. I have 59 repositories, most of which are original work.
• I needed to update every repository that references the GitHub source for its submodules to instead reference the macoy.me source

This post is mirrored on my blog.

It has been a while since I felt the need to add features and make some more significant changes to Cakelisp.

Two came in this past month: defer and CRC builds.

defer

The defer feature is one I had been wanting for a while, but was unsure about how I wanted to implement it cleanly.

Here's an example usage of defer:

(defun main (&return int)
  (var file (* FILE) (fopen "File.txt", "rb"))
  (unless file
    (return 1))
  (defer (fclose file))
  ;; Do file operations...
  (return 0))

By putting defer there, I am guaranteed to have the file closed if the function ever returns. This removes the need to copy-paste (fclose file) before every return, which can be very cumbersome. It also makes the program more reliable, because I might forget to paste the fclose.

This feature can be found in many oth

This post is mirrored on my blog.

In order to effectively write applications that communicate via sockets, there were some realizations I needed to make that weren't explicitly told to me by any of the documentation I read.

If you have experience writing applications using sockets, all of this information should be obvious to you. It wasn't obvious to me as an absolute beginner, so I'm trying to make it more explicit in the hopes of shortening another beginner's time getting their feet wet with sockets.

TCP reliability vs. application reliability

TCP guarantees reliability in regards to the stream; it does not guarantee that every send() was recv()'d by the connection. This distinction is important. It took me a while to realize it.

The core problem I was trying to solve is how to cleanly handle a [network partition](https://en.wikipedia.org/wiki/Network_partitio

This article is mirrored on my blog.

I have been migrating all of my code from GitHub to my self-hosted Gitea instance.

My Gitea instance has been mirroring my GitHub code when it changes. In the next week or so, I will be deleting my code outright from GitHub.

Here's article that pushed me to finally do it: Give Up GitHub: The Time Has Come!

I am doing this for several reasons:

• I don't want my code plagiarized by Copilot. (Although, writing code in Cakelisp makes that a non-issue!)
• The master fiasco. Any way you swing on any issues, I don't want politics showing up on my code hosting site.
• I don't like how the youtube-dl takedown was h

This article is mirrored on my blog.

I have several projects written in Cakelisp that I have been chipping away at.

File Helper

I haven't made much progress on File Helper, but I do find myself reaching for it and hope to revisit it.

I want to create a command-line interface for creating an index of files on systems I have which aren't graphical. I can then tag and visualize the file system on my work station.

Machsearch

My newest application does indexing full-text search. It's much faster than ag, grep, or any other non-indexing full-text search.

It's so fast that you can search as you type, and it scales very well to large codebases thanks to its

This article is mirrored on my blog

My linker in development was crashing on free. It was calling one malloc but then freeing with a free associated with a different malloc. This subsequently caused a segmentation fault because the free expected a metadata structure that didn't exist in the other malloc (at least, not at the same size).

This took a lot of sleuthing. I knew it was a problem with my linker/loader, but couldn't step-debug it because my loader doesn't create a program image the way GDB expects.[^1]

This article goes over how I found the issue. It might help you if you are encountering strange things with your work-in-progress linker (ha ha!), or like reading about someone debugging something.[^2]

Finding the problem

The problem manifest in my attempt to statically link[^3] the following simple Cakelisp pr

This article is mirrored on my blog.

I'm writing a linker. It's an unusual linker. It's focus is not on producing executable files. Instead, its focus is to facilitate rapid iteration on a program without having to re-link or re-open it after making changes. It is hot-loading of code at an object-file granularity.

I realized from reading Andreas Fredriksson's Hot Runtime Linking (archive.org) that the dynamism I've been wanting in a ahead-of-time compiled environment could be achieved by taking over the linking and loading stages. I made an attempt to support hot-reloading in Cakelisp, but it was fragile and limited. Not only was working at the link/load stage a better fit, but

This is mirrored on my blog.

I have invested a significant amount of time in building Cakelisp for several reasons, but I think the main one was easier access and better integration of code generation.

In this article I'm going to give a high-level view of what I mean by "code generation" as well as a taste of how it can be used.

What is code generation?

By "code generation", I mean a piece of code which outputs more code.

A similar concept in another field might be "jigs". Jigs are essentially tools often built by the maker in the process of building another thing. An example of a jig in woodworking would be a table saw sled. These sleds assist in making various different cuts safer, easier, and faster on a table saw.

One satisfying aspect of jigs is that they are often custom built, and sometimes even built using t

This post is mirrored on my blog.

In the late 1950's, Lisp was invented, which used the S-expression syntax style. It looks like this (in this case it is Cakelisp, the programming language I made):

(defun main (num-arguments int
             arguments ([] (* char))
             &return int)
  (fprintf stderr "Hello, Cakelisp!\n")
  (return 0))

In 1998 the XML specification was published. XML looks like this:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg width="100%" height="100%" xmlns="http://www.w3.org/2000/svg" version="1.1">
  <rect x="0" y="0" width="100%" height="100%" fill="#333333"/>
  <rect x="0in" y="0.000000in" width="5in" height="2in" fill="#aaaaaa"/>
  <rect x="2in" y="3.500000in" width="5in" height="2in" fill="#aaaaaa"/>
  <rect x="4in" y="7.000000in" width="5in" height="2in" fi

This tutorial introduces a way to set up projects that use Cakelisp. This isn't the only way, so you shouldn't feel you have to follow this format.

An example repository (which also uses GameLib) is available here.

Prerequisites

The following operating systems are supported by Cakelisp:

• GNU/Linux
• macOS
• Windows

Anything POSIX/Unix-y will likely work because Cakelisp uses the C++ standard library and the platform's C/C++ compiler only.

You need a C++ compiler installed or available to build Cakelisp itself. Cakelisp will use this compiler while cakelisp is running to build compile-time code. You also need your target's C/C++ compiler so Cakelisp can build the code it generates.

You should install git for the best experience. You can download the code manually, but that will make getting updates harder.

Project setup

The ass

This post is mirrored on my blog.

I have been relatively busy lately due to unpacking all my things from my cross-country move. Some of my hobbies have been receiving more time. However, don't worry, Cakelisp and GameLib development still continues.

For this month, I'm going to write a short article about an approach I take to difficult programming tasks. I call it "surgical programming".

The key difference between junior and mid-level software engineers

In my career, I think one of the most important skills I had to develop was learning how to read code.

My less-experienced self would frequently reach out for documentation, or only read function signatures. I would call functions other people had written without reading them myself to confirm they did what they claimed.

Now, I rarely ever read online documentation. The code is the

This article is mirrored on my blog.

I started working on Cakelisp a little more than a year ago. I started the project after searching for a programming language that met all my requirements, and found nothing which matched.

I figure this is a good time to take stock and talk about what is in the future for Cakelisp.

Popularity

My goal was never to make a language that everyone wanted to use. I always approached Cakelisp with the goal of making the perfect language for me, without considering too much how other people would like it.

This gives me a whole lot of flexibility when making decisions. I can play more fast-and-loose and make big changes without worrying.

Besides, even if I did try to make a language for "everyone", I believe I would have failed to get much more attention.

As it stands, Cakelisp has over two hundred "sta

This article is mirrored on my blog.

I recently released File Helper, a file organization application I wrote using Cakelisp.

This application had only two external files that were necessary for it to fully function:

• A font
• An application icon

I packaged File Helper in a .zip or .tar.gz for Windows or Linux respectively. These archives contain the platform executable as well as a license file and the two necessary font and icon files.

However, wouldn't it be nice if instead I shipped a single executable, thereby eliminating the extract step?

It might sound trivial, but eliminating that extra step has many benefits:

• Less technical users won't get confused. Double-clicking an archive usually opens it in a browser rather than extracting it, which might confuse them and cause them to not use my product.
• The application has no risk of