“”Wow””

There’s a good article today in kode24 called “I can’t be bothered to hear about that vibe coded hobby project of yours”:

But as with all AI-generated content, the problem is that people won’t bother spending time on something you didn’t bother spending time on yourself.

[…]

Then, of course, there are a few instances where you simply cannot find what you need. That is why some argue that the true value of “vibbe-coding” lies in creating your own tools for your own personal use. And they might well be right.

Because the beauty of it is that you don’t have to tell anyone else about them.

So true, so true — I agree 100%.

Anyway, a couple decades ago, probably while falling asleep, I imagined a silly FFT display of the music playing. You know — one of those things that move along with the beat and the frequencies like all the Winamp plugins had.

I’m not sure quite why I had that idea, because I’m against having displays with lots of action in general — I hate distractions.

But I had an idea for how it would look, and I thought it might look, for want of a better word, “cool”.

So I started working on it, and then I realised that 1) I know nothing about the ALSA sound system, and 2) I know little about Fourier and maths in general, and 5) I know very little about X programming.

So I was the person least suited to doing this in the world, and the project stalled pretty quickly.

This is my excellent drawing to illustrate what I wanted it to look like — I was thinking about a circle with red lines, but then I remembered that I wanted the lines to be more radial.

After the previous success with Just Have Claude Do It yesterday, I thought of just asking it to do this one, too, and half an hour later…

And with some tweaking:

I guess with stupid hobby projects like this you used to be able to say “well, this may be stupid, but at least I made it! And now I know how to do X programming!”

Well, this project may be stupid, but I didn’t make it, and I’m even stupider than when I started it, I guess. So that’s a major difference between doing silly programming yourself and outsourcing it to an LLM.

Still… the results are amusing, I think? And I would not actually have done this myself.

You can find the results on Microsoft Github, but I guess you can just ask Claude to make you one yourself — that’s probably easier than using this code…

Let’s Split (Vinyl)

Ever since the late 90s, I’ve sampled vinyl records (and ripped CDs) before listening to them — because I’m bone lazy, and I don’t like running back and forth to the stereo every twenty minutes to flip the record over.

There’s a lot of software and APIs in this area to allow you to automate a lot of this. There was the CD CDDB database of CD data that you could query to rename tracks after ripping them, for instance.

But one thing that didn’t exist back then was good software to split sampled vinyl albums into tracks. So I wrote a programme myself around 1997, and I’ve been using it ever since, and after splitting I use the Discogs API to rename tracks automatically.

(I did some research about ten years ago into whether something better had shown up, and the answer seemed to be “yes” — but deep inside software that wanted to handle all this stuff, not just “split it already and leave me alone”.)

The vsplit programme I wrote is pretty simple: It takes as input a “noise floor” level, and then splits when you have a noise floor that’s been low enough for long enough. (The noise floor is constant across records, I find, but varies between record players.)

This handles, say — 80% of albums, I’m guesstimating? And the rest I’ve used an Emacs mode for graphically (but manually) splitting the albums.

But for a decade and a half I’ve had this idea: I know how many tracks there are on an album. So surely one could write some kind of “adaptive algorithm” to use this extra information to inform the splitting? That is, if we’ve found 15 split points using the first algo, and we know that there are only 5 tracks, then there have to be some tracks that have pretty silent bits embedded, and we should append those bits to each other.

Or something.

A decade ago I started writing something along those lines, but I just had to give up: It was too much back and forth with testing and retesting — once I had gotten something to work on one album, it broke on a different album, and then I had to tediously listen to what’s up with that, and and and I just threw my hands up and left well enough alone.

But now we have LLMs:

And after uploading several albums [REMEMBER TO EDIT THIS OUT BEFORE POSTING BECAUSE IT SOUNDS REALLY ILLEGAL] to it — some that have straightforward silent bits between tracks and some that are more free-flowing:

And finally:

I’ve now got something that seems to work, like, 99% of the time! This final album I gave it was a real brain teaser — it has one track that doesn’t really have a pause between two tracks, so you just have to make the algo pick a random point.

Like, I’m impressed — I wasn’t sure whether it was going to get there or not, but:

And everything seems like it’s working A-OK.

vsplit.c went from 300 lines to 750 lines, which was less than I expected. 🫠

I’m really not one of those RAH RAH AI AI people (really not! I swear!), but this is just such a perfect example of LLMs doing programming work that (demonstrably!) I’m either not able to do or just can’t be bothered to do. Probably the latter, but there’s not that much difference in practice, now is there?

I’ve put the resulting thing on Microsoft Github. You’re welcome.

How much userspace does one need for a Linux machine anyway?

A joking comment on my post about Emacs being pretty small these days said something like “130MB just to show a PNG”… which made me wonder what the userland on this Raspberry Pi Zero was like, anyway.

Above you see a list sorted by the resident size of the processes.

The biggest thing, at 29MB, is systemd-journal — which isn’t really necessary on a device like this, but nice to have.

Next up is exim4 at 17MB, which is totally unnecessary — this system is not going to be receiving mail (or even sending it).

NetworkManager (at 10MB) sounds necessary, but isn’t — one can just plop some stuff down in /etc/network/interfaces instead.

Then we have three instances of sshd (at 10MB and down), which is because I’m ssh‘d in — there’s normally just two otherwise? But necessary.

Then there’s stuff that sounds necessary, but ModemManager (!) at 4MB certainly isn’t, and I don’t think polkitd is either (4MB).

bluetoothd (3MB) is not necessary, and neither is avahid (two processes, 4MB altogether).

And then the rest (like d are the processes that update the screen and stuff) look necessary.

But that’s (+ 29 17 10 4 4 3 4) => 71MB of stuff that does not need to be running, I guess.

Which is more than the size of the Emacs process, anyway.

(There are obviously super duper optimised Linux images that run on actually constrained devices, but I was just curious as to how much a normal Debian image could be shaved down.)

Not that I’m going to be pruning processes — there’s plenty of space to go around, but it just shows how far off my initial supposition that the device was too limited to run Emacs locally was.

Herp derp I eat paste

A year and a half ago I made a kitchen clock, which has worked well (except that I had to swap out the screen which broke mysteriously).

But yesterday I was having some work done here, so I had to remove one of the wifi access points here, and… the clock stopped working. *gasp* Yes, because I had in my infinite wisdom decided that I would generate the clock face on a different machine, because the clock is a Raspberry Pi Zero 2 W, and I just assumed that it didn’t have enough memory to run Emacs (which I am, being a totally rational person, using to generate the SVG that’s being displayed).

So it’s a Rube Goldberguesque setup of having the image being generated on the main server, and then scp‘d over once a minute, and then being displayed on the console here in the kitchen.

But the wifi outage made me wonder — is it true that the machine doesn’t have enough memory to do it all on device?

So it’s got 416MB of useful memory, and while just running and doing nothing special, it’s using 129MB of that.

What happens if I load an Emacs with all the SVG libraries and stuff and generate the image?

It’s using 186MB — so the Emacs occupies about 50MB max.

*sigh*

It’s so easy to think of Emacs as this “big thing”, but everything has gotten so much bigger around it that it doesn’t matter at all any more.

So now I’ve changed the code to run on-device, so the only thing that goes AWOL if the wifi goes missing is updated temperatures.