sin-ack's writings

What We Take For Granted

Mon, 08 Dec 2025 08:30:00 +0000

This is the lightning(-ish) talk I gave at TigerBeetle 1000x World Tour Belgrade, transcribed to article form. Huge thanks to Ludwig for hosting the event and the TigerBeetle folks for setting it up.

The slides are available in PDF format as well.

AoC 2022 in ZigSelf, day 2

Fri, 02 Dec 2022 06:00:00 +0000

The second day of Advent of Code was also rather easy on the question side, like day 1. Rather, the hard part was reading the question. :^) Here’s the solution in ZigSelf.

AoC 2022 in ZigSelf, day 1

Thu, 01 Dec 2022 06:00:00 +0000

Hi there. I had mentioned that I would be solving AoC puzzles this year with ZigSelf. I plan to commit to it as much as possible, but no promises. :^)

The first day of AoC has always been quite easy, and today is no exception, so this was rather simple.

The inner workings of ZigSelf's actor model

Sat, 26 Nov 2022 21:00:00 +0000

Hi there. I wanted to do a series of deep dives about various parts of ZigSelf in order to give others a more thorough explanation of how everything works, and also as a braindump in order to verify my thinking. The first post I wanted to make is regarding ZigSelf’s implementation of the actor model, as it’s the feature I believe is one of the most interesting aspects of the language.

That Time I Tried Porting Zig to SerenityOS

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

This was a talk I gave at the Software You Can Love 2022 conference. You can find the slides right here (PDF).

Today I want to tell you a story about the time I ported the Zig compiler to SerenityOS.

I’m going to tell you a bit about what my motivation was to do this. Then I’ll explain the steps I took and the various challenges I faced (there were a lot of those!). We’re going to go into the details of some of the problems that I had to deal with. And finally, I’ll finish it off with my general thoughts… and maybe a little surprise.

ZigSelf Update, August 2022

Sat, 13 Aug 2022 10:00:00 +0100

Hi there. It’s been quite a while since I posted here, mostly due to real life responsibilities. I’m planning on making monthly updates here from now on so that I can showcase the new things that are in ZigSelf. For the first update though, let’s play some catch-up.

ZigSelf: An implementation of Self in Zig

Tue, 01 Mar 2022 10:00:00 +0100

Hello there. I have not posted in a while, and not without good reason. In my first article I had mentioned that I was going to make posts about my own implementation of Self called mySelf. That project never took off, and my interest shifted to other things. I had largely forgotten about it, but then LangJam happened.

LangJam

LangJam is a programming jam that works similar to game jams, but instead of developing video games you develop a programming language based around the theme of the jam. When I heard about it back in August, I remembered about my interest in implementing Self, and decided to join the jam. My implementation went largely nowhere, as it wasn’t really interesting from the standpoint of the jam’s theme. However, spending 48 hours to implement the lexer, parser and then a basic interpreter was pretty fun, and I started wondering again.

How malloc broke Serenity's JPGLoader, or: how to win the lottery

Thu, 03 Jun 2021 00:00:00 +0200

I got the chance to investigate an interesting bug in SerenityOS this week. It was related to the decoding of JPG images in the operating system. For some reason, when a JPG image is viewed, it comes out like this:

Lenna, showing up with incorrect colors.

Weird, huh? Also seems like a simple confusion of RGB vs. BGR. And sure enough, making the following change on JPGLoader.cpp:

-   const Color color { (u8)block.y[pixel_index], (u8)block.cb[pixel_index], (u8)block.cr[pixel_index] };
+   const Color color { (u8)block.cr[pixel_index], (u8)block.cb[pixel_index], (u8)block.y[pixel_index] };
    context.bitmap->set_pixel(x, y, color);

makes the image show up correctly. Case closed!

…not. Why did this even break in the first place?

A look at Self's object system

Mon, 29 Mar 2021 13:00:00 +0200

When I first introduced Self, I mentioned that Self is a programming language which employs prototype-based inheritance; it does not depend on a class-instance distinction to facilitate object-oriented programming, but rather, it uses a prototype object from which copies are created. The methods associated with a prototype is stored in a traits object which is just another object storing methods that can be used on a prototype and all its copies through a parent slot.

The trouble begins when we actually try to implement this prototype-based inheritance system as an actual virtual machine, particularly with regards to memory consumption. Say that I have a prototype object point with a constant parent slot pointing to traits point and two assignable slots, x and y.¹ When we copy this object, we would expect to copy all three fields. But if we scale that up, that’s so much unnecessary data being copied! For one, for every copy of the point prototype we make, we’re copying that traits point parent slot reference. Not to mention, because our language is dynamic, we can’t simply treat x and y as offsets into memory, because they might be constant or assignable (Self can’t intrinsically know). So our naive implementation would be pretty inefficient.

Can we make this more memory-efficient? In fact, we can; we can exploit the fact that most Self objects that are copied only ever have their assignable slots modified. Let’s take a look at how the original developers of Self have optimized the memory usage of the Self virtual machine.

An introduction to Morphic: Self's UI toolkit

Sun, 17 Jan 2021 17:35:06 +0100

In my previous two posts, I talked about Self as the language, and the system which allows it to serialize objects into text format. Now let’s talk about another big part of Self, which is the programming environment and the UI toolkit that it is created from: Morphic.

Self Transporter: how to share your Self code

Sat, 16 Jan 2021 22:13:00 +0100

In my previous post, I talked about Self and gave a general tour of the language and the programming environment. I mentioned that Self was an image-based programming language. Of course, if you want to develop a Self application with multiple people, an image is not suitable for collaborating (except in real-time – we’ll come back to that in a later post). Your Self image contains everything in your programming environment (provided you don’t forget to save it!), including the active morphs you have on the screen, and stuff you are working on. Therefore, obviously, it is not possible to collaborate using your world images on version control.

So then the question becomes “How can we extract just the parts of our application so that they can be re-imported to other Self worlds independently?” And the answer to that is the Transporter system.

A tour of Self

Thu, 14 Jan 2021 16:51:08 +0100

Hey there. This is the first post I will be making here, and I wanted to give a tour of Self before making posts about my current implementation, mySelf.

Throughout this post, I will be showing examples from the regular implementation of the Self programming environment, available here.

What is Self?

To quote the Self language homepage:

Self is a prototype-based dynamic object-oriented programming language, environment, and virtual machine centered around the principles of simplicity, uniformity, concreteness, and liveness. Self includes a programming language, a collection of objects defined in the Self language, and a programming environment built in Self for writing Self programs. The language and environment attempt to present objects to the programmer and user in as direct and physical a way as possible. The system uses the prototype-based style of object construction.