For my post this month, I wanted to present the entirety of a tutorial I just created for learning to use Cakelisp. The most up-to-date version will be kept here.

Enjoy!

This tutorial will introduce you to Cakelisp's most unique feature, compile-time code generation. I'm not going to introduce fundamental programming constructs like variables or conditional logic---I'm going to focus on what makes Cakelisp special. This is the most important thing to cover because it is the least familiar to new users from other languages.

Prerequisites

• Experience writing C or C++ programs. If you're just learning how to program, you should learn a different language rather than Cakelisp for now.

Setup

First, download Cakelisp. You can also clone it through git. The URL is https://macoy.me/code/macoy/cakelisp

This post is mirrored on my website.

It is common advice that it isn't worth automating something unless the time saved doing the task is greater than the time required to automate it.

Randall Munroe has two relevant xkcd comics (license):

This comic is the most relevant to this article:

When I talk about automation, I include things like code generation and macros, which automate code writing.

I am going to argue that doing work to automate things may still be worth your time, even if it takes longer than it would have without the automation.

Ethics of unergonomic interfaces

Recently, I have been thinking about user interface ergonomics, or how well an interface, be it textual code

This post is also on my blog.

I have been working hard on a file organization application written in Cakelisp. This is part of my career goal to sell my software. The project's name is File Helper (I haven't spent any time trying to come up with a better name yet).

I believe I have a good approach to thinking about my projects. It is sometimes hard to define project success in terms other than "other people think it's really cool". There are a large number of reasons why a project is still a success, even if it ends up not being popular.

Accumulating code

I have been continuously improving Cakelisp and GameLib and intend to continue using these tools on future pro

Cakelisp Alpha 3 is now released.

It has been a while since I last pushed a release. This is solely because I didn't have any set milestone I was targeting for v0.3.0. Nevertheless, I got a lot done:

• Compile-time code uses a precompiled "CakelispComptime" header. This speeds up compile-time code compilation by about 50% in my tests
• `tokenize-push` was overhauled to be in a really good place going forwards. This was important to allow macros with unlimited token array sizes
• Types now support arbitrary keywords, which means `volatile`, `unsigned`, etc. are supported instead of just `const`
• Various C and C++ constructs are now included in `runtime/` such as `defenum` for `enum` support and a work-in-progress `class` generator
• Tokenizer is more robust to weird edge-cases
• Emacs support is improved
• Many bug fixes

Overall, the language is in a really good state.

The following post is mirrored on my blog.

I have been making progress on several fronts with Cakelisp and GameLib, but in this post I wanted to focus on an exciting work-in-progress addition I have: type introspection.

What it is

Type introspection refers to the ability to inspect types at runtime. Reflection is the ability to both inspect and modify types at runtime, which I'm not going to talk about here. By types, I'm referring primarily to structured data, e.g. struct in C.

What this means is that given a type my-struct, you could write a loop which iterates over the fields in that struct at runtime and know some information about that field, without having to write a single line of code per each field.

I am going to attempt to convince you why this is an essential feature to

It has been a while since I last wrote an article. Last month, I left my previous job after six years there. I moved from California to the East Coast to start at a new job, which I have been enjoying so far. The change has been especially good for showing both how much I know and how much I have to learn.

I also had several realizations about what I want to do with my career.

Goals

My current career goal is to become self-sufficient by creating products that I both believe in and own personally[1].

Cakelisp was one step towards that goal for me. I wanted to create an environment where I felt happy and empowered, two things I didn't feel with existing tools. However, recently I have realized that I had blinders on in regards to the broader, holistic view of my goal. I only focused on optimizing my development environment.

If I want to achieve my goals, I need to optimize every part of the process.

It is

I moved from the West Coast to the East Coast. It was a busy time and I still don't have a desk or chair to type at. I'm making this post to let you know why I won't be publishing Cakelisp content for a bit. I should have something for July, as I did make progress since my last article.

I have been working through LearnOpenGL lately because my graphics programming knowledge lags behind. Last time I did graphics, it was all fixed-function pipeline.

The problem

In order to use OpenGL, it is generally recommended to use an OpenGL loading library. These libraries facilitate requesting the gl* function pointers to the functions you might use, depending on what version and extensions of OpenGL you use.

I am not a huge fan of this because it feels like it shifts the complexity onto the users of OpenGL. When designing APIs, it's good practice in my mind to try not to make things which spread complexity. I understand the desire for loaders because they facilitate creation of drivers with only partial OpenGL support, but it does make things harder for the end-user of the API.

Solutions I don't like

LearnOpenGL chose [url=https://glad.dav1d.de/]G

There were several cleanup and features added to Cakelisp since the last post:

Precompiled headers for comptime compilation is now merged to master. I put in a lot of work to get them working on Windows as well, though I didn't see the performance improvements I was hoping for on that platform.

tokenize-push was rewritten. This generator is the primary way to populate new Token arrays, and is the foundation of all macros in Cakelisp. For example:

(defmacro array-size (array-token symbol)
  (tokenize-push output
    (/ (sizeof (token-splice array-token))
       (sizeof (at 0 (token-splice array-token)))))
  (return true))

My first implementation of tokenize-pus

I am happy to be a new part of Handmade Network!

Progress since submission

There have been several things I've been working on since I submitted Cakelisp to the network:

Kitty Gridlock completion Kitty Gridlock is a game I made in about 3 weeks (off-hours, weekends primarily) for my girlfriend. I had a deadline to deliver (her birthday), so I had a good goal and could limit scope effectively.

I wanted to prove to myself that I could be productive in Cakelisp in its current state, i.e., without making any modifications to the language. I was absolutely successful in this goal: I got the game done faster than expected, without having to make changes to Cakelisp.

Thanks to SDL's portability features, I was able to port Kitty Gridlock to the target platform, Android, in a matter of days. The use of C++ as the output language was a definite boon to this, because it naturally meant support for the Android NDK environment.

I'm no artist, but I was quite please