agentkilo

This is impressive!

I still have my PSP 3000 (bought over a decade ago), which is in great condition, despite the frequency I whip it out and have fun playing the classics.

I mostly just play vanilla single-player games on it, so there's rarely a need to bring it online. But when that occasion appears, it can be really cumbersome. I keep a cheap mobile hotspot around and have it work in WEP mode, just for bridging my PSP to other WiFi networks. I will definitely try this instead.

That said, I think a great feature of PSP (and other old-gen handhelds) is, it can work great while being completely offline. I think I will keep it forever, or until they stop making new batteries for it.

SBCL is a great choice! It's a surprisingly dynamic system (so are other CL implementations).

A while ago, I did some private work for someone, using SBCL, and sent her the native binary I built, then forgot about the whole thing.

The client came back with some new requirements much later, when the project was concluded, and the source code was already lost by that time.

I vaguely remembered how I did things, so I spawned a REPL from the old binary, went into the relevant CL package, wrote a new function that overrides the old behavior, and the client's problem was solved.

I did all those without the original source code. It was a small thing to fix, but I can't imagine making the same fix so swiftly with any other tech stack, when the source code is lost. I was deeply impressed.

This article is really inspiring! I have a few dozen half-baked projects, that's meant for no one else but me, to play with, or to "learn new things" from, but none of them ever became so complete and polished as author's Bauble. I can feel the pure enjoyment of crafting from the article. I hope more people can find out about it, and share OP's joy.

I should really finish what I started. It may take, say, eighteen years, but I should finish them XD

I started with LDD [1], which is a book from a decade ago, but should still be relevant these days. And at some later time I found this treasure trove [2] hidden in FreeBSD docs, among which, the FreeBSD Architecture Handbook and the FreeBSD Developers' Handbook may be of special interest to you.

[1] https://lwn.net/Kernel/LDD3/

[2] https://docs.freebsd.org/en/books/

Very cool! I just started to dvelve into RISC-V, and the book I'm reading (not in English) offers their own emulator[1], which, at a glance, is much simpler than QEMU, and comes with a weird license[2]. I wonder if people actually used it, since it looks like an academic project. Maybe I can also follow this tutorial and test it out.

[1] https://github.com/NJU-ProjectN/nemu/tree/master

[2] https://github.com/NJU-ProjectN/nemu/blob/master/LICENSE

Edit: wrong link

Well I was bothered by a similar problem when tweaking my StumpWM modeline long time ago.

I wanted to show the seconds in the clock on my modeline, but the modeline has a fixed refresh rate, which I set to 1HZ. Then I realized my clock can never be accurate.

Eventually I chose to hide the seconds to stop myself from having those nightmares, but I think they are coming back after reading this article.

Well put. I always have the feeling that any language which has an `eval` function or an invokable compiler can do meta program. That said, I think the "big deal" is in UX/DX. It's really nice to have meta programming support built-in to the language when you need it.

direct link to youtube video: https://youtu.be/atcqMWqB3hw

Well done, the "Guitar Solo" at 1:14 killed me lol.

Thanks to modern technology, as a civilization we can now efficiently convert the energy we harvested into memes.

People should try Janet (the programming language). Its fiber abstraction got everything right IMO.

Functions in Janet don't have "colors", since fiber scheduling is built-in to the runtime in a lower level. You can call "async" functions from anywhere, and Janet's event loop would handle it for you. It's so ergonomic that it almost feels like Erlang.

Janet has something akin to Erlang's supervisor pattern too, which, IMO, is a decent implementation of "structured concurrency" mentioned in the article.