Gary Moore's Website

    
_______                    __          __               
|     __|.---.-.----.--.--.|  |.-----. |  |_.-----.-----.
|    |  ||  _  |   _|  |  | |_||__ --| |   _|  _  |  -__|
|_______||___._|__| |___  |    |_____| |____|_____|_____|
                    |_____|                              

---

Automatic .plan Upload
----------------------

This is my first proper automatic upload of my .plan file using my kqueue based
watcher[0]. Should use zero CPU while not in use, and I can write these plan files
by just editing the file in neovim or whatever editor, and on save it'll
automatically get uploaded to my website.

I'm not sure how long the upload takes, but it's surely < 500ms. By the time I
save and alt+tab refresh my browser the content is there already.

We're using bunny.net and completely moved away from cloudflare. This website
is just a template on the bunny.net equivalent of workers, and this plan just
gets uploaded to their object storage. On request, the template gets filled in
from object storage, so the way we update this plan is actually rather simple.

  1. Edit .plan
  2. Save
  3. Watcher picks up the change
  4. Watcher uploads to bunny.net object storage
  5. Future requests to the worker with my site automatically picks up
     my changes

Lovely!

[0]: https://git.sr.ht/~gary_moore/toe

---

Blog Publishing Platform
------------------------

So I have an idea for this, something similar to what I've done already for
publishing to my gemlog on the gemini protocol. That is, why not just send the
blog post to myself as a signed email? Already got a decent bit of the code,
just need to flesh out HTML templating vs the much simpler gem format.

That's what I think I'll do eventually in order to have a platform for the
below article series. There's once important deviation compared to how I did it
before, though. Instead of the silly stuff with the git repo and SourceHut
build step as before, I'll just push to a bucket, and do something with a
bunny.net script.

---

"Low-Level" JS article series idea
----------------------------------

So this is something that's been floating about in my head for a while now.
There's some interesting performance topics that I haven't really seen covered
much with regards to JavaScript, and I suppose that's manual memory management
with typed arrays.

There's some specific probably niche topics here:

  1. Packing low cardinality information into bitfields
  2. Discussion on deopt pitfalls wrt polymorphic func parameters
  3. SIMD within a register, specifically in u32s
  4. Buffer backed string interning for cache locality
  5. Eliminating GC churn with fixed slots and freelists

And more topics as I think of them I suppose. Before doing a wee series on JS
perf, I suppose I should build out some way to publish blogs on my personal
site. I already publish to the gemini protocol because the LLM crawlers don't
go looking there, but I've got this .plan thing here now, and I think I can
borrow the kqueue stuff for a really low friction CMS-ish thing.