So happy to finally share something I've been working on for some time. I'm releasing a new low level programming fundamentals course! It's called "The Simple Joy Of Programming", and you can find out more in this video:

Apparently Patreon (and recurring subs in general) have issues in India because of RBI requirements. Anyone have any advice or alternative ideas for helping people in India get access to Patreon? I've seen people accept ad hoc payments through paypal but that seems non ideal.

The more I read of Dijkstra's writing, the more it becomes clear that he would have been an absolute menace on programming twitter

Life is funny. You watch one piece as a kid and imagine yourself as luffy, zoro, sanji. Then you grow up and realise you are, in fact, usopp.

I’ve finally realised why the Americans love Halloween. It’s a necessary evil to prevent the Christmas decorations going up too early, like wolves controlling the deer population in Yellowstone.

In the programming course I'm publishing, we build a small ISA / virtual machine from scratch, and we've just reached backwards jumps which means loops! Here's the sandbox implementation computing iterations of the collatz conjecture, it's fun to watch

It's surprising to me that there isn't really a ubiquitous term like "array" that we use to describe contiguous elements that are variable width. I know arrays end up being the vast majority use case, but still. We have agreed upon terminology for much more obscure things.

Don't get me wrong it's important to understand bitfields / flags / sub byte formats, but I personally think I would have found byte addressability, endianness, booleans "not actually being 1 bit" etc much more straightforward starting at bytes and then zooming in later.

I'm unironically starting to think it makes more sense to teach computing as intrinsically base 256 first rather than base 2. In my experience students tend to latch onto the concept of bits, to the detriment of their understanding of bytes as the base addressable unit.

I think if a programmer had been in charge of the original design of timezones, we would have ended up with just one global timezone for everyone (california), and if it happened to be midday at 1am in your country, tough luck

Somewhere that I could see there being innovation in a modern programming language is better tooling for data layout & visualisation. Most languages feel overly focused on operations, whereas data layout, structures & types are just as (if not often more) important.

It's also one of the things that makes the most sense to me about Rust as a C person. My data lifetimes are very clear in my own C projects, but when publishing an open source library like Clay, being able to enforce the lifetime on user data would solve a lot of headaches.

In garbage collected languages this simply doesn't happen. If the library retains a reference to an object, it won't get de-allocated. Neither the user or the library maintainer often even thinks about the lifetime of shared data / objects.

One of the absolute classic examples is when retaining a pointer passed in by the user. While of course we try to avoid internal state where possible, in reality this happens often. And there's no way to prevent a user from accidentally passing a pointer to a stack variable.

This is especially obvious in C. C is a beautiful language for solo and team dev, as long as you're able to establish and follow some conventions. But it lacks language features to actually enforce a number of critical implicit rules, especially wrt memory and lifetimes.

As you go from solo dev -> open source lib, the effectiveness of those implicit rules drops significantly. You have a good chance of teaching & enforcing rules on a well disciplined team, for an open source lib, you can expect users to make mistakes immediately.

When designing those rules for usage of your code, there tends to be three distinct situations: - Solo dev (you are the only user) - Multi dev "team" - (you know the users personally) - Open source / library maintainer (you don't know who the users are)

When re-using code or interacting with a library, there are rules that need to be followed for that code to work correctly. Some are explicit and enforced by the compiler ("the function takes these arguments"), some implicit / learned ("you must call the functions in this order")

Might be a hot take, but after seeing the awesome work @its_bvisness has done here, I strongly feel like Unreal blueprints (and node graphs in general) should be automatically laid out, and not allow the user to move things arbitrarily. IME you get used to auto format quickly.

LLM's generating example code full of emoji comments