Raphi Rambles

Hello World

2025-05-16T11:30:00+02:00

#include <stdio.h>

int main(int argc, char *argv[]) {
    printf("%s\n", (char[]){ 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33 });
}

So here we go.

After years of putting it off, I finally bit the bullet and bought a personal domain name. My main intention was to get out of gmail and avoid trapping myself with whoever I end up going with for hosting my mail.

Now, as long as that domain is paid for, why not build a website ?

As a long time critic of social media and advocate for re-decentralizing the web, I figure it's time to put my money where my mouth is. Whether or not I end up using this space for anything interesting remains to be seen, but let's take this one step at a time, shall we ?

I had heard of Pelican for a while already and decided to give it a try. The new kid on the block, Hugo, seems to be more popular these days, and maybe I'll give it a try, but being used to python I figured it would make things easier.¹

A couple of days hacking up a theme (CSS and I are not the best of friends...) and here we are. This won't win any beauty contest, but I like the minimalist vibe of it all so far.

So what's this thing gonna be ?

I'm not sure yet. I'm feeling an itch to start writing again and figure I'll just get started on that and see where it goes.

The question of who I'm writing for can't really be avoided, though. No sense in writing anything if you're not addressing someone. And while the void of the interwebs is good enough for now, at some point I'll have to decide on a language to use (an actual human language, that is).

I've always loved English and tend to naturally use it whenever it's surrounding me (like when I'm coding or reading tech documentation, which is what I've been doing for the last 2 days), so obviously it didn't even occur to me to translate the theme I was putting it together and now using another language would only feel weird.

But I do know that if this blog ever attracts some readers, those will almost certainly be french people², at least in the begining.

So what do I do ? Switch the whole site to french ? Aim for an international audience right from the begining ? Internationalizing the site should be easy enough, but do I feel like translating everything I post on here ? Hell, who's really gonna care if I just switch language randomly, consistency be damned.

As with about everything else, I guess the answer is "who knows, let's just see what happens".

Enough rambling for now. Time to go mess with Nginx and get this show started.

See ya, interwebs!

I am somewhat interested in Go, kind of in a hacking mood these days and I do have some time on my hands, so we'll see what happens... ↩
And no one hates English more than a frenchie. It's in our genes. Which is probably why I like this language so much. ↩

Tooltip Odissey

2025-05-19T20:00:00+02:00

If asked to name a blogger whose work I've enjoyed, the first one that would pop into my head would the the great (and sadly, late) Shamus Young. If you're into geeky stuff like video games, programming popularization and obsessive nitpicking about storytelling, then I can't recommend this blog enough.

That guy was a huge influence on the way I still think about a lot of stuff, and the itch to start writing myself might not have gotten to me if not for him.

But the funny thing is, I didn't think of him (at least not consciously) when I started building this website. That only came when, catching up on the markdown syntax, I stumbled upon the footnotes feature.

Open the link above and skim a few posts. Look for the citation links¹ peperred across the pages and click on one of them.

It's not much, but it's one of the small touches that gave this blog its vibe. And to this day, I always have a thought for the ol' twentysided whenever I see one of those (and also get slightly annoyed when sites stick to the default browser behaviour.² Maybe it's just a habit I picked up, but I find reading the footnote in place much more convenient).

So since I had way more urgent things to do, I decided to go ahead and spend an afternoon hacking on my own take on the idea.

I haven't looked into his implementation. I might check it out later, but I figured it would be funnier to come up with my own version, especially on a trivial thing like this.

The first thing I realized is that since the footnotes' markup is generated from the article's markdown, I can't easily fool around with it (I guess it's possible, but this is going to require writing a pelican plugin, which is not what I'm interested in at the moment. Also, I'm not sure how straightforward it is to alter only part of the generated output.³ Again, my goal here is just to hack together a small feature, not to become a markdown expert).

So, since I can't directly alter the page's HTML, I guess I'll have to use Javacript.⁴

Simpler is always better...

My first thought was pretty elementary. Grab all the footnotes gathered at the bottom of the article, clone their children, and add the clones right beside the link that points to them. The actual tooltip hide/show logic shall be handled via CSS.

I got started doing that, and along the way realized that I probably could avoid messing with the DOM by simply extracting the footnote's text and sticking it on the link as an attribute. If CSS could then access this attribute, that would vastly reduce the amount of JS code. I found a codepen online that did just that, pasted it in my template, and lo and behold, it worked!

Here's the script I ended up with:

function SYToolFoot() {
    // Loop over the footnote links
    document.querySelectorAll('a.footnote-ref').forEach(function(footlink) {
        const footnoteId = footlink.href.split('#')[1];
        // Grab the corresponding footnote
        const footnote = document.getElementById(footnoteId);
        // And stick its text in a custom attriibute
        footlink.setAttribute('data-tooltip', footnote.textContent);
    });
}

Now ain't that a beauty!¹

Barely 5 lines of js and it looks and feels great. Since the actual showing and hiding is handled via CSS (that's where the real magic happens, and I shamelessly stole that part), I had to trigger it on mouseover instead of requiring a click. But honestly, it feels sleeker that way.

So good job, well done, now let's go grab a beer and reflect on the virtues of simplicity and how much of a better place the world would be if only people would wise up and join us in the perpetual battle against complexity. Right ?

Stock, sappy corporate pictures as illustrations. Another Shamus hallmark. In fact, I recognized a few photos he used while searching for this one. Source: pexels.com

... Except when it's not.

Hmm. The default behaviour (click & scroll to the bottom) is preserved.⁵ That's great, as it means the basic functionality will be unafected if javascript is disabled. But it's also confusing. Someone might click on the link out of habit (that's what links are for, right ?) and get confused by the glimpse of the tooltip appearing as the page starts scrolling down.

That's pretty much what Wikipedia does, and while it works well on their page, here it just feels wrong and annoying. Feels like we need to tune the numbers just right on the animation delays and whatnot, which sounds like the polar opposite of fun.

Well. The intent behind these tooltips is mostly to add some jokes or slight digressions. I don't expect to write the kind of stuff that warrants a more disciplined approach to citations or bibliography. So I could just hide the bottom list and only keep the funny tooltips. Also, I said earlier that I wasn't a fan of the usual, back and forth behaviour. So let's just get rid of the list, and problem solved, right ? We end up with just what Shamus had, only slightly nicer as I don't have to click the mouse anymore to see the silly bits.

So that's what I did. Clean up the code, slap a quick preventDefault() on the click event, and we're done. Nice and quick, still felt pretty good about it all.

That's about when I decided to document this whole process and turn this thing into an article. Obviously, I started playing with the tooltips immediately. And as I got to the second or third one I tried to include a link and...

Wait.

This² is what it looked like. Go ahead, try and click the link.

This is hell, right ? And the worst part is, even if you could get to the damn thing, it wouldn't work anyway.

I'm copying the footnote's text into an element attribute. All the actual html markup is stripped out. You can't even see the link, because, well, there is no link.

Now, I could just accept this limitation and keep things as they are. Art lives on constraint and all that. And honestly, as long as you stick to plain text, the quick and dirty solution is fine.⁶ But now that I thought of stuffing links in those tooltips, I just can't let go of the idea. Without them, the whole feature is just a cute trick. But with them, it becomes actually useful, and can be a great way to add some precisions without cluttering the main point.

Also, I realize only now than the hover event won't be available on mobile, which sucks, I guess. If you were wondering why my exemples didn't work, now you know why.

Oh well, it's not like my initial approach was hugely complicated anyway. So let's get to it.

Lessons learned (?)

About 30 minutes later I got the DOM shuffling version working. The first pass was about 30 lines of pretty straightforward code. It's barely more complex than what I had before and it does what I want. Problem solved, for real this time.

So, is there even a point to this whole thing, or did I just decide to waste your time like I wasted mine ?

This story hopefully illustrates a few classic blunders. Beginners' mistakes, really, but those things have a tendency to keep happening even when you'd like to think you know better.

Diving in a rabbit hole

When I found out I couldn't hover the tooltip themselves, my first impulse was to double down. Keep things as they are and add some logic to handle the corner cases. Which often leads to discovering more corner cases.

Sometimes there's just no way around it. But it always pays to stop as soon as you notice this pattern and think about whether or not the first steps you took were heading in the right direction.

I'm not a frontend guy. I'm bad at UI and I know it. I don't think this particular case would have gotten too bad, but that's just an assumption. The truth is that I haven't done a lot of integration work before, and most of it relied on third party libraries to handle that kind of things. Here in vanilla land, I don't have a good hunch to try and predict potential pitfalls before falling into them. I can't know how long the path is before I walk it.

Luckily I saw that one coming before embarking on a wild goose chase, but that's only because I've been burned before.⁷

Simple != Easy

I'm more and more convinced of the importance of the KISS principle, and I try to apply it whenever I can, even though I still fail to resist the urge of overdoing things pretty often.⁸ But I think my mistake here was to confuse simple and easy.

Sure, manipulating the DOM is a bit more cumbersome than simply setting an attribute. I'll have to catch up on the API, read some docs, maybe re-learn a few javascript quirks. But is it that much more complex than the naive approach ? Not really. And since the elements are copied as is, unforeseen situations where they stop behaving like they should are much less likely. No special UI shenanigans to worry about. The code is dumb and only cares about the one thing it's supposed to do. This is always better than trying to be clever.

By trying to cut corners, I was giving up all of this and would have quickly ended up with a ball of mud, ie more complexity.

I'm sure someone more used to building interfaces would have spotted the problem right away. That's what domain experience is all about. But sadly, experience doesn't always transfer well across domains, even when those look similar. Whenever you try your hand at something you're not that familiar with, chances are you'll hit that kind of wall.⁹

Usable != Sexy

I'm no designer, but I've been using the web long enough to develop an eye for stupid UI trends, and find myself ranting about those more and more.¹⁰ It usually boils down to something along the lines of:

"Congratulations for being such a shiny turd. Too bad you're still turd."

And yet, I still fell for the sexyness of on-hover tooltips.

There's nothing wrong with some cheap flash now and then. But doing it right is extra work, the kind of which I can only enjoy for so long before going postal and sending death threats to Brendan Eich and Håkon Wium Lie.

And half-assing it is even worse. Trigger on hover feels nicer at first thougth (why waste two mouse clicks just to read some side comments ?), but it comes with a bunch of downsides. My naive implementation⁴ forces you to keep your mouse in just the right spot to keep reading the damn thing. If you Alt-Tab to quickly check on something else and come back, the tooltip animation plays again, which feels like some kid waving for attention. And that's assuming you haven't moved the mouse in the meantime (if you did, then the tooltip is gone, so you have to find it back and re-hover it if you weren't done reading it). They're also prone to trigger when you're just reaching for something else. What felt sleek and modern on first impression ends up being a royal pain in the butt.

Thinking back on the Wikipedia example, I realize how good of a job they did. Their tooltips are timed just right and get out of the way seamlessly (I don't remember ever getting pissed at them. And I get pissed at crappy widgets on a daily basis). And their perfect positioning lets you interact with their contents without having to think about it. The only flaw I can find is the Alt-Tab one.

"Sexy" might not be the first word that comes to mind when thinking about Wikipedia's UI, but the best interfaces are the ones you don't even notice. Whoever did that knew what he was doing.¹¹

Trying to replicate it could be a worhtwhile learning project. Could even be fun. But that would still take time and require me to care more that I currently can (I already spent way too much time just trying to make the stupid popups look not-quite-atrocious. Also, this was supposed to be a quick hack, remember ? It's been 3 days already. Granted, most of that was spent writing this article, but still).

I go back to Shamus' site and fiddle with his take on tooltips. His clunky, archaic take that requires pressing buttons and doesn't even try to be fancy. And I realize how right he got it.

Context is everything. This isn't wikipedia. Their implementation might be pretty cool, but it's overkill for this site. But I still want to focus on writing, and going for flash without putting in the work to do it right would just be distracting.

Sometimes the dumb and boring way is the best one.¹²

Are we done yet ?

I swear I didn't plan for this. This started as a simple excuse to just write something and justify getting this blog online. And as the brain got rolling it kept getting caught on details and tidbits it found interesting.

This whole tooltip thing is definitely not worth so many words by itself. No one is gonna learn anything of technical value here. But I hope this report helps demonstrate how simplicity is a tricky thing.

Even the most trivial tasks desserve some attention put into them, and following the trains of thought it produces can lead to some interesting insights. This ain't no grand revelation, but my understanding of what good UI truly is (and my conviction that it's not about making stuff bright and shiny) just grew a teeny little bit better.

I hope the bad Shamus Young impersonation wasn't too cringy. Some of it was intentional and meant as a small tip of the hat, but I didn't plan to rip him off so much. Guess I wasn't kidding when I said he was such an influence on me. Again, if you don't know his blog, go and give it a glance. If you're interested in coding (even from a distance, those posts are meant for non-tech people), I recommend his programming series. If you're more into story and worldbuilding analysis, then read one of his videogame retrospectives. Oh, and if you're a fan of DnD and/or the lord of the rings, then you can't miss his DM of the Rings comics series (they're currently being re-posted in higher quality by his family, if you'd rather follow along weekly than binge-read it all) (Oh, and apparently there's a french version too. Nice!).

Whatever your jam is, this site desserves some traffic. It's one of those places that made the web such a magical place.

Allright, I'm done. See ya interwebs!⁵

Tadaa! Wait... Why does *this* tooltip look different ?

Some link to the best thing you'll ever see

Filler content

Here it is again, just as a reminder. Feel free to experiment with it and marvel at how cursed it really is.

One more for the road. I promise i'll try not to overuse those so much in the future. So long!

They look kinda like this one ↩
Check out my first article if you're not sure what said default behaviour is. ↩
Did someone say regex ? ↩
And here goes the pride and joy of owning a 100% js free website... Oh well. It was good while it lasted. ↩
Not on this page, though. As you probably guessed already, I'm reimplementing what I had to demonstrate how it worked. I'm not going to redo everything just as it was, though. Sorry if this makes things confusing. ↩
Although the version I posted and kept for this article is slightly naive. You need to clean up the textContent to remove the footnote's backlink and the extraneaous white space that messes up the formatting. No big deal, but thought I'd mention it in case someone wants to use the posted code (Pro-Tip: use a regex, it'll be cleaner than chaining trim calls as I did. Don't worry. It's not HTML anymore). ↩
and likely will again ↩
As soon as I got the cleaner script working, I went ahead and added a bunch of options to customize the behaviour, knowing full well this code is probably never gonna leave this site. Sigh. ↩
Keep that in mind next time you feel like poking fun at some job because it looks easy. ↩
Hell, I'm even thinking about a dedicated category for those rants. For now, I'll just link to thisfor an appetizer. ↩
I didn't even mention the settings link that lets you tune the whole behaviour to your liking. Man, what a class act. ↩
This article would have been a lot shorter if I had just gone with my first idea. I'm not sure whether this would have been a good or a bad thing. ↩

So You Wanna Get Into Bluegrass Lead Guitar

2025-05-26T13:00:00+02:00

Bluegrass music can get pretty flashy, and while you don't need to aim for those levels of virtuosity, this can make getting into lead playing (an already scary task in and of itself) all the more intimidating. And as often, the most difficult thing can be knowing where to begin.

Well, here's a few suggestions on how to get started. We won't dive too much into anything specific and rather point out some techniques and general concepts that may not be too obvious and should provide a good introduction to the style while remaining useful as you get further.

Whether you're still afraid of the very idea of playing melodies or you're already accomplished in other genres (possibly coming from the electric guitar), I hope those tips will get you on the right track.

Back to basics

You might have discovered Bluegrass via current players like Molly Tuttle or Billy Strings. Or maybe you fell in love with Tony Rice. That's great, and there's a lot to learn from them all. But I would advise starting with earlier stuff. Much, much earlier.

Not only because it will give you a better understanding of the genre and how it evolved over time (although it will defnitely do that), but mostly because the earlier you go, the simpler things get.

Art is built on what came before. And as each generation expands on the tradition, the fundational set of techniques and vocabulary that define the form gets that much thicker. Just like learning how to walk before you run, you'll have a much easier time figuring out what the modern greats are doing if you understand what influenced them. Trust me, Billy Strings' playing seems a lot less crazy when you're already familiar with Doc Watson.¹

You don't have to spend all your time on the older stuff if that's not quite your jam. But if you struggle with something, figuring out where that thing comes from and working on the earlier and likely simpler version can only help.

This article goes into much more depth on this idea of chronological learning and is full of great references. If you do like the old-fashioned, pre-actual-bluegrass sound, then simply listening to the names listed there can keep you occupied for quite a while =)

Carter Style

As far as country lead guitar in general is concerned, you can't really go much further back than Maybelle Carter. Sometimes called the "carter scratch", the style she developped is often cited as the first use of guitar as a lead instrument.²

She played with a thumb pick, but the technique is easy to emulate with a straight one. The basic idea is to play a stripped down version of the melody on the bass strings and to interject a light chord strum or two at every pause to keep the rhythm going.

Notice how little her left hand moves ? That's because most of the melody notes are part of the underlying chord, which mean you don't have to reach for them. Fretting the passing notes while keeping the chord ringing can feel tricky in the begining. Just take it slow and don't worry if it sounds mechanical at first. Focus on hitting the right strings and give your hands some time to get in sync.

Once you get the basics down, go ahead and explore what you have. Pick a few simple vocal tunes and try and figure out their melody. Again, most of it will fall on frets you're already holding, so this gives you a nice point of reference to guide your ears. Try to stick to the keys of C or G, as those positions lend themselves ideally to this technique.

Once you get into playing more single note lines, having spent some time with this style will help a lot, as you'll be used to visualising the chord shapes and how they relate to the scale or melody you're playing. This will make identifying your chord tones and learning how to outline the harmony much easier.

And one last bonus: if you decide to get into crosspicking³ later on, the overall concept is pretty much the same, so you'll be able to simply focus on refining the right hand without having to think about the left one.

Don't think of it as just a stepping stone to the fancier stuff, though. Having this tool on your belt should remain pretty useful, especially when you're playing by yourself or in a small ensemble. Even in its most basic form, some songs won't need anything more. And if you do want to dress it up, adding just a few slurs and some syncopation can go a pretty long way. Norman Blake is a master at this.

For a more detailed breakdown of the technique, here's a pretty good two parts video series dedicated to it.

Brush up on those major scales

Like just about any american genre, you'll find some blues in Bluegrass.⁴ And harmonically, the defining aspect of the blues is an ambivalence between major and minor tonalities. This is why beginers are often advised to start with the minor pentatonic scale, as it will sound just fine over actual minor tunes, and clash in a really nice way in situations where it's not the theoretically "proper" scale to use.

While this works great in the rock world, historically country music tends to be a lot more subtle about this, so I would recommend starting with the major pentatonic. Most melodies will fall within that scale, and learning to follow the changes should be much easier.

Learning how to use this scale will probably take a little while. There are plenty of ressources across the web on this topic, though, so I'll let you explore on your own.

Get dirty

Sticking to major doesn't mean you should entirely avoid the blue notes⁵, though. As I said above, the blues is part of Bluegrass. Once you get those major scales under your fingers, single out the third note from one of them and lower it by a half-step (ie, down one fret). Play it over some backing track.

Sounds pretty nasty by itself, right ? Well, now go back to your regular third and listen as the tension resolves.

This is the blues. Whether or not you understand the theory behind it, this is the one harmonic concept you'll have to get in your ears if you ever want to sound like you know what you're doing.

There are millions of ways to handle that minor to major move. The simplest one is to just throw that dirty third anywhere you feel and simply resolve it immediately, or to use it as a passing tone. Throw in a hammer-on for effect. In fact, if you know your basic G run, you're already doing it:

e ------------------
B ------------------
G ---------------0--
D ----------0-2-----
A ---0-1^2----------
E -3----------------
       ^ Here it is!

Another cool trick is to find spots where the two thirds lie on adjacent strings and rock back and forth between them. In C, this can get you this classic Doc lick:

   v Nice!
e ---0---0--------------------
G -4---4---1-----1------------
B -----------2-0---2-0--------
D ---------------------1^0----
A -------------------------3--
E ----------------------------
                       ^ Another dirty third, this time resolving to the second.

Add a seventh to the mix, and things can get pretty nasty =)

You may want to apply some restraint depending on the mood you're going for (some songs really don't like that level of tension), but when it's appropriate, feel free to go crazy. You'll hear that motif over and over in many classic recordings. Train your ears to spot it, it's pretty distinctive so it shouldn't take too long and will help your transcribing quite a bit.

That's not how Tony did it

For a long time, Country musicians remained pretty shy about those dissonances, and you'll find them only sparingly in the earlier recordings. But starting around the 60's, guitarists started to embrace basing their solos around the minor pentatonic, like a bluesman would.

Tony Rice is the one who brought this approach to Bluegrass, and it sounds great. If you want to get mean and crank up the attitude, that's the way to go.

It won't work on every tune, though, and that may just be me, but I find it trickier to get right, especially if you don't want to sound too much like a Tony wannabe.⁶

Now if you like that sound, by all means go for it. But I do think that learning to think in major and jazz it up as needed will leave you wth a better understanding of it all. It's easier to start from the harmonically "correct" approach and spot where and how you can stray from the rules, than figuring out how to straighten things up after having broken them.

The mighty Rest Stroke

Back to technique. That one, while fairly common, doesn't seem to be mentionned as often as I think it should.

It's deceptively simple: as you push your pick through one string, make sure it lands and comes to "rest" against the one below it.

Should look like this.
Watch the original video for a fuller demonstration.

It's trickier than it looks and tends to mess with your timing, so pay extra attention to that. Also, be careful not to apply too much force, as it can easily overwhelm your guitar's top and get it to buzz.

Most people use it only sparingly, and I would advise doing the same, at least until you get really confident with it. But whenever you need a note to really pop, the rest stroke is the way to go.

The one obvious place for it is at the end of a G run. Try it with and without resting and tell me which one sounds right.

It's also a great way to emphasise your bass runs. Or your regular bass notes, if you find yourself playing without a bass player and need to fill in that role.

Playing a slow blues and wanting to get a real rootsy and aggressive tone ? Ditch the alternate picking and use rest strokes on every note.

This technique was developed to get the volume needed to be heard in purely accoustic setting, and is an essential component of Gipsy Jazz right hand technique.⁷ I assume it faded out of fashion as amplification solved the volume issue, but I would still consider it an essential skill for any accoustic genre, plugged in or not.

(Some old guys still played that way on electric, and it's a pretty cool tone too.)

Again, it's not that easy to execute cleanly, and it can be fairly hard to incorporate into whatever else you're doing (I'm still struggling with the bass player impersonation exemple I gave above). Also, it's definitely not appropriate in all situations. You'll need to develop a feel for when and when not to use it.

The nice thing is that you don't have to try and master it right away. As far as the right hand goes, there's already plenty to keep it busy with regular alternate picking.⁸ Just be aware that it's available and work out how to fit it in when needed. Even if you only ever use it on G runs, that will stll make a difference.

Thicken up

If you're used to thinner picks, then I'd strongly advise moving up a gauge or two. You don't have to go for the thickest thing you can get, but I would avoid anything under 1 millimetter. I personally don't care too much about the actual thickness anymore, but focus on having as little flex as possible (and ideally, none at all).

This will give you much better control and precision, which will become more and more crucial as the tempo speeds up. Using something meatier will also make it much easier to pull some tone out of your instrument.

It's probably gonna sound harsh at first. The fix is to loosen up your wrist and lighten your grip. I know this is (a lot) easier said than done, but being forced to work on eliminating tension can only benefit you in the long run, even if you decide to go back to something thinner.

Of course, this is not a hard rule that you have to follow. Use whatever suits you best. But do give heavier gauges a fair try before deciding, and don't rule them out simply because they feel harder to use.

Get Rhythm

This should probably be at the top of the list, but do not neglect rhythm. You can play the coolest line ever and execute it perfectly, it's gonna fall flat if your timing is even slightly off. So dust off that metronome and make sure everything's tight.

Pay attention to which notes get accented, and by how much. Keep that pulse going. Listeners should be able to still feel the groove even if you're playing by yourself. Fiddle players tend to be prety good at this, because the whole style evolved from dance music, and it wasn't uncommon for old time fiddlers to be the only musician at the ball. Give them a listen and try to emulate that feel.

Keep working on playing backup, too. Don't treat it as what you do between the fun parts⁹. Even if you stick to the simple boom-chuck, pay attention to your tone and dynamics, be mindful of how much space you're taking, and always ask yourself how you can best serve the song and support whoever is in the lead.

Keep it simple

Bluegrass is a simple genre. Technically challenging, sure, but harmonically there's usually not a whole lot going on. It can be tempting to try and enrich those plain chord progressions, and sometimes it can make for a nice ear twister. But it has to be done tastefully, so as often, better to err on the side of caution.

Likewise, don't feel like you have to aim for a deluge of sixteenth notes. Stick to the melody. Repeat yourself. Focus on sounding good, and try to apply the things you already know in a clever way instead of constantly reaching for new licks. You don't even have to improvise. Write out your solos in advance. This will give you time to fool around and think about what you want to do. If the end result sounds halfway decent, nobody is gonna care that it didn't came up on the spot.

Don't be afraid of sounding cliché. Clichés are the backbone of any genre. Embrace them, study them, try to understand why they became clichés in the first place. Learn the language first, and only then figure out what you want to say with it.

Allright, that's all I have for now. I hope that wasn't too confusing. My goal here was to suggest an easier and gentler way to get started and to try and demistify the process, but that's hard to do without knowing what a potential reader may or may not already know.

I guess my final advice is to take it easy. Don't rush, play around and let things develop as you go. Don't get too bogged down in what you should or should not do. Make mistakes, have fun, keep picking and enjoy the ride!

This is not a dis at Billy. I love how he proudly wears that influence on his sleeve and soaks it with attitude. And it illustrates my point perfectly: He may break conventions, but there's no way you could accuse him of not knowing his classics. ↩
Which is, as always when the word "first" is involved, probably bullshit. But the point is that it had a huge impact and is a great place to start. ↩
in which you arpegiate the chords instead of strumming them. I wouldn't go there if your right hand isn't already pretty solid. ↩
And no, the name "Bluegrass" has nothing to do with that fact. Also, French people: there's no "s" in there. Please stop calling it BlueZgrass. It's embarassing. ↩
Note the plural. I could write a whole rant about how there's not one single blue note, and why the one that's usually gets that name isn't even the most interesting one. ↩
Nothing wrong with stealing from Tony. He's a stapple of the genre, after all. But such a distinctive style can get tiresome when you hear it imitated too often. ↩
Whether or not you enjoy Gipsy Jazz, you can't argue that those guys don't know how to get crazy volume out of an accoustic guitar. ↩
If you're still struggling with it, then forget about rest strokes and focus on that. Straight ups and downs is what you want 99% of the time. Don't get fancy until you have the basics down cold. ↩
Once I got into the right mindset, I found out that I actually tended to enjoy playing rhythm more and more. I almost regret taking up singing, as I wish I could spend more time focusing on just backup. ↩

Let's Build a Thing

2025-06-02T21:20:00+02:00

Getting this blog started reminded me about RSS feeds.

I started subscribing to a few, and at some point thought it would be cool to share the stuff I follow on here. You know, try and make the web an actual web again.

I'm sure there's already a bunch of tools to do just that, but one of the selling points of RSS is that it's simple. So let's build this thing ourselves and have some fun, shall we ?

I haven't written a single line yet, and just started thinking about how to proceed. So that's what today's rambling is gonna be about. Maybe hacking on it will give me more article ideas, but I suspect it won't. There's not a lot to say about parsing some dumb XML.

What's this RSS thing ?

If you don't know what RSS is, it's really not hard to understand:

A website owner sets up a page that's really nothing more than a list of all published articles, formatted in a markup language that dumb computers can make sense of. If he's feeling fancy, he might setup several of those feeds for different categories or comments threads. Have a look at this site's feed. I know It's ugly, but figuring out what this mess is about really isn't rocket science, is it ?
People interested in what this guy has to say copy the feed's link into some RSS reader application. That program's job is to simply go and check whatever it's subscribed to at regular intervals (you can configure it to update once a day, or every 10 minutes, or whatever suits you). Optionally trigger a desktop notification when something gets added to one of the lists, and you're done.

That's it. You can add some bells and whistles if you feel like it, but the basics are that simple. Automating the feed's generation is easy to begin with, and any decent web tool will probably handle it for you anyway. Implementing a basic reader is a fun beginner's project.¹

This is much cleaner than relying on some social media platform to keep you up to date via push notifications (which they'll gladly do, as it is a wonderful way to build up your addiction).

While the end result might look pretty similar, with RSS, all that happens is that your machine periodically goes and checks whatever people have been doing. Technically, it's exactly the same than manually going to each individual site to see if they posted anything new. It's just automated, and handled by a program you can configure or uninstall if you decide you don't like it. You remain in control. Since you're getting the data straight from the source, there's no need to trust anyone but the site you're checking out. No one has to stand in the way and monitor your activity or fill your feed with targeted trash.

The protocol's simplicity also means that anyone who cares can implement his own tools to handle it. This doesn't prevent bad actors to try and get people to use their own, shittier tools, but at least competing with them is technically much easier than if we were dealing with operating systems or web browsers.

RSS is old tech. It's not flashy, but it does its job and has been around for a long time.² The tech giants would love to kill it, but no one's stopping you from using it again. Keeping up to date with whatever's happening is the main reason I hear from people to still use social media. Turns out we never needed them for that.

Technical choices

So, before diving in, let's take a minute and figure out what we're trying to do.

This site is statically generated, which is at odds with the fundamentally dynamic content I'll be dealing with. The page listing the feeds needs to update on its own, so I need to be able to periodically regenerate it. The most straightforward way to do that is to simply set up a cron job.

I don't really see a reason to tie the page generation to pelican or some other specific framework. A standalone script seems like the most flexible solution. If I keep the link gathering logic and the html production separate, then the API should be easier to adapt for different situations (like skipping the html output and simply passing the list to a Django template). I'll keep that in mind while hacking up the first draft.

I'm tempted to fool around with some new language, but the one I can rely on being installed on just about any server is Python.³ Since it's just a simple script, it won't have to interface with anything, so there's no need to deal with WSGI or anything like that for deployment. Seems like the perfect tool for the job.

I'll need to store the urls I'm watching somewhere. And maybe some other optional things. This means having a config file. For the sake of KISS, let's dump all that in a simple python file, Django style.

Now for the presentation. I want to organize the feeds in multiple categories. I'm picturing it as a grid of boxes each containing the links for one cateogry. Should be simple enough.

For some reason I want to play with some htmx but is that even needed ? The whole page is gonna get rebuilt everytime it needs to update, so there's really no use for it. I dunno. Maybe I'll find a way to shoehorn it in. We'll see when we get there.

If I want to get fancy, maybe I'll allow the user to rearrange the boxes, minimize them, or whatever. This could make for some nice UI practice. But again, that stuff can be dealt with later, so let's keep the first version basic.

Allright, I guess this is my spec. Now let's forget all about it and fool around.

Of course, turning it into something practical is where the real work begins, especially if you want non tech-savy people to use it. But that's interface work, really. The base logic is still child's play. ↩
The first official spec came out in 1999. ↩
I guess there's also Bash. This could actually be a good occasion to get more familiar with the classic unix tools. But this will take me longer and possibly require more dependencies. Also, I hate Bash syntax. ↩

I Made A Thing

2025-06-03T21:00:00+02:00

So, the (very) rough draft of my RSS aggregator is up and running.

There's still a lot of room for improvement (easier configuration, caching the feeds to avoid redownloading them each time the command runs¹, processing them asynchronously instead of one after the other like a dummy...) but it works.

Handling the feeds was about as straightforward as I expected (with a small caveat: the spec is quite loose regarding which field should be mandatory or not, which can cause some shenanigans if you're expecting to find some data that's not included. One feed I used for testing had a modification date, but not a publication one, for instance. No big deal for a toy script, but I can see how this could become a pain in the butt²).

Outputting the html turned out a bit tricker though. I planned to use Jinja's inheritance to integrate the markup into the global site layout, like I do with pretty much every other page, only to realize that this was supposed to run on the server.

Pelican runs on my local machine, which is where all the templates are. Only the generated output gets uploaded to production. So there's no base template to inherit from.

Well, Duh. I just dumped a document fragment and include it in the main page via javascript. Not great, but hey, it works. I could see it becoming useful if the feed grow large enough, though.³

As often, the only real hurdle was due to one pretty stupid oversight. I planned to organize the various feeds into several categories, and display each category in its own box, like so:

I stole the idea from the old aggregator Sam & Max⁴ used to run. Sadly, it's not online anymore, so this is from memory. And no, I don't see what's wrong with the design.

No matter where I got the idea, the rub is that I'm currently subscribed to a grand total of 4 feeds. Two of which strike me as interesting to share here. So while the idea of having different categories is cute, I just don't see how this is useful right now.

Oh well. I'll keep the idea in mind and wait and see if it makes sense one day. Until then, I'll just stuff everything in a single category and call it a day.

It's probably gonna be a little while before this page gets interesting, but the plumbing is in place, so adding sources to it should be easy.

Unrelated: I hate Python type hints

The python community have been pretty keen on adopting type hints over the last few years. I've tried to use them a couple of times now and got rid of them after 10 minutes.

I get the appeal of static typing, and I even enjoy it when I'm fooling around in C or some other, stricter language. The general consensus seems to be that dynamic languages didn't turn out so great, and the compromise of optionally declaring your types seems to be getting popular⁵. That's fine.

But Python's implementation just feels wrong to me. Maybe Its just old habits clouding my judgment. And I'm sure I could get the hang of it after some practice.

It starts out nice enough, but pretty soon you're having to import a dozen names to handle builtin types like lists or dictionnaries. Function signatures become a mess.

# Exemple lifted from https://www.geeksforgeeks.org/type-hints-in-python/
from typing import Optional, List, Tuple

def get_user(id: int) -> Optional[str]:
    return None if id == 0 else "User"

def sum(num: List[int]) -> int:
    return sum(num)

def get_name_and_age() -> Tuple[str, int]:
    return ("Abc", 25)

Sure, there's a lot of information packed in there. But I can't parse any of this from a casual glance. The same code used to look like this:

def get_user(id) :
    return None if id == 0 else "User"

def sum(num):
    return sum(num)

def get_name_and_age():
    return ("Abc", 25)

I don't know about you, but if I were to check out a language praised for its readability, I'd sure expect something closer to the second exemple (although to be fair, the first one is pretty mild, but things can get much hairier. Also, the sum function shadows the builtin one and triggers an infinite recursion.⁶ This has nothing to do with type hints, though (then again... it was easier to spot in the distraction free version...)).

Also, I ran into this case:

class Feed:

    def __init__(self, some_stuff: StuffType):
        self.stuff = some_stuff

    @classmethod
    def from_url(cls, url: str) -> Feed:
        stuff = get_stuff(url)
        return cls(stuff)

Which is simple enough, but blows up with a NameError. Since the class is built dynamically, the name Feed is not defined yet when it's used as from_url's return value.

Python 3.13 fixed this, and you can get it to work on earlier versions with a __future__ import.⁷ I'm far from being a language expert, but I do know that evolving syntax is hard, and this tells me the devs have to modify the parser to handle corner cases that feel like they should be obvious, which confirms my overall impression that this whole thing is being duct-taped on top of something that was not designed for it.

Again, I may just be an old fart yelling at the clouds here. People way smarter than me are endorsing this, and my pythoning has been pretty anecdotic since 2019, so I'm not really in a position to argue with anyone who deals with it on a daily basis. Also, I'm not defending dynamic typing at all cost here. I'm just worried than this evolution is just not as straightforward as it seems. It's been 10 years since the syntax was first introduced and cases like the one I ran into are only now being handled.⁸

I keep telling myself I'll give it a fair try sometime, but I just can't be bothered for the quick and dirty stuff I tend to do these days.

Okay, rant over. See ya and long live duck typing.

Editing note: wait what ? Why would I do that ? Refreshing the data is the whole point of this script. Funny how stupid half-assed thoughts can make you feel when you stumble back upon them later on. ↩
This is why people are pushing to move to Atom, which is a stricter specification for syndication. I tend to call them both "RSS" out of habit. ↩
I resisted including htmx just for that and wrote the plain js version. Hurray for discipline. ↩
Content Warning: this is a french blog. Also, NSFW. ↩
The new hot thing seems to be type inference, in which the language is statically typed but can infer those types when its obvious (typically when declaring variables). I haven't played much with it, but I like it. Also, Zig code can get pretty ugly, but for some reason its signatures don't bother me one bit. It feels like a natural part of the syntax. ↩
AKA stack overflow ↩
This brings back memories of supporting both Python 2 et 3. ↩
I'm not trying to imply that the python devs are doing a bad job here. Far from it. I vaguely understand why it happened, and I know that changing the fundamentals of a language is a long and thankless job. I just wonder if the end result is worth so much hard work. ↩

I Don't Care About Star Wars Anymore

2025-06-09T21:00:00+02:00

Really. I don't. Maybe I've finally grown up. Or maybe I'm just too bitter and need to get out to stop the pain. But while I'll still cherish the memories, I'm truly done caring about whatever happens to this franchise.

So let's waste your time and mine whining about it, shall we ?

The purpose of this blog is to get back into the habit of writing stuff down. Indulging in some nerdy nitpicking seems like a fun way to do that. Naturally, most of the topics ideas I'm getting are things I've been mulling over for a while already. And apparently quite a few of those still revolve around Star Wars. Some of those takes are not things I commonly see whenever my web roaming brings me back to this old galaxy. Maybe that makes them interesting, or maybe I'm just that annoying guy that always needs to have an opinion different from everyone else's.

I don't know if I'll get around to those rants or not, but if I do, one of the annoying things about this series is that it can mean so many different things to different people that it's impossible to say anything meaningful about it without first stating what the franchise even is to you, as this will affect any point you try to make.

So let's do that. This way I'll have something to link to if I ever decide to touch the subject again.

A long time ago...

I first saw Star Wars¹ on VHS at about 7 or 8 years old. I remember liking it quite a bit, but for some reason the bug didn't quite bite. I thought "yeah, okay, that was pretty cool" and moved on with whatever else I was infatuated with at the time.

Then a few years later my mom took me and my cousin to see it again as the special editions² hit the theaters (According to their release date, I was ten by then). And this time lightning struck. We had to go see The Empire Strikes Back on the very next day, and then had to wait two whole weeks before we could finally see the saga's conclusion. I had seen the light. From then on, Star Wars was my religion.

Being an obsessive kid, I dove head first into it. I read all the books I could get my hands on, even going so far as trying to read one I found in English.³ I wrote awful stories about my own version of Corran Horn. I didn't play video games, I played Star Wars video games. At some point I got into role playing games via, you guessed it, that old D6 edition. I wanted to know everything about this galaxy far, far away and quickly connected with a couple of guys my age that seemed to love that stuff as much as I did. I still consider those guys my best friends 30 years later.

So when it comes to the OT, I may suffer from some slight nostalgia bias.

That being said, after mulling over those for quite a while now, I like to think my appreciation for it is not all rose-tinted glasses.

The older I get, the more convinced I am of the importance of storytelling. The tales we share define us, both as individuals and as a culture. And what made that original trilogy tick wasn't so much its groundbreaking visuals or its weird mashup of pulp influences (although those definitely helped). It was that it got its plot fundamentally right.

Lucas' first draft was a tangled mess of ideas that no one could make sense of, but after rewriting it several times, he ended up with a clumsy⁴ and simplistic script that dutifully checked all the marks from Joseph Campbell's Hero's Journey. While structurally sound, it was pretty blunt, which turned out to be its main strength.

The archetypal characters and lucas's general lack of direction allowed the enthusiastic cast to nail their parts, while its retread of classic tropes made it easy for audiences to grasp as they got introduced to this brand new setting while being bombarded with all the spectacle.

The sequels took this diamond in the rough and polished it. Lucas wisely (and perhaps reluctantly) delegated writing and directing to people who knew what they were doing, and it paid off. The Empire Strikes Back added much needed depth to the story while staying laser-focused on its themes, and Return of the Jedi managed to bring it to a satisfying conclusion, despite being the weakest of the three⁵.

As a kid, I certainly didn't give much actual thought to those movies and kept to the escpapist fantasy. But looking back, it's obvious that the coming-of-age story deeply resonated with me. Star Wars is far from the only one of those, but it's the one that grabbed me and as such, it's part of whoever I became.

I Don't Want to Grow Up

Two years after I became a believer, The Phantom Menace came out. Needless to say, I was all over it. It was freaking Star Wars, so how could it not be the best thing ever ?

But by the time we got to Revenge of the Sith, I was pushing eighteen and in my final year of high school. Having developped some basic critical skills in the meantime, I was definitely not impressed with that new trilogy.

It had many flaws, but its biggest one was by far the writing (which, again, had always been Lucas' weak point). This went far beyond the cringy love scenes and terrible lines about sand. A lot of people complained about the acting, but that was a symptom of how awfully dull the characters were to begin with.

Years later, I'll begrudgingly admit that delving into the politics behind the fall of the Republic and depicting the ineptitude of the late Jedi order were interesting ideas, which I dismissed back then out of a misguided notion of what Star Wars should be about. But ideas are worth nothing if executed poorly, and sadly the story was so badly told that there's no way I can care enough to reconsider them.

Some people like to point out that supposedely everyone loved the first episode when it got released and hating on it only became trendy later on, completely disregarding the fact that the hype around these movies was huge. Yes, people tend to get caught up in the excitement when things are new, and it takes some time to revise one's initial judgment. Dismissing opinions you don't agree with as blindly following the herd can work both ways.⁶

But those people do have a point: Hating on the prequels did get pretty trendy.

George Lucas ruined my childhood

RedLetterMedia's epic sized reviews of the (by then) new trilogy started a new kind of web entertainment, which mostly consisted in trashing some notorious piece of media while playing up the outrage for comedy. This formula got pretty popular, to the point of getting quite tiresome more than a decade later.⁷

The conversation quickly focused almost exclusively on Lucas himself, and soon devolved into memes about him turning to the dark side and willfully setting out to sully everyone's childhood memories. Clearly the man was a fraud who didn't understand his previous creations. It was a textbook fall from grace. People felt betrayed, and this being the internet, the whole world had to know about it.

Looking back, it's embarassing how far some of us took it, and how petty and entitled the whole thing could get.⁸ But back then I was fully on board. Luckily, there was some valid criticism among all the nitpicking and Lucas bashing, and this whole period got me to think a lot about storytelling and the creative process. I learned to move on from listing plot-holes and focus more on bigger picture elements like tone, theme or characterization.

I slowly started to understand how foolish putting individuals up on pedestals is. Lucas' story was a perfect exemple on just how harmful the myth of genius can get. He'd never been the god-like visionary some had made him out to be. He wasn't an evil hack only concerned about business either. He was just a regular guy with some good ideas and a drive to make cool stuff, and the real tragedy of the prequels was that no one dared to help turn these ideas into something coherent.⁹

As bad as I still think those movies were, they helped me to understand why I had to kill my idols. A recurring meme back then joked about how Lucas had turned into Darth Vader. Sadly I didn't see any follow-up about how maybe it was time for us nerds to confront and atone with our collective father.

At some point in the early 2010's I was done grieving, and forgave George for his sins. I would still glance at whatever was going on in the EU, but was content knowing that the main saga was basically done. Surely we could now all move on and hopefully learn a thing or two from past mistakes. Everything was going to be allright.

Here we go again

I've got a bad feeling about this...

Disney buying the licence felt like someone about to resurect the corpse of an old friend. I didn't want more Star Wars, and only wished for it to rest in peace. But sadly billion dollars media companies don't seem to care about what I want, and the rest of the world seemed pretty excited. And hey, Lucas was out, so surely this couldn't be as bad as the prequels, right ?

"I'm just happy we'll get to see some new Star Wars" was a pretty common phrase to hear. My answer to this was that I'd rather get more Firefly.

There's nothing wrong with wanting more of something you love, and I'm not against the idea of telling new stories in a pre-existing setting. But the tale should come before the brand. Keeping a series going just for the sake of producing ever more content was already a long tradition, and we all knew from experience that digging up old and beloved franchises to do so was fraught with peril.

Star Wars being such a cultural touchstone with an already divided fan base, Disney had a tough job on their hands. It wasn't hard to predict it couldn't please everyone, and we already knew how mad the internet could get over those things. Some kind of backlash was inevitable, no matter how good or bad the new movies would turn out.

As much as I pretended not to care, I was still emotionally attached to this universe and I dreaded reliving the prequels bullshit all over again.

A dull awakening

As much as I didn't want to like it, I still tried to approach The Force Awakens with a fair and open mind.

As an exercise in mimicking the orginals, it was pretty good. But as far as substance, there wasn't a lot to chew on. Playing it safe with the first movie was understandable, but did it really need to repeat so much from A New Hope ?

The marketting made a lot of noise about how much respect was being paid to the OT, but that respect largely showed at the surface level. Most of it boiled down to cheap appeals to nostalgia (I hated the Millenium Falcon reveal¹⁰) and some (admitedly stunning) shots exalting the old iconography. The new cast felt like kids playing make believe in the Star Wars universe, which was cute and endearing, but failed to make up for the uninspired script.

The few themes and ideas it introduced remained under-developped and I didn't care for the story hooks it left for its successors (I never understood why everyone seems to think star wars has to involve mysterious lineages, but that's a topic for another time). I guess it did its job of getting a plot started, but between the characters' lack of growth beyond their basic concepts and the movie's refusal to give some kind of context to what was going on, I was struggling to see much of interest in there.

Are your expectations subverted enough ?

I'll give this to The Last Jedi: it surprised me.

I genuinely laughed at Ryan Johnson's methodical dismantling of every single plot point Abrams had left him. It felt like a middle finger to how bland and uninteresting these ideas were, which I almost wanted to applaud.

I'm just not sure demolishing the ongoing plot so thoroughly right in the middle of a three acts story was such a good idea. Dropping a few threads and taking some things in a new and unexpected direction would have been fine, but by the end, I was struggling to see how anyone could possibly follow up on this mess. I saw some people hoping the next episode could fix this, but there was nothing left to fix.

Assigning each film to a different director wasn't a bad idea, but one would expect those three to agree on some kind of general outline before getting to work. I still can't understand how such an oversight from Disney was even possible.

Johnson also set out to deconstruct the rusty tropes Star Wars has been saddled with for ages, which is a perfectly valid goal¹¹, and something I would agree was badly needed. The trouble is that he didn't get much further than pointing these tropes out, and didn't bother to dig much into them. A more subtle approach and a better script could have made it work, but as it was, the whole thing felt petty and not nearly as clever as it thought it was.

While having radically opposed intentions, both TFA and TLJ ultimately suffered from the same fundamental problem: they had nothing to actually say. As bad as I still think Lucas failed with his prequel trilogy, I could now see that he was at least trying to bring something new to the table.

Calling it quits

By that point I had truly lost all interest. I didn't watch Episode 9, and while I did feel some vindication at how badly it was received, I didn't care enough to gloat.

Disney's handling of the franchise boiled down to an awfull lot of noise about nothing. The sinking state of online discussion and the ongoing culture wars only made it more frustrating to try and reason about. Plans for more theatrical releases seem to be abandoned for now, and the future seems focused on TV shows, which thankfully don't get as much media coverage. I'm told some of them are decent, which I have no reason to doubt. Smaller productions aren't expected to generate as much profit as summer blockbusters, so there's more room for them to try new things.¹² I just can't be bothered to pay attention anymore.

Epilogue

Stories matter. Whether it's the bible or your childhood's comic books, we all have a few stories that shaped us into who we are.

That's why it hurts to see them die. The nerd outrage can get pretty childish, but there's a reason we get so emotional in the first place. Treating these stories like mere content to be consumed and wondering why anyone would care so much about silly space wizards is missing the point. Lashing out and abusing blasphemers is just as misguided. Nothing of value will grow from that battlefield.

We should remain critical of what gets produced, and it's okay to nerd out and bicker about it. Let's just stop turning this stuff into holy wars. Stories matter, but that doesn't make them sacred. Ditch the dogma, and focus on looking for some bit of meaning. If you can't find any, just walk away. Rant about it if that makes you feel better, but don't forget to move on, and please don't feed the troll factory. This way lies only madness.

And maybe start writing your own stories.

I guess this is what Star Wars taught me. I know this sounds corny, but it took me 20+ years to begin to get it. Maybe someday I'll learn to get to the point. Anyone knows of a good story about that ?

If you're not sick of Star Wars yet and are hungry for more, sfdebris has a fascinating three parts series on Lucas' evolution and the making of both his trilogies, up to the sale to Disney. Good stuff.

It had already been renamed and labeled as the fourth episode, but I didn't care or notice. The guy who'd lent me the tape called it "Star Wars", so "Star Wars" it was. ↩
Which is why, while I can agree with most of the criticism those versions got, I still can't be too bothered about it. Those were my originals, so whatever fault they may have can't be that bad. ↩
I gave up after one chapter, but still, that was pretty ambitious. ↩
Mark Hamill loved mocking lucas's dialog and did so in many interviews. ↩
Want an idiosyncratic (and maybe controversial) take ? Making Leia Luke's sister was a dumb decision and the first step in making the whole galaxy feel like it revolved entirely around a handful of people. ↩
I saw the same argument about Disney's Episode VII. Since I was already a cynical asshole when that one came out, I can proudly say that this time my opinion never changed one bit. ↩
When done well, it can be fun and raise interesting points. Sadly not everyone does it well. ↩
Jake Lloyd didn't deserve any of this shit. I don't think we realized just how toxic internet discourse could get, and sadly it's only gotten worse since then. ↩
Watching some behind the scene footage, you really get the impression that people are afraid to question anything George says. Maybe he wouldn't listen anyway, but I can't help to wonder if his "mad genius" aura makes those people assume he just can't be wrong. ↩
That camera pan was the cinematic equivalent of an obnoxious kid tapping on your shoulder while yelling "LOOK! LOOK AT THAT THING YOU LIKE!" ↩
KOTOR II tried to do just that and mostly succeeded. Too bad it suffered the Obsidian curse of lacking an ending. ↩
I didn't cover Rogue One here to try and keep this from becoming a freaking novel, but it was a pleasant surprise. ↩

Learning Touch Typing

2025-06-12T15:00:00+02:00

I stumbled on this article the other day. It's about learning to touch type, and the author compares the process to musical practice. While the "Fast, Slow, Medium" routine he describes is debatable¹, the basic idea makes a lot of sense. After all, both activities involve building up mechanical skills and developing muscle memory, so it makes sense to find some overlap between the two methodologies.

I've been trying to finally get decent at typing myself for the last few weeks, and I'm noticing more similarities with working on instrumental technique, as well as a tendency to fall into the same kind of traps.

I don't really expect any of this to be useful to anyone, and just felt like pointing out those observations. I don't know why, but I've alway enjoyed finding parallels between seemingly completely unrelated things. So here goes.

Where I'm coming from

I somehow got comfortable using a keyboard casually as a teenager without ever giving it a thought. I did use more than two fingers, but beyond that I had no idea what I was doing. Somehow that felt good enough for a while.

Only when I got into programming did it start to bother me. In part because I was too slow to feel like a proper hacker, but mostly because I was making three typos per line.

Typos aren't too bad when you're just writing casual stuff or chatting with friends, but code is not as forgiving. Fixing stupid goofs one after the other gets infuriating pretty fast, especially when you're trying to understand what in the hell your program is even doing. I knew I should do something about it, but somehow I just kept going and endured the frustration.

At some point I quit my job and didn't get to use a keyboard for anything serious for a while. I would get the coding itch back now and then, and couldn't stand the constant mess ups. I felt downright impotent.

I started doing drills on Typing Club about a year ago, but didn't keep at it for long. Starting this blog got me to type quite a bit, though, both code and prose, so it seemed like a good opportunity to finally get serious about it.

It's slowly getting better. I'm about as fast as a stoned turtle, but I'm making less mistakes and can mostly keep my eyes on the screen. Numbers are still giving me cold sweats, though.

Building technique

When chatting about music, I often run into that guy whose main contribution is to lecture people about how technique doesn't matter, because it's all about, like, the feel, man.

This is like saying you don't have to learn how to drive your car as long as you know where you're going. I can agree with the idea that it's better to focus on your destination than to fuss over technicalities, but I'm not sure how far you'll get if you don't know how to start your engine.

Technique is nothing more than knowing how to use your tools. Good technique is not about being a virtuoso, it's about internalizing the mechanics deeply enough that you don't have to think about them anymore. You know the saying that your instrument should become an extension of your body, so that the music is free to flow directly from your mind to the ears of the listener ? This is what good technique is.

If you're writing stuff on a computer, then the keyboard is your instrument, and the same logic applies.

Old habits die hard

Around 2012 I got into Bluegrass and quickly realized just how terrible my right hand was. I had been playing for more than 10 years already and had never paid that much attention to it. I knew it wasn't great, but just like my keyboard skills, I figured it was good enough for what I was doing.

It wasn't, and trying to pick out fiddle tunes on the accoustic guitar made that abundantly clear.

I set out to pretty much re-learn my technique from the ground up. It took me about 8 years to finally get it back in a state I was reasonably pleased with.

A lot of that time was spent figuring out how to even start fixing it, and I didn't have the time to truly work on it for a couple of those years². Still, it took a while. Hopefully touch typing won't take that long.

Along the way I ended up in that weird place where the old muscle memory still kicked in and interfered with the new habits I was trying to settle, which only made things worse. This is pretty much what typing feels like now. It all straightened out in the end though, and luckily I'm not typing on a stage and don't really have deadlines to worry about, so now is the best possible time to deal with the transition.

Start at the begining

When starting out, you may want to learn Mary had a little lamb before tackling Flight of the bumblebee.

Start from the basics, and then build on those fundations. Typing drills are just like scale practice. There'll come a time when your fingers will have figured out what they're supposed to do, and by that point you'll be able to just let them run on their own as you switch your attention to what you want to say in the first place.³

At my first dev job I got into vim, and while I soon reached the point where I wasn't feeling crippled anymore, I never noticed the huge boost in efficiency the evangelists were raving about.

That was simply because I was constantly hitting the wrong keys, which would often mess things up in hilariously random ways (which prompted me to memorize the undo binding quickly). Learning the commands wasn't hard, but my fat fingers were too inept to apply that knowledge properly, so most of the benefits went to waste.

This is the point where I really should have bitten the bullet and start getting comfortable with the home row.⁴ Learning vim without fixing my typing first was like trying to run before I could walk.⁵ In retrospect, It's frankly embarassing that I didn't get on it then.

Working sucks

Drills are work, and not the rewarding kind. They are a meaningless chore.

I'm lazy, and I don't like doing chores. Like many, I'm terrible at just pushing through and tend to skip to the fun parts.

I also resent being told what to do. I don't ignore all advice, but I usually decide to try things my way anyway and see if I get burned. This wastes time in the long run, but the few lessons I end up learning tend to stick better.

The key for me is to understand why I should bother in the first place. Become aware of the actual problems I need to solve. "Yeah, I guess I'd get better if I did this" or "That's what the greats do" is not enough. I have to feel the pain before I try to soothe it.

Once I decide to get started, the next hurdle is to commit to it. I'll struggle to get a routine started, but once it's going, it helps a lot. I also need to find ways to make it enjoyable. I'm not a huge fan of gamification, but it seems like a good fit here.

The whole process is frustrating, especially when progress is slow. I might get fed up and bounce off at some point, but I know there's no way around it. The way to git gud is to struggle.

Slow the hell down

This one should be obvious, even more so in my case. The reason I decided to start working on this in the first place was the astronomic amount of typos I was making, so aiming for accuracy rather than speed is my real goal to begin with.

And still, I found myself hammering away at my regular speed (if not faster) and wondering why things weren't improving. That blunder was easy to spot, but as I forced myself to take it slower, I noticed something I already experienced on the guitar: I was making even more mistakes.

My guess is that this is due to the existing muscle memory getting confused. When going at a speed I'm used to, the fingers happily jump in the general direction they're supposed to, but slowing down reveals how imprecise they really are.

My solution is to double down. I stop before each and every character and describe to myself the movement I have to execute before typing it.

Reach for the right shift key while pressing the left hand's fourth finger down.
Click.
Move the right hand's third finger up one row.
Click.
Get the third finger back to its home position while moving the first one down, extending it to the left by one key.
Click.
Bring the first finger back, while moving the left hand's first up and to the right.
Click.

Congratulations. You just spent thirty seconds typing "Font".

Going that slow feels like torture. It brings back memories from dusting off the metronome after ignoring it for so long. And I remember that when I got on that, I was amazed at how quickly it stopped feeling painful. After a while it even became kind of pleasant.

I don't expect deliberately typing at 5 WPM will ever become fun, but I'm sure getting into the right mindset can make it at least tolerable.

Keep your eyes up there

I've often heard folks express amazement at how some blind people could get so good at their instruments. The reason why always felt obvious to me: being deprived of one sense forces you to develop the other ones even more to compensate.⁶ Hearing is the most obvious one, but I would argue touch is just as important, if not more.

Again, the where and how to play anything gets ingrained in your muscle memory. Once it's internalized, you don't need to look at what your fingers are doing anymore.

I made a point of deliberately not looking at my left hand when I play. I find it helps me switch my attention away from what I'm doing and towards what's going on around me. It pushes me to think with my ears instead of following scale patterns. And I start to physically feel what I'm playing, rather than watch it.

If you've been playing for a while, try it. Close your eyes, turn off the light or just stare at the wall in front of you, and play something. I'm willing to bet it won't be as hard as you think.

Blind musicians have to develop that physical relationship to their instrument because they simply can't rely on their eyes to help them figure things out.⁷

Typing is much less abstract, and the benefits of keeping your attention on the screen are much more obvious, so it makes sense that your very first goal should be to stop looking down at the keyboard. That's what the "touch" in touch typing stands for, after all.

Context is everything

One last annoying part of this process is how big of an impact context can have on your performance.

I might be doing well in some typing app, and then switch to editing some code and everything comes crashing down. As soon as I start having to actually think about what I'm writing, the fingers seem to get lost again.⁸

Again, this reminds me of how different everything feels when playing in a new setting (alone or with a group, on stage or at a casual jam...). Every situation comes with its own unique set of details to pay attention to, which can really play a number on your technique.

I also tend to be quite sensitive to slight changes in the gear I'm using. A pick or a string gauge I'm not quite used to can really trip me up. This makes me wonder how I'll handle having to type on a different keyboard.

Allright, that's all I have.

I'll end this by quoting a comment from the article I opened with (note that it's from 2008):

Not trying to offend anyone here, but I've never encountered a person (programmer or otherwise) under 30 that can't touch type. Could this be an age thing?

I'm not even sure touch screens existed in 2008, let alone smartphones. The assumption that of course young people would pick up touch typing on the go wasn't that far fetched back then (although I'm proof that many didn't care enough), but it's a bit depressing how ridiculous it sounds 15 years later.

While a few occasional, stupidly fast bursts of speed can be fun, I wouldn't make it part of the routine, and I certainly wouldn't start with it. ↩
Turns out playing in four bands while keeping a full time job isn't such a great idea. Everytime a rehearsal got cancelled, I figured I'd use the time to work on that damned right hand, only to spend the night loafing around on the couch. Working when your mind is drained is no use. ↩
Tommy Emmanuel has a line I quite like about this:

"It's not music yet. This is learning skill. When you practice the skill enough, it turns to music, but you can't have the music without the skill." ↩
If the use of hjkl for movement is still baffling to you, now you know why it makes sense. ↩
I kept using vim, though. Modal editing made sense to me and was handy even if it didn't speed me up that much. The mistakes I kept doing were quick enough to fix, and as I got used to it I started to really miss most of the basic bindings when I couldn't use them. vim didn't make me more efficient, it made me suck even more at the other editors instead.:w ↩
To be clear: I'm not claiming that all blind people are musically gifted, and I don't want to diminish the hardship of handicap. I'm simply pointing out that the phenomenon, when it does occur, is not as surprising as it seems. ↩
Again, I'm not suggesting they have it easy. Sight is immensely useful when learning. Without it, say bye-bye to most learning resources. Sheet music. Chord / scale diagrams. Hell, you don't even get to look at what other people are doing. You'd be a fool not to take advantage of it. But at some point, it might be worthwhile to ditch that dependency. ↩
Prose doens't seem to trip me up as much, and since I'm not looking for immediate feedback, slowing down and fixing mistakes as I make them is not as annoying. So, good thing I'm spending so much time on these articles, I guess =) ↩

Implementing Dark Mode

2025-06-17T18:30:00+02:00

Allright, here's a dark mode switch. Because it's cool and I was bored.

I learned only a few months ago that variables and nesting had both made their way into the CSS standard. And apparently it's been long enough that most major browsers should support it.

That's sweet. Those were the only two features I actually used in LESS, so I ditched it.

Using those variables, here's the entirety of the dark-mode specific code I needed:

body.theme-dark {
    --background-color-main: #1c1b22;
    --background-color-scrolltop: grey;
    --background-color-tooltip: #312f3b;    /* main background lightened by 10 % */
    --txt-color: #fff;
    --txt-color-light: darkgrey;
    --txt-color-tooltip: #fff;
    --link-color-hover: orange;
}
body.theme-dark img {
    filter: brightness(.95) contrast(1.2);
}

(And apparently, pygment¹ can't handle css nesting. Oh well.)

Of course I had to actually use the new variables in the rest of the stylesheet, but that's not too bad, and it should make it easier to change things around down the road.

I hope you'll find it pretty. If you don't, consider that I seriously entertained going with this:

I honestly kind of like it. It's brash and amateurish, but I happen to like that vibe. Maybe I will switch back to it just to piss people off.

Also, it reminds me of the posters my dad used to make.²

Oh, by the way, I'm storing your chosen theme in your browser's localStorage, so I guess I'm technically kind of tracking your activity. Let's hope the GDPR won't get me for this.

On a completely unrelated note, it's been a month since this site launched. Looks like I'm still having fun with it. So, that's cool I guess.

The python library I'm using to highlight the code snippets. ↩
Those only had a few lines of text, so obviously it wasn't as overwhelming. But the yellow on black titles made them stand out and was pretty distinctive. ↩

Dark Mode: Followup

2025-06-21T15:00:00+02:00

So, I started fooling around with a django app since the last time, and noticed the debug toolbar¹ had added a theme switcher (this may be old news. It's been a while since I started a django project).

Since I had just fooled around with it myself only a couple days before, I took a look at their implementation.

It's very similar to what I had done (which I scraped together from various examples), but slightly shorter and a bit more elegant.²

So obviously I started fooling around with it and began adapting it to what I wanted. Along the way I fell into the overengineering trap and turned it into some kind of library.

Here's what I ended up with:

// Lifted and adapted from django-debug-toolbar:
// https://github.com/django-commons/django-debug-toolbar/blob/c217334010fa54a8726640519ca29cb77fffda58/debug_toolbar/static/debug_toolbar/js/toolbar.js#L215
var themeToggler = (function(w, d, undefined) {

    const defaultOpts = {
        switcherElementSelector : "a#theme-switcher",
        rootElementSelector     : "body",
        localStorageVarName     : "user-theme",
        dataThemeAttrName       : "data-theme",
        lightThemeName          : "light",
        darkThemeName           : "dark",
        autoThemeName           : "auto",
        callback                : undefined,
    };

    const prefersDark = w.matchMedia("(prefers-color-scheme: dark)").matches;

    // Those will be set from opts in the init function and therefore can't be
    // const.
    var themeList   = undefined;
    var rootElement = undefined;

    var userTheme   = undefined;

    const setTheme = (theme, opts) => {
        rootElement.setAttribute(
            opts.dataThemeAttrName,
            theme === opts.autoThemeName
                ? (prefersDark ? opts.darkThemeName : opts.lightThemeName)
                : theme
        );
        if (opts.callback) {
            opts.callback(theme, opts);
        }
    };

    return {
        init: (_opts) => {
            const opts = {...defaultOpts, ..._opts};

            themeList = prefersDark
                ? [opts.lightThemeName, opts.darkThemeName]
                : [opts.darkThemeName, opts.lightThemeName];
            rootElement = d.querySelector(opts.rootElementSelector)
            userTheme = localStorage.getItem(opts.localStorageVarName) || opts.autoThemeName;

            d.querySelectorAll(opts.switcherElementSelector).forEach((el) => {
                el.addEventListener("click", (ev) => {
                    const index = themeList.indexOf(userTheme);
                    userTheme = themeList[(index + 1) % themeList.length];
                    localStorage.setItem(opts.localStorageVarName, userTheme);
                    setTheme(userTheme, opts);
                    ev.preventDefault();
                });
            });

            setTheme(userTheme, opts);
        }
    };
}(window, document));

I followed what I'm half remembering from the best practices of the 2010's³, and it looks like an old jQuery plugin as a result.

I completely stopped following whatever was going on in the Javascript world about ten years ago. Hell, even the arrow function syntax feels new to me. So I have no idea how actually usable this is in the current ecosystem.

I don't care, though. For what I do, copying and pasting scripts is more than enough, so this will do for now. Maybe I'll have a look at web components and see if it makes sense to turn this into one, though.

I don't feel too bad about going overboard with the parameterization. The actual logic is still pretty simple, and dark mode is a nice usability feature, so having some drop in snippet to use in a future project could come in handy⁴.

For comparison, here's what I'm currently using on this site:

function getTheme() {
    var theme = localStorage.getItem('theme');
    if (!theme) {
        theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
        localStorage.setItem("theme", theme);
    }
    return theme;
}

var stylesheetLight = document.getElementById('syntax-style-light');
var stylesheetDark = document.getElementById('syntax-style-dark');

function switchTheme(theme) {
    var body = document.querySelector('body');
    if (theme == "dark") {
        body.classList.add('theme-dark');
        stylesheetLight.media = "not all";
        stylesheetDark.media = "screen, projection";
    } else {
        body.classList.remove('theme-dark');
        stylesheetLight.media = "screen, projection";
        stylesheetDark.media = "not all";
    }
    localStorage.setItem("theme", theme);
    return theme;
}

var theme = getTheme();
switchTheme(theme);

var themeSelector = document.querySelector("button#theme-switcher");
themeSelector.addEventListener('click', function(ev) {
    theme = switchTheme(theme === 'dark' ? 'light' : 'dark');
    ev.preventDefault();
});

It's shorter and more to the point, but also coupled to this particular site's markup, which means it'll need some editing to be useful elsewhere.

It's also taking care of some specialized logic (switching the styles for syntax highlighting) which many sites probably won't need, which is what prompted me to add a callback option to the reusable version.

Adding an option to switch between setting a class or an attribute could be nice, but hey. Maybe I'll do that at some point, but that's good enough for now.

The bug that wasn't a bug

As I dug into the debug toolbar code, I spotted what I took to be a minor bug, and dilligently opened an issue about it. Turns out it's not a bug, and I learned something in the process. Sweet!

In short, they're offering three options: light, dark, and auto, the last one being mapped to the user's system's preferences, which can change between two visits.

The issue is that toggle buttons with more than two states feel weird to use, and in this case you end up with one out of three clicks effectively doing nothing.

Having the third option is the right thing to do from an usability standpoint, but the UI for it should probably be a dropdown list (or a simple bunch of dumb links I guess). This can be harder to integrate within a broader design, though.

If you read my code, you'll have noticed that I kept only two states. This barely changes the logic (adding a third one would only involve modifying a couple of lines), but I don't want to bother implementing a nice dropdown. I think ignoring the user's potential changes in preferences isn't too bad for a simple website, so I'll keep things nice and simple.

Still, I'll have to at least think about this on future projects, and my snippet might turn out not so great for the ones that should include the "System Settings" option. If I ever write a doc for it, it will need to start with this disclaimer.

My first real article was an attempt at demonstrating how designing a good interface requires a lot more thought than simply going for maximum bling. This whole thing is a nice reminder of this.

Javascript Apocalypse

For a self proclaimed back-end dev, I seem to be posting a lot of javascript on here. Part of the reason why is that this site being static, I don't have a backend when I'm fooling around with it.

I have this weird love / hate relationship with javascript. The language's quirks often drives me crazy and I'm appalled at how it seems to have conquered the whole world⁵, but somehow working with it tends to feels nice. I don't know why, but I just enjoy it. I'm strangely fascinated by prototypal inheritance, even though I've barely used it, and I love the language's history, too. Even its name doesn't make sense.⁶

Also, you can do shit like this:

const switcher = document.querySelector('button#theme-switcher');
// I tried a few different values and chose that one for maximum annoyance.
// Don't ever tell me I don't suffer for my art.
const delay = 150;
function epilectic_jamboree() {
    switcher.click();
    setTimeout(epilectic_jamboree, delay);
}
setTimeout(epilectic_jamboree, delay);

I almost put a prank link to activate this on this page. Oh, you know what would be even worse ? Choosing a random link on each page load and pointing it to this abomination. Now that would be pure evil. Pray that I never get bored or pissed enough to do it.

Allright, so between getting sidetracked with this whole js thing, reading up on UX and writing this article, all I have to show for yesterday's work is a mostly blank html page. Which can switch colors, I guess.

I hope my boss won't mind.

One of the first things I install whenever I start anything with django. I barely ever look at it but it's invaluable to have it set up when something inevitably goes wrong. ↩
Using modulo to cycle through list indices (ie: themeList[(index + 1) % themeList.length]) is one of those simple tricks I wish I thought about more often. ↩
Self-calling anonymous functions, yay \o/ I remember how weird those felt when I first saw them. ↩
I guess adding some docs would still be a good idea, tho. ↩
If some general AI ever takes over the world, chances are it will run on javascript. This fact is both reassuring and terrifying. ↩
As usual, marketting ruins everything. ↩

Happy Pony

2025-07-15T20:00:00+02:00

Apparently, Django turned 20 two days ago.

I've worked with the framework professionally for about five years¹, and kept using it occasionally since I quit my job. Two weeks ago, I started fooling again with it on something slightly less trivial² than the minimalist sites or tools I've been hacking on for the last few years.

Being busy with this side project and a few other things, I stopped posting on here, so in order not to lose the writing habit I've been trying to build, I figure joining in the celebration is as good a topic as any.

Long story short: it's still awesome.

Catching up with an old friend

As I just said, I didn't really use the framework seriously for a little over 5 years. And I was amazed at how little the general experience has changed.

I expected to spend way more time re-learning things I had forgotten, and while I did have to look up a bunch of things, those were mostly minor details like import paths or parameter names, which were trivial to check³. The overall structure felt just as intuitive as it did when I spent my days with it.

It's hard to tell how much of this comes from ingrained habits, but I think it does speak to the quality of the API. Just like UI, a good API should stay out your way. You might need to spend some time to learn it, but once you know it, you barely notice it anymore.

Also, no matter how good the docs are, sometimes it's quicker to just check the source, which I did a few times over the last weeks. I've had to dig into some library code to understand what was going on many times, and django's source is easily one of the cleanest codebases I ever explored⁴. I learned a lot from it back in the day, and it's still a joy to read.

The right tool for the job

While I wouldn't call it bloated, django can feel overkill for some things. I've been meaning to adopt a more minimal approach for most of my computing, which is why this blog runs on pelican.

But if I have to deal with a database, then fuck it. Knowing I can generate an admin interface with a couple lines of configuration has spoiled me. Hell, I'll throw together a few models and run the admin locally rather than use a spreadsheet. People call me crazy when I tell them this, and they're probably right. But I haven't used a spreadsheet since high school and doing things this way is actually less work than learning how those work again. With a nicer interface to boot.

I'm still half looking for an excuse to use some intermediate framework like flask or bottle. But for the tool I'm building, I knew right away django was the perfect fit.⁵

The long road

In the world of web dev, 20 years ago is prehistory.

Django was already stable and had been for a while when I first learned it back in 2013. You know, back when code was written on clay tablets and the cloud belonged to pterodactyls.

In an industry so obsessed with chasing the latest trends, the fact that it is still relevant is frankly refreshing. I don't follow the news much anymore, but from what I've gathered, the framework is still popular, but seems to stay out of the hype cycle. It's old tech by now, just as reliable as it's always been, quietly evolving without making a fuss about it.

I'll take this over shiny new crap any day. Here's to hoping this old workhorse will still be around in 2045.

Should you use Django ?

I dunno. Use what you want. I don't care.

But if you do, you'll get a pony.

From early 2014 to late 2019. ↩
It's just a pretty simple CRUD app, nothing fancy or complex, but it's still closer to a "real" website than a quasi-static site with a single db table. ↩
I remembered the documentation being pretty good. It still is. ↩
Python helps a lot with this, and definitely deserves some of the credits. But still. Most of the python code I've read was pretty clean, but not as clean as this. ↩
In fact, it could have been another quick admin job and finished in a day. I decided to build a nicer frontend for it and use this as an excuse to learn more about htmx. And got distracted fooling with fun stuff I don't really need along the way. ↩

Markdown + Lilypond = ?

2025-07-22T22:00:00+02:00

I've heard of lilypond¹ for a while now and never gave it much more than a passing look. It seemed pretty cool, but I just never really had a need for it (I barely interact with sheet music, much less publish any).

Thinking it could get handy if I ever write another music article which involve writing down some tab², I started to think now might be the time to finally look into it.

A reasonable workflow would be to simply use lilypond to generate the tablature / sheet music I want as an image and include that in the article, but I'd rather be able to type the source right in my markdown post and have it generate the image on the fly. I'm lazy, and switching gears annoys me fast (I'm slowly getting used to taking the time to resize regular images before I publish something, but I still loathe it). I don't want to add another step to my workflow, especially not for something I might want to edit as I go.

I started to look for a markdown extension that could let me integrate it with pelican, and was suprised to find very little³. I found some stuff to highlight lilypond code, which is not what I want (although ironically it would be handy for this very post), and found an article about doing something similar, but with different tools.

So I thought, how hard can it be to just write this myself ?

So here we go. I can type this (most of it is straight from the lilypond docs):

!!!
\paper {
    page-breaking = #ly:one-page-breaking
    make-footer=##f
}

upper = \relative c' {
  \time 12/8
  \key e \minor
  \voiceOne
  r4. r8 e, fis g16 b g e e' b c b a g fis e
}

lower = \relative c {
  \key e \minor
  \voiceTwo
  r16 e d c b a g4 fis8 e fis g a b c
}

\score {
  <<
    \new StaffGroup = "tab with traditional" <<
      \new Staff = "guitar traditional" <<
        \clef "treble_8"
        \new Voice = "upper" \upper
        \new Voice = "lower" \lower
      >>
      \new TabStaff = "guitar tab" <<
        \new TabVoice = "upper" \upper
        \new TabVoice = "lower" \lower
      >>
    >>
  >>
}
!!!

And get this on the generated page:

So hurray, it works.

It's far from done, though. I'll probably throw the code on github when it is, but right now it's an awful mess, so I'll keep it to myself until I clean things up.

Shenanigans

The overall process was pretty straightforwerd, but I got some troubles with python's ElementTree library (which I use to parse the generated svg code and insert it in the page html) which made a mess because of the way it handles XML namespaces.

I barely know anything about those, and was not interested in the slightest in learning more about them. I wasted a couple hours on this, and came up with several solutions (including skipping messing with the XML tree altogether and just spit out the raw source), but I'm still not sure which one I actually want.

This pissed me off enough to stop here for today, though, so I'll look into that later.

Integrating with lilypond was dead easy, though.⁴ I kinda wish it could write its output to stdout, which mould save me from writing a temporary file, but hey, that's not too bad.

Roadmap to 0.1

As I said, there's quite a bit left to do for this to be more than a quick hack and turn into something potentially useful:

Cleanup the code and decide how I want to handle the xml shenanigans I mentioned above.
Decide on a sane syntax for the markdown blocks that will contain the lilypond source.
I've used simple !!! delimiters from the markdown docs exemple, but this is bound to conflict with something else. This shouldn't be too hard, but better to think a bit and be reasonably certain I don't pick something that might already be taken by something else.
Which output format should I use ?
Right now I'm generating svg, but png could be just as nice. I don't know. Making this a config option seems easy enough, but I can already see some of the complexity handling several formats will cause. And whatever I can see right now is probably just the tip of the iceberg.
What to do with the generated file ?
Due to the way lilypond works, I have to dump its output in a temporary file which I then read to stick its content straigth in an img tag's source attribute. I could see keeping the file around being handy though, especially if switching to png. But then, how do I know what to name the generated file and where to save it ? What if I'm using this several times on one page ? This will probably require some way to pass options right from the markdown block, and involve parsing those.
Lilypond (or maybe this is just the regular svg format ? I barely know anything about that one either) seems to include some color information, which is nice, but breaks when I switch the color theme. I added a quick css hack to handle this for now, but I'll have to see if we can get rid of this information (png file should not have this problem, though).
Right now I'm having to include a directive to tell lilypond not to output a full page⁵, which it does by default. This is annoying, as I'm probably gonna use this for short snippets and I'm likely to forget the syntax, so I'm tempted to insert this directive automatically. This may not be what a potential user expects, though, so do I add another option for this ? And if I do, how do I handle cases were several pages are generated ?
I'm already noticing pelican is being slower at generating the blog. I should cache the output and avoid regenerating the whole thing when the source hasn't changed since the last time.
This seems like the easiest issue to handle right now, so that's probably the first one I'll do.

Most of those points aren't really technical, but rather part of the overall tool's design. Designing a good API is hard enough to begin with, but it's even worse when dealing with stuff I'm not really used to, and even more when I'm not even sure what I want yet. This is making me lean quite hard on the "keep things as simple as possible" approach. So this extension is probably not gonna be very configurable for a while.

First impressions on Lilypond

Honestly ? I don't know. I barely looked at the source I used to test the code. My thinking is to make sure the general idea works, and learn to use it later.

It seems pretty complete, though. Maybe too complete for what I need. But hey, I figure learning the basics can't hurt. I can always ditch it if I find some simpler tool.

A quick digression about Markdown extensions

For some reason I've been enjoying writing markdown extensions quite a bit over the last two weeks. So far I did:

An extension to generate a link to a django model, using its get_absolute_url. It's cute and was fun to do, but I predict I won't have any real use for it. Oh well.
Another one to generate an hx-ref attribute on all links. Dead simple and useful if dealing with htmx.
Yet another one to automatically add some atributes to HTML elements. This one is on github, and I'm using it on this blog to autoamtically add a loading="true" attribute to all images.
I'm thinking of another one to auto generate a slugified title for headings. Addding those manually is exactly the kind of tedious crap I'd rather avoid.

And now this lilypond thing.

I don't know why, but something about parsing fascinates me. I barely get to insert some code in the middle of the general tree processing here, but I dunno, this feels nice to do. It's easy, but it makes me feel like I understand something about how languages work.

The python-markdown's API to write extensions is pretty simple, too, so that's nice.

Alright, off to go grab a drink now. I'll make an effort to clean up the code tomorow, but after that I'll probably try and use the damn thing and learn more about lilypond before I get any further. I'll post another article if this thing gets nice enough to share.

So long, interwebs!

Hi, Flo! ↩
I got away in that one with using simple code blocks and writing the tabs in raw ASCII, but this could get unwieldy and hard to read for anything more complex. ↩
This might be due to just how awful search engines have become... I'll spare you the rant about trying to find some technical info on pretty basic problems, which I run into every other day. ↩
"Integrating" is kind of a big word here. I'm just calling the CLI tool as a subprocess with the right options. ↩
The \paper lines in the exemple source above. ↩

MarkyPond out on Github

2025-07-24T19:30:00+02:00

Kept hacking on my lilypond markdown extension which is now out on Github.

I called it MarkyPond, as it sounds kinda cool, doesn't seem to be already taken, and evokes both markdown and Marky Ramones.

It wasn't hard, but boy was it tedious.

Lots of string juggling, which python is pretty good at, but complicated by the Lilypond command line tool¹. Painful refactoring due to a brittle test suite (because of a mix of me trying to be too clever and mocking being such a PITB).

I'm not too happy with the code quality, but hey, it's done, and it does what I want it to.

It now supports outputting png:

svg (as before):

And pdf:

I may need to re-think the html integration on that one.

Hmm. I can already see I'll probably need to copy some information in each block, which will become a pain quickly. Glancing at the lilypond docs, I saw things that looked like you can include other files, so I'll probably have to add some option to handle this.

But not now. I need to use the damn thing before I start adding stuff that tries to be helpful but creates more of a mess.

Along the same idea, I won't bother supporting more output formats for now. I don't even remember which ones lilypond handles. Some of them might be easy enough to add, but again, if I start messing with it before knowing more about the way it all actually works I'll just end up with chaos.

Fun with caching

I mentionned in the previous article that the processing was too slow. I solved that by generating a MD5 hash of the lilypond source², which I then use as the generated file name. Then, it's a simple matter of checking if that file already exists before generating a new one.

With this, the time pelican takes to regenerate the whole site went from almost 2 seconds (for only two, one bar long each exemples!) back to about 0.3 second.

I end up with ugly file names like 502a317d29de43443f02f6372e4dd430.png, but I don't care, as I'm only using the file for a link. I can see how it could not fit some other use case, but again, I'd rather keep this suited to my immediate needs for now and I'll need to know more before I try to solve problems I don't have yet, so I was quite ready to just call it a day.

But then I realized that this would lead to a proliferation of unused files as I keep editing the lilypond source of an article. With each change, the hash changes as well, and a new file is created, with no simple way to know the previous name (so I can't just automagically delete it).

So after a dozen edits, you end up with eleven useless files and have to check the final name to know which ones you have to delete. And also be careful not to delete any file that was used for another article. Great.

This won't do. I need to find a way to name those files in a sane way.

What's my name ?

The trouble with naming the files is that I can't automate it. I could think of some scheme to generate a default name for each one, but once I'm called by the markdown parser, I get exactly zero information about the current file being processed³. I couldn't even find information about the html document. The only thing I get access to is the node that will contain the block I'm generating (which doesn't seem to provide access to its parents).

Maybe I'm missing something, but for now, I'm kinda screwed.

So no way around it, I have to add a way to pass arguments to the markdown block itself.

Again, this is not really hard to do, but it's pretty tedious and requires more testing. And hey, now that I had to do it anyway, might as well go ahead and add a few more arguments to override the extensions's basic configuration.

So that's what I did. And now the syntax looks like this:

{markypond output_file='/subfolder/lol.pdf' output_fmt='pdf'}
mynotes = {
  g,2 g\4 | des1
}

<<
  \new Staff {
    \clef "G_8"
    \omit StringNumber
    \mynotes
  }
  \new TabStaff {
    \mynotes
  }
>>
{/markydown}

So. That's done, I guess.

This was an enjoyable hacking mini project, but tidying things up, writing tests and documenting the whole thing⁴ took a while and sucked most of the fun out of it, and I'm getting a bit sick of coding right now.

Which is good, as it means the next article won't be yet another piece of tech wank. I'll try and use the damn thing a few times and we'll see if I come back to it when I know what I'm doing.

See ya!

Post Scriptum:

So I wanted to add a subtle tip of the hat to Ozzy Osbourne by adding titles to the generated images. Which doens't work. Great. One more thing to debug.

So here's a funny picture instead, subtility be damned.

RIP Ozzy.

The tool "helpfully" adds the extensions to the files it spits out. So I had to remove it from the argument I get before calling it and add it back afterwards. Nothing crazy, but annoying all the same. ↩
I saw it done in an article I read when researching the initial idea, so it felt obvious once it became needed. Not sure if I would had thought of it otherwise. ↩
Pelican does pass the article metadata to the parser, so I could use that. But then this extension would only work with Pelican. ↩
The doc is pretty terrible right now, but hey, at least the info's out there. ↩

Don't post when you're pissed

2025-07-25T23:00:00+02:00

So yesterday I published an article about a markdown extension I'm fooling with.

I mentionned how tedious tidying things up was, and I was honestly getting sick of the whole thing.

Coding is solving problem after problem. About half of those problems turn out to be pretty fun.¹ Some of them might drive you crazy for a while, but the feeling you get when you finally get it makes you look back on the whole ordeal with a sense of understanding and accomplishment that I truly enjoy.

The other half consist of tedious and annoying crap you don't care about mixed with random things that break because everything is a mess and computers are so dumb.

What I'm getting at is that there's a point when you should just stop for the day if you don't want to turn postal.

I didn't though. The thing was so close to done, and I feared letting it get out of my head. If I stop now, I'll have forgotten half of what I still have to do by tomorow and finishing this will be even more of a pain, I thought.

So I pushed through. Publishing a first, half decent draft on github and writing an article about it would feel like a milestone, and would allow me to move on to something else, clear my mind, while still feeling like I had done something of the last few days.

As I got started on the article, I had to deal with a whole new bunch of tedious little things. Looking for images, resizing / compressing them, getting the source for various links, proofreading... Nothing too bad, but I was already fried for the day, and I was getting more and more pissed as I took care of them.

And then as I was almost done, I tried to add a title to one of the generated images, thinking it should just work. It didn't, and the whole thing broke down.

I took a quick glance at the code and saw that I wasn't gonna be able to fix it right away, so I changed my plans and pushed the whole thing out, and immediatly went out for a couple of pints.

Woke up this morning and after getting annoyed at Microsoft², I took a quick look at what was broken, and saw what was causing the problem. No idea about how to fix it, though. I had some things to do that morning, so I went out and did them.

When I got back home I looked at the code again, re-read some docs and realized I had misunderstood a concept from the markdown library and used the wrong tool for what I wanted to do. I dreaded refactoring the whole thing, but got started tweaking a few things to see what would happen.

A couple of hours later it was all done. The test suite that was driving me insane the day before caught every little error I forgot to check. The new structure was simpler and cleaner, which allowed me to spot things I could further simplify, so I did that.

I tried the title thing I wanted to do on the previous article. It worked seamlessly.

That milestone thing I described above wasn't necessarily a bad idea, but man. Had I waited a single more day, both the code I pushed and the article I wrote would have ended up so much better.

I've known how pointless it is to push through something when you're too pissed or tired to focus anymore for a while now. I've experienced it with coding, music, and pretty much anything I ever took seriously enough to care. I like to think I'm able to see it coming and I often manage to catch myself and stop when I reach that point.

But then a bad day comes, some random frustrations accumulate enough and I fall for it like an overzealous rookie. Guess I still need a few lessons to truly get it.

Well. Live and learn.

I'm still gonna avoid writing about overly technical things for a while though. Those can be fun and interesting, but I'd like to focus on some other things. I have a few ideas in mind, but I also feel like allowing myself a few random, casual posts like this one now and then. You know, like on a blog or something.

Those still get the job done as far as working out the writing muscles, and it's a nice way to reflect on stuff. Which is the whole point of blogging, right ?

So long interwebs. Don't post when you're pissed, and touch some grass, as the younglings say.

It's a special, slightly masochistic version of "fun". But still. ↩
That's another story, though. And no, I'm not running windows. ↩

Microsoft is stealing my vimrc

2025-07-28T22:20:00+02:00

TLDR: Backlash against the AIfication of all the things is good. Legislation around those issues is sorely needed. But we should be careful not to simply shift the balance of power among the already powerful. Whoever wins that war won't care any more about the commons that its predecessor.

A week or so ago I set up a forgejo¹ instance to host my git repositories.

The main idea was to use it for the few private repos I have and ditch the old bitbucket account I've been using for those.² I pondered the idea of moving all my stuff there and leave Github behind too, but that's trickier.

It's like social media. Everyone is on Github, so it's hard to go elsewhere for code you intend to be public. None of the stuff I have on there is of much interest, but still, what if someone stumbles upon it and feels like suggesting a fix or report an issue ? I don't want to open registration and manage random users on my private instance (nor to force people to create yet another account if they feel like contributing). But if I'm gonna pass up on the chance to get feedback, why even bother opening my source ?

I know there are cleaner, non-profit, FOSS and what-have-you alternatives for this. I'll explore them, but in the meantime, I figured I'd just leave the public things on Github. I can still change my mind about this later on.

Still, I moved my dotfile³ repo to my new forge because why the hell not.

Spot the Bot

I woke up friday morning, grabbed a cup of coffee and sat at the computer. I had published my last article on the previous evening, so, wondering if it had gotten some traffic, I glanced at my logs⁴ and was greeted with this:

Some bot was crawling my config files as I watched. I could see each new request pop up, one every second. I could almost hear it go "Tick, Tick, Tick".

It was apparently going through the list of issues and pull requests for the repository... Of which there are none whatsoever. I guess the spider expects a different arborescence and got stuck in a loop.

Who the hell would care about this crap ? I looked up the IP and found it was owned by Microsoft.

So.

Microsoft owns Github, which gives them access to most of the open source code out there, which they use to feed their Copilot AI. Apparently that's not enough for them, so they go and crawl random forges hosted elsewhere. Sigh.

I banned the IP and moved on.⁵ Later during the day, I spotted the bot again, using a different IP (this one was trying to access some non-public pages and kept being redirected to the login page). I banned it too.

I'll give this to them: resources wise, one request a second is nothing. I read about LLM crawlers DDoSing small servers, which is not what's happening here. So at least they're not burning down this house as they steal the furniture. I haven't set up a robots.txt for the forgejo site, and I half wonder whether they'd respect it or not. Given that the IP has been reported as abusive, I have my doubts. And even if this bot does, many others don't.

This is a bit depressing.⁶ These crawlers are the reason why you can't access any site without having to demonstrate you're not a bot these days. On top of the adds and cookie banners, it's yet one more of those constant interuptions that make navigating the web infuriating.

I'll look into solutions to try and detect those bots and ban them automatically, but it pisses me off to even have to think about this for such a small website.

We're not talking about script kiddies or villainous hackers here. Those are perfectly legal and legitimate businesses that, non-content with having ruined everything they could on their own land, are now treating the rest of the web as their data mine. If you enjoyed technofeodalism, you'll love colonization 2.0.

Impact on self hosting

My ideal web is one where everyone would self host their stuff, and while I realize this is probably still unrealistic, real progress is being made on tools to allow less-technical people to manage it.

Dealing with misbehaving crawlers is yet another hurdle that many won't be able or want to deal with. And automated tools are bound to consume more resources.

Today, an old machine with 2Gb of RAM is more than enough to host a simple static site like this one (assuming you're not aiming for millions of daily views, of course). If everyone suddenly needs to protect themselves from unwanted bot traffic, the machines will need to get beefier, and recycling your ten years old laptop or getting a cheap Raspberry PI might not suffice anymore.

Infrastructure provider Cloudflare is now blocking those crawlers by default and proposing a pay-per-crawl fee to remunerate the scraped sites (assuming you use their service, of course). It sounds like a good idea on paper, but all I'm seeing is a giant red flag.

I don't really know anything about Cloudflare, but their wikipedia page claims they're fronting almost 20% of all websites already. Which is enormous. Whether or not the current direction can be trusted not to mess with things doesn't matter at this point: letting one company take up such a central position can only be bad news.

They have everything to gain from standing up against the AI bots, and the small web has everything to lose from relying (ie depending) on them for protection.

This leaves us self hosters to roll up our own protection, which, again, is an additional cost and barrier to entry (both monetary and technical). So that sucks.

I'm no sys admin, so I don't really know what's available. I'll investigates WAFs and see if something interesting comes up. Anubis seems to be popular and efficient, but I'd really like to avoid anything that affects regular readers.⁷

Copyright won't save us

Source: Mimi & Eunice

A lot has already been said about the problems those AI crawlers pose regarding intellectual property. I happen to think that the current copyright system is an abomination that should be revised from the ground up, and I have little hope the conversation will even entertain the idea of actually fixing it, so I'm wary of this line of defense.

About a month ago, Disney and Universal sued Midjourney over this. I haven't followed the reactions, but I don't think we should cheer them on. I certainly don't mind if Midjourney gets knocked down a peg, but seeing those giant leeches cry over their IP when they already own everything makes me sick.

They're not out to champion the cause of the smaller creators who actually suffer from this situation. They're only in it to maximize their own profit, and should some legislation come out of this, it will only reinforce their own power. Independant artists might benefit in the short term, but the best they can hope for is maintaining the status-quo.

The AI companies' argument that their unsolicited use of material to feed their machines falls under Fair Use is bullshit. But Fair Use is still an important aspect of copyright law, that right owners happily disregard when it suits them, usually with complete impunity. Weakening it further can't be good in the long run.

It's tough. There's no good guy in this story. Even though the system sucks, it may help prevent or slow down the pillaging of actual, valuable work. But this system is already used by the bigger players to shut down criticism and enforce censorship. As we drift ever closer to an authoritarian dystopia, I'm not sure we stand to gain from strenghtening property rights even further.

In the end, it's a battle between giant corporations. Whoever wins will just take all the spoils. Our interest might align somewhat with Disney's right now, but let's not fool ourselves into thinking they're fighting on our behalf, and let them get away with new ways to control ever more media.

Allright. This started as a quick little rant and grew some legs as it went on. A lot of what I said is based on gut feeling and pre-existing opinions. I don't think anything's blatantly false, but I haven't truly researched most of my points and some of them may be a bit hazy. I'd better stop here and keep to first impressions rather than try to go more in depth and risk making a fool of myself.

Also, talking about business models, policy and all that grown up crap in English is definitely not my forte. I hope I managed to get my points accross without sounding too simplistic.

At any rate, I found this EFF article while looking for links that sums up the whole AI crawlers situation much better than I could.

So long. I promise the next article won't be about tech.

A fork of gitea that claims to be "more free" than its upstream. ↩
Private repos used to be a paying feature on Github. Bitbucket had a different pricing strategy, so I went there for those.

Ten years later I just get annoyed at managing two different accounts and I'd rather keep that code to myself anyway. ↩
Linux systems config files tend to be simple hidden files scattered in your home directory. Under Unix, hidden files are indicated by a dot prefix to the file name, like .bashrc. Hence the "dotfiles" nickname.

It's common practice to store those in a Git repo so that it's easy to retrieve when you set up a new machine and keep a log of your changes (useful when you can't remember why in hell you changed some random bit years after the fact). ↩
I haven't setup analytics for this site. Still looking for a simple enough and self hosted solution, but that's pretty low on my todo list. So for now, I just look at the server logs when the itch to see what's going on start scratching. ↩
Ain't no better way to start the day than reading firewall docs. ↩
And ridiculous, too. My dotfiles repo is still on Github, so they're scraping code they already have. Also, it's freaking config. Personal tweaks tailored to the way I like to use my tools. This has to be the least interesting thing to feed an LLM with. ↩
It's much better than a regular CAPTCHA, but still. The small delay it incurs is exacly the kind of small annoyances that add up fast and end up ruining the whole experience of surfing the web for me. ↩

Getting started on the mandolin

2025-08-01T15:30:00+02:00

A few months ago a friend of mine lent me a mandolin.

I had been meaning to try my hand at the instrument for a while now, and even bought an old silvertone for cheap which, while pretty, showed up with an action so high it was almost unplayabale. So predictably, I didn't stick with it and it's now gathering dust alongside the couch.¹

My friend's is only slightly less pretty, and most importantly, it plays like butter and stays in tune pretty well, so this time I've been much more diligent.

Since it wasn't that long ago, I remember the process I went through during the first few hours I spent with it, which got me to improvise simple things after less than a day's work, and I thought it could be interesting to describe it here.

I'm not trying to show off or even pretend I'm halfway competent yet. Honestly, I still suck at it. My intention is merely to demonstrate how applying a few basic harmonic concepts can speed you up when getting to know a new instrument.

Also, keep in mind that even though I was new to this instrument, I've been playing guitar for more than twenty years, which obviously helps tremendously with the mechanics. I've also had almost as long to internalize the theory I'll mention below. It took me a while to understand and memorize those concepts, and even longer to learn to hear them. My hope here is merely to show you how useful knowing that stuff can be.

So I've learned the major scale, now what ?

On the few occasions I had had to fool around with a mandolin before, I had deciphered and memorized the G major scale.

Learning a scale is an important step, but once you're done memorizing the pattern, it's not obvious what to do with it beyond running it up and down, which stops being fun after about two minutes. Figuring out how to turn that scale into music takes a while, and experimenting is not that easy if you have no idea where to start.

So my first impulse was to spot my arpeggios². I started with the one chord (ie G Major) and stuck to the lower two strings to get started.

Without delving too deep into theory, the way to find those is to simply count the notes as you play your scale, and isolate the first, third and fifth notes from the pattern. Once you found those, keep running the scale until you hit the root again (in this case, G) and add that note to the three you just singled out to round things up:

As a guitar player, finding the major third was a no brainer. Frets work the same way, so I didn't have to think to know it lied 4 frets (2 whole steps) up from the root (here, the open G string). Having the fifth on the next open string didn't feel so natural³, though, so I spent a few minutes playing the arpeggio up and down, alternating with the full scale for reference.

Once I got it under my fingers, I could play simple lines like this:

I'm fancying it up slightly with hammer-ons and pull-offs, but really all I'm doing is emphasizing the notes from the argeggio, using notes from the scale as passing tones and reaching for the root when I want things to resolve.

Bluesin it up

As a bluegrasser, I immediately wanted to dirty things up. Luckily, I already knew how to do just that.

Since I had already located my major third⁴, I only had to lower it by one half-step to switch to minor and get that sweet, bluesy feel. Resolve it back up to the regular third or down to the second, and I'm good to go.

In the same vein, lowering the root note by one full step will land me on the minor seventh. A nice trick is to get there chromatically, which tends to sound pretty cool. Check it out:

Switching chords

So, now that I'm on the seventh, my ear really wants to go to the IV chord (C in this case). I also know from experience that going down one more half step will yield the third of that new chord (you can hear me hang on it in the last exemple).⁵

But what then ? I have no idea where the C chord tones are on this new neck.

So I just stopped, went back to the full scale and took the time to spell it out, as I did for the G chord. which gave me this new pattern:

Again, I played it slowly a few times over, making mental notes on where the new root was⁶, and also the third in case I want to mess with it as I did on the G. And then I went back to fooling around.

Apart from my lousy timing, you might notice that I went ahead and played over the D chord as well. Since I had already spotted the scale's fifth note and noticed it was an open string, I simply moved the G arppeggio up one string and played around that. It could have gotten me into trouble had I tried to add more notes to it, but sticking to the chord tones was pretty safe (I still added a sixth in there because sixth are sweet).

So am I a mandolinist yet ?

Hell no. Far from it.

I've kept with the process I just described and included the two missing strings, and I can fake my way for a few bars on simple 3 chord songs, as long as they're in the key of G or D. If the song doesn't stick to a I IV V harmony, then I might get by if it's still diatonic, but forget about outlining the progression.

And that's about it.

The C arpeggio is still giving me trouble, as its shape is different enough from what I'm used to to trip me up. I've looked at closed position scales, and while I "get it" on a surface level, they feel foreign and I get lost at the first chord change.

There's still a long way to go, is what I'm getting at.

But it's nice to know what I don't know. It'll take a while before I actually know what I'm doing, but with the help of those basic harmonic notions, I can at least pinpoint what I need to work on.⁷

If all that number talk sounded like giberrish to you, sorry. If you learn how to build chords from the major scale, then it should all start to make sense. Juggling with those numbers and getting used to thinking with them takes some practice, but it's one of the first things you'll tackle if you ever decide to study harmony.

This is of course not the only or even right way to go about it, but it's mine. Some people are able to figure that stuff out entirely by ear. Not me, though. I needed to be able to put a name on things before I could make sense of them.

I barely use anything more advanced in my day to day, so hopefully I've shown how far a little understanding can get you.

Time to get rhythm

As I said, I went through that process a couple months ago, and I haven't delved much further as far as melody goes.

I switched my attention to chords and playing backup. Being able to contribute to the general groove is more important and that's what you should focus on when starting out.

Having joined a polish folk band in the meantime definitely helped make this a priority.⁸

It's slowly coming together. Again, I'm keeping things simple and focusing on simple triads, trying to memorize and make sense of the various inversions and fiddling around until I stumble on something that sounds decent.

Again, knowing how chords are built and what an inversion even is helps a lot. I still have to get the shapes under my fingers and develop an understanding of how they're all laid out on the fretboard, but at least the tidbits I stumble upon make sense.

Allright, time to stop and go woodshed a bit. Rather than a thinking up a coherent conclusion, I'll just throw a crappy picture of this article's main cast instead.

On the left is the old silvertone that I can't play. The one you heard in the sound samples is on the right.

See ya, and happy picking!

I'm sure a good setup can help, but I have my doubts it can do wonders. Old instruments don't always age well and sometimes there's just not a lot you can do to bring it back up in shape, short of rebuilding the whole top or some other huge operation which would cost more than the original indtrument..

I'll still look into it, but I'm putting it off for now. ↩
The notes that make up each chord. Those come from the scale you just learned, but each chord will be made up of a subset of those seven notes. ↩
Although my guitar reflexes tended to land me on the sixth, which I love to overuse. So as long as I know how to resolve it, that mistake can actually sound pretty good. ↩
Fourth fret, fourth string, in case you forgot. ↩
Again, those are just classic moves I picked up and internalized over the years and that I'm blindly applying to this new tuning. ↩
Fifth fret, fourth string. ↩
And that's just knowing my way around the fretboard. Being able to transpose my pre-exising guitar technique is a huge boost to get started, but I can feel the wood's not reacting as I expect it to. There's still about a billion things I'll need to adjust to make it sound right. ↩
I showed up at the first rehearsal barely able to play the basic bluegrass chop chords. The fiddle player had to show me how to play minor chords, as the chop version of those was too much of a stretch.

I was clearly the beginner in the room, which honestly felt pretty fun. I've struggled quite a bit (still do), but it forced me to take things more seriously, and what little progress I made since then feels all the more gratifying. ↩

Half-assed banjo tuning

2025-08-29T21:45:00+02:00

About a year ago, I started using a banjo on a few tunes with a duo I'm currently playing in. We're both guitar players, and I was really missing some timber variety after our first few gigs, so I figured some simple clawhammer could make for a nice change.¹

Now banjo often requires the use of a capo, which in turn requires adjusting that damn 5th string. Nothing like an out of tune drone to ruin everything.

Up until now, all the songs I use it on have been in keys that allowed me to simply ignore the problem and leave the drone as it was, but yesterday we started working on a tune in A, and that constant ringing G was just awful. And since my friend plays the song on a diatonic accordion², we can't simply switch it to C or G.

I know many people would simply tune the string up to A. It's only one step, so it should be fine, but not being that familiar with the instrument, I'm still wary of messing with the tuning directly. I tried it anyway, and found out the string didn't hold its pitch. It would sound fine for few bars and quickly drop down to some random note between G and A, which was even worse than simply leaving it untouched.³

I got away by tuning the drone down to an E. It worked, but the drone got lost in the overall mix, which kind of defeats its purpose.

I got home and cut up a pen cap to turn it into a fifth string capo. It's not great, but it does the job for now.⁴

Unexpected harmonies

This reminded me of something interesting that happened when I first started incorporating the banjo into the set.

Out of the five tunes I already (try to) frail on, 3 of them are in good old G, so no problem here. Another one is in D minor, which I play with a capo on the seventh fret,⁵ so I can simply grab the fifth string along and not worry about it any further.

The last one is in E flat, though. It's a cover of Mississippi John Hurt's Pallet on your floor, and the key was chosen to fit my voice. I already played it on guitar out of C with a capo on the third fret. As I got started trying it on the banjo, I fully expected that drone to sound awful.

But it didn't.

Turns out the G is the third of the scale, which sounds less neutral that the tonic or the fifth but is still part of the chord and opens up the overall sound. I don't think it would fit any tune, but here it works just fine.

The real magic happens on the IV chord, though. I think of it as an F, but it's actually a A flat. Which means the G drone is now the major seventh of the current chord.

I have a kind of love/hate relationship with major senventh chords. They can be beautiful, but they can also make for the cheesiest sounds I can think of.

I read some introduction to jazz years ago that basically recommended turning every major chord into a 7th,⁶ which horrified me. If the mood you're aiming for is easy-listening soup, I guess that's a good way to go, but otherwise, this approach make me want to puke rainbows.

I had noticed a while ago that I tended to like them better when they fell on IV chords, though, which is exactly what's happening here.

Have a listen. Here's a version of the melody using my makeshift, pen cap capo to raise the drone to a B flat (ie the fifth of the scale) (sorry for the dead strings tone. Getting a fresh set is high on my to-do list, but it ain't here yet):

Hear what I meant when I said this version sounded kind of neutral ? That's not a bad thing. It sounds fine, really, and there wouldn't be anything wrong with choosing to play the song that way.

Now here it is without the capo. I tried to emphasize the drone to make it a bit more obvious and sang a chorus to hear the harmony in context.

I just love the color the tune takes with the second version, which happens to perfectly fit the John Hurt mood. The first one almost sounds bland in comparison.

(Also, note the sixth on the V chord at the end. That's another harmonic color I love (and probably tend to overuse, to be honest)).

Embracing mistakes

The reason I like this arrangement so much and felt like writing about it is that it happened entirely by accident. Remember: I just slapped on the capo, noticed the fifth string wasn't tuned "properly" and went for it anyway, despite being convinced it was going to sound terrible. None of the harmony shenanigans I described above were planned. They were just the result of what was technically a mistake, and I only started to figure them out after noticing I liked what I was hearing.

Had I had a decent way to deal with the drone handy, I might have just set it up "the right way" and would never have thought of fancying things up.

It is often said that many great ideas are born out of mistakes, and I'm still amazed at how true that saying is. Most, if not all, of the lines I'm proud of came out of me messing something up. Landing on a note ouf the key. Playing the wrong chords. Hitting an unwanted string that "should" have ruined a lick but didn't.⁷

The more it happens to you, the more you realize how pointless it is to worry about screwing up. Sadly, building up the confidence to truly get rid of that fear is still a long way ahead. But each new fumble hopefully gets me a little closer to that goal.

That's what they mean when they say there are no wrong notes. So if there's one thing to learn from this story, here it is: mess around, try random things and embrace falling flat on your face. I know that's easier said than done, but this is how you'll grow.

Learn to notice when something cool turns up among the noise and enjoy the ride in the meantime.

While looking up the name of the sawmill banjo tuning, I stumbled upon this website. If you thought Jimi Hendrix playing with his teeth was impressive, wait until you meet Fred. I wish this had been captured on video.

Oh, and one more link while I'm at it. Mentionning and playing pallet on your floor made me want to hear it again, and I found this version. I forget why, but my initial reaction was a pretty strong "meh". 20 seconds later I was in love. I'll definitely check those guys out.

See y'all, keep picking, and enjoy every mistake you make !

The nice thing about banjo, especially clawhammer, is that you really don't have to do much to get a nice texture. A dead simple bum-ditty rhythm can be enough to add a whole new dimension to a tune. ↩
Yay! Instant Cajun! Now that will stand out from the rest of the set! ↩
Maybe the string is just too old, or installed incorrectly. I'm sure it's a simple fix, but right now, the only thing I know for sure is that I can't depend on it. ↩
I read online about doing the same thing with guitar bridge pins:

This sounds like it should stay in place a little better, and you can buy cheap ones for about 3 bucks a six-pack. I'll order a few and try it out. ↩
I do retune for that one and raise the B string up to a C to get that appalachian modal feel. That's called sawmill tuning, and it's a pretty sweet sound. ↩
Keep in mind I'm talking about the major seventh here. Blues players do stick a seventh everywhere too, but they go for the minor / dominant one, which is a very different sound. ↩
I vaguely remember turning a waltz into 4/4 simply because I hadn't noticed the signature. The band went along and the song is still my favourite from that set.

Can't say anyhing else ever came out of my awful sense of timing, though. Sigh. ↩

Where the hell is Patrick Costello ?

2025-08-30T17:00:00+02:00

While writing yesterday's article, I was bound to remember the days I first got interested in clawhammer banjo, a little more than ten years ago.

A friend had told me about a youtube channel that did a good job explaining how that whole thing worked, so I checked it out. The channel was Patrick Costello's, and I instantly liked the guy.

I liked his playing and tone, simple and to the point. I liked his overall demeanor and friendly attitude. I liked his philosophy and approach to music. And I loved how straightforward his teaching was. He had a real knack for demistifying whatever he was demonstrating, emphasizing the importance of mastering the basics while making it all look like you'll get it with just a bit of practice.

This was still old school youtube. No lighting or fancy editing, just a nice and down to earth guy with a cheap camera and a genuine drive to share what he loved.

Everything I know about the banjo came from Patrick, and he taught me a few deeper lessons about music as well.

Talking about him in the past tense makes this all sound like an eulogy. Thankfully it's not. At least not as far as I know.

I wanted to link to his lessons in my last article. But I couldn't find his old channel. I dug around a little, and found out he had deleted it. His old website is down, too.

Apparently he was quite a controversial character in the online old-time music community. I remember he would often mention the "purists" crowd in his video. I don't remember him making much of a fuss about it, but it was obvious he'd seen a few flamewars.

I didn't really pay it any mind. This was the internet. Of course an opiniated guy would get dragged into a nerd fight now and then, and we already knew how silly and blown out of proportions those could get.

From what little I gathered yesterday, members of various communitites seem to have a different story. They paint him as a man craving for attention and constantly starting fights over the slightest bit of criticism. To the point of getting banned repeatedly from several forums.

I honestly don't care who's right and who's wrong here. I tend to stay away from internet drama and it's way too late to pick sides anyway.

The forum members do recognize the man had some serious health issues, which I remember him mentioning. Some suspect mental health problems as well. Again, I'm in no place to judge.

Well, to end that rambling story, the man apparently had a string of setbacks which culminated with his house burning down a few years ago. He announced shortly after the fire that he was "done" and deleted most, if not all of his published material.

Again, I'm not trying to pick sides, but this doesn't paint the picture of someone who's doing well.

It's apparently not the first time this happens.¹ I haven't looked very hard, but it's been three years already and I didn't find anything more recent from him. Maybe he'll be back, maybe he won't.

I won't blame him if he just stops dealing with online feuds and retires from teaching. Nothing wrong with that, and that's for him to decide anyway. But deleting everything he put out is, well, sad.

The internets can be a cruel place, but when you stumble on a gem it's nothing short of magical. The fact that some random guy, no matter what flaws he might have had otherwise, was able to reach so many people is the magic. Everything else is just banter and window dressing.

This isn't the first time I find out some thing I've liked a while ago just isn't there anymore. Sometimes it's just a silly joke or a cat picture. Sometimes it's a deep discussion about some niche topic that spanned a dozen pages on a forum thread that's no longer hosted. It always stings. And it always seems like I'm the only one who cares.

In a world where stuff from 2 days ago is already considered old news, that's not really surprising. But so much is lost in the process. We figured out long ago why archiving things was essential, but somehow this doesn't apply to the web. This is bound to bite us in the butt one of these days.

This is why places like the Internet Archive are so important.² Whch is where I found some of the books he published (under a creative common licence, another nice touch). I read one of them ages ago. I don't remember it that well but from the few pages I've skimmed, I'm confident there's some good information in there. So go read those if you want to get into frailing banjo. In the meanttime, I'll save them somewhere in case they disapear.

There's also this weirdly named youtube channel that's uploaded some of the ealier stuff he did with his dad, so there's that. I'm not sure who's behind it. I don't know if more stuff will end up on there. Wait and see, I guess.

I'm not sure what my point is with this post. I just felt like throwing a message in a bottle. I hope Patrick is doing okay and I want to thank him for the work he's done and the influence he had on me. Anything else is beyond me.

So long, interwebs. Please get your act together and try to preserve the good stuff rather than focusing on all the bullshit.

Him disapearing from the web for a while, that is. Thankfully the fires were less common. ↩
Not as important as fucking copyright, though. Sigh. ↩

Why Do The Bad Songs Always Last So Long

2025-10-08T14:00:00+02:00

According to the file's metadata, I wrote this in August 2019.

I was listening to some album or compilation (I don't remember what it was) and one tune which I didn't like dragged on long enough for me to get annoyed, which prompted the title. Thought it had a nice ring to it, and set out to turn it into something.

It really felt more like an exercise than anything else, and while I liked what I ended up with, it didn't really fit the mood of any band I was in at the time, so I recorded a quick take, archived it and soon forgot about it.

Stumbled back upon it while looking for something else and figured I might as well post it on here, as I don't really plan on doing much with it.

So here it is:

The take is quite rough and the guitar is slightly out of tune, but hey. Still like the song. The melody feels like a weird mix of French singer Eddy Mitchell and John Hartford's gentle on my mind, the second of which I'd been listening to a few days before. I remember I had to tweak the melody a bit as some part was bordering on ripping it off.¹

Here are the lyrics in case you can't make them out through my mumbling:

Listen to an old jukebox or a busted radio
In a crowded Honky-Tonk or at an empty talent show
Why do the bad songs always last so long ?
I'll listen to your tale, might even sing along
But please keep to the point, don't ramble on and on
Why do the bad songs always last so long ?

I must admit sometimes it hits and wakes a memory
Some old never-ending story that failed to make see
Why do the bad songs always last so long ?
I reckon I've heard this tune a few dozen times before
Don't let this groove drag on for a single minute more
Why do the bad songs always last so long ?

Hope someone likes it. In the meantime, that'll do for a low effort update to this blog.

See ya interwebs. Don't suffer through the bad stuff for longer than you have to.

Everytime I write something I can always spot bits from something I've been hearing not too long ago. Sometimes it's subtle, sometimes not so much. I'm usually fine with it, as long as I feel it still tells its own thing. ↩

Unsung Heroes

2025-10-18T10:30:00+02:00

Dennis Ritchie passed away on October 12, 2011. In a sane universe, people who knew who he was would have paid their respects, the news would have been relayed by the specialized press, and people who didn't particularly care about computing or its history would have never heard of it. After a week or two, everyone would have moved on with their lives.

Which is exactly what happened.

But at the time, the rest of the world was in mourning for another guy who had died about a week earlier. Celebrations went on and on for the god like figure whose gift had blessed us all with amazing technology that was nothing short of magical.

That other guy was Steve Jobs. And the whole situation pissed me off.

I'd never been a fan of apple or Jobs, but this isn't my point here. No matter what merits the man might have had, I couldn't stand the way he was constantly praised as a genius inventor¹, when it was obvious his real accomplishments had much more to do with marketting than engineering.

And then the man who designed the C language in order to build Unix, two staples of computing that are still widely used 50-ish years later and / or shaped digital history as a whole, died and what little recognition he got was lost next to the ongoing canonization of someone who'd figured out how to turn pixels into luxury goods.

Kill your idols

A classic take among techies is that Steve Wozniak should be the famous one, as he did all the real work. Praise the nerds rather than the suits. I don't agree with this.

The point I'm trying to make here is that both should get public recognition for what they actually did, and no more. Giving credit to work we find useful doesn't mean we have to turn its authors into rock stars.

I wasn't pissed because I thought the roles should have been reversed. I'm not arguing that Wozniak and Ritchie should have been the ones under the spotlight (I'm sure they are/were perfectly happy with their relative lack of public exposure).

I just wish the media would stop indulging the ones who do seek the attention.

This isn't a new problem. The focus on individuals is as old, if not older than mass media and has been discussed and criticized for longer than I've been alive. This happen in just about every domain. Art is full of this crap, too. And it's always more infuriating when it comes to something you think you know someting about.

Ritchie was a researcher who simply did his job. No more, no less. He built on what came before, and neither C nor Unix were magical masterpieces than no one else could have conceived of. They just happened to solve the right problems at the right time, and went on to leave a truly profund mark on the global evolution of technology.

Their creators then simply went on with their work. Those who care about that stuff recognized that work, and that was enough. No need to hype them up for the masses.

The rule of marketting

But marketting doens't work that way. Marketting only cares about selling an image, and thrives on the figure of the brillant entrepreneur.

And that would be fine, if marketting kept to its place. But sadly, its reach extends much beyond designing dumb ads to sell us dumb crap. In more and more fields, advertisers get to decide what gets made and how, and their word weighs more than the advice of those who actually know what they're doing. This is why Hollywood can't seem to produce anything beyond focus-group-approved, rehashed franchises designed for mass-appeal, and this is what allows the tech industry to sell us bullshit upon bullshit. Even politicians end up caring more about their brands than policies.

To the point that collectively chanting the current buzzword passes for innovation.

Apply that logic to misunderstood (and barely taught) topics like technology, and you get the current nonsense around AI. I'm not talking about whether the tools can be useful for certain things here, but about the way business owners, ie people that tend to at least worry about their investments, happily bet everything they own on what the current flock of self proclaimed experts sold them as The Future™.

We live in a sausage

None of this is surprising in a system that values short-term profit over everything else. Not much of a scoop, I know.

It still depresses me to think that Zuckerberg's metaverse delusions got more attention than anything Tim Berners-Lee might have to say about the state of the web. This makes about as much sense as putting Elon Musk in charge of a country's budget.

Trying to reason about complex things ain't easy, and it can be pretty hard to figure out who we should trust, especially when the media doesn't understand or care about the truth any more than the average CEO. My rule of thumb is to stay away from any corporate actor, and to be extra-vigilant about anything that gets hyped. It ain't perfect, but it's a start.

Asking yourself where whoever's speaking comes from helps, too. Most of the real, meaningfull progress in computing was publicly funded², most notably the internet and the web. The private sector mostly figured out how to make a buck out of it before convincing everyone else that they were the ones responsible for the whole thing and should therefore shape all future evolutions.

We need to stop believing in that lie. And one small part of that comes from learning to differentiate the actual pioneers from the frauds³, and to stop worshipping individuals. Valuable work that truly matters comes from regular people simply doing their job, not from gifted geniuses. Give credit where credit is due and move on.

And let's hope Ken Thompson doesn't kick the bucket on the same day as Bill Gates.

A figure I already couldn't stand, no matter the field. No single person has ever been single handedly responsible for any worthwhile invention. Not Jobs, not Ritchie, no one. ↩
Technically, Ritchie's work wasn't, which caused quite a mess when his employer (AT&T) later decided to commercialize unix.

But even those shenanigans only happened because the code was initally shared freely. ↩
Hint: they tend to be too busy working on cool shit to try and sell you crap. ↩

Never Surrender

2025-11-03T22:30:00+01:00

I've had an itch to rewatch Galaxy Quest for a while, which I finally scratched a few days ago. The (perfectly legal, ofc) platform I watched it on also had the Never Surrender documentary about the making of the movie and its reception, so I watched that, too.

I loved the movie just as much as I did when I first saw it ten-ish years ago. If you haven't seen it, then go watch it. And if, for some weird reason, you'd rather finish reading this before doing so but still want understand what's going on, then here's a quick summary:

An old sci-fi TV series named Galaxy Quest¹ got intercepted by an alien civilization who mistook it for historical documents about a real crew of space explorers, which prompts them to come to earth and enlist the cast of actors to help them against an evil opponent who threatens to invade/anihilate them.

It's a simple enough premise for some feel-good, light-hearted comedy, but it also touches on a theme that always resonate pretty strongly with me, which is the power of storytelling.

Richard III's hammer

The documentary talks at length about how important this movie was to trekkies and fans of other fantasy / sci-fi franchises. It's basically a love letter to those communitites, poking some gentle fun at their nerdiest aspects without ever being condescending.

Everyone is a fan of the show. The cast gets to be their characters in a real, high stake situation and use actual working magic-tech instead of props. The Thermians² modelled their entire society after what they could glean from the old footage, and even the obsessive kids from the convention get to save the day thanks to their deep knowledge of the fictional ship's innards that no "sane" person would ever care about.

The whole plot is people acting out their fantasy, but there's more going on here than children playing make-believe. Everyone cares deeply about the story they're a part of, and whatever that story might mean to them, it means something.

Art doesn't have to be grandiose, and it certainly doens't have to fit whatever standard the snobs have set for themselves. If it moves someone, anyone, no matter how or why, then it's worth it.

As Alan Rickman's character will realize, there's no more shame in being inspired by the Suns of Worvan than by anything Shakespeare might have written.

Why stories matter

The general love and appreciation for the fans I just described is probably the one thing most people took from the movie, and is explored at length by both audience and crew in the documentary that was shot twenty years after the movie's release.

But what I trully liked is how it can be taken one small step deeper.

On the surface level, this story is about fantasies becoming reality. But I tell myself more and more that stories are real to begin with.

Not in a litteral way, of course. We all know spaceships and dragons don't exist. But whether or not we wish they did is beyond the point.

Stories are fundamantally about people, what happens to them and how they chose to deal with it. Everything else is window dressing.³ And when something clicks and you connect with a character's predicaments, who's to say whatever you're feeling is not genuine ?

None of the stuff that happened in the Galaxy Quest show was ever "real". It was all actors and cardboard props. And yet the thermians, who do not understand the very concept of lying, and therefore fiction as a whole, took it all at face value and built their entire culture out of what the show was embodying.

When they finally learn the truth, their whole world could crumble. But it doesn't, because whether or not it was founded on fairy tales, what they built was strong enough to keep standing on its own.

This is what stories are. A bunch of lies lumped together that somehow manages to brush with whatever truth the artist is trying to say. You know, the human condition and all that jazz. It doens't have to be particularly deep or smart, as long as it resonates. And when enough people believe in that truth, we end up with religion.⁴

This is why treating them as mere "content" is so infuriating, and why I get pissed whenever someone dismisses nerdy nitpicking as obsessing over "just a story".⁵

I clumsily tried to touch on this in the conclusion to my star wars article. Hopefully I made my point a bit more clearly this time around.

Galaxy Quest isn't the first piece of media to touch about what storytelling is all about, but it's the last one I saw, so it's the one this articles focuses one. Again, if you haven't seen it, go ahead. You'll have a good time, and what minor details I covered shouldn't spoil it.

Sharing stories is what makes us humans. For better or for worse. So let's keep doing that. Old or new, doesn't matter. The magic is in the telling.

This is what we should never surrender.

They had to use another name for legal reasons, but it's basically Star Trek. ↩
That's the name of the alien species who get this whole thing started.

Don't they look great? (Click for full size) ↩
Not that it's not important. Worldbuilding can get fascinating in its own right, and there's nothing wrong with getting lost in it for its own sake.

I'd argue that no one would care about the history of Middle Earth if Frodo's story hadn't been told right to begin with, though. ↩
Some nerds can be the worst zealots. Taking that stuff seriously doesn't mean sacralizing it, and we could all do with less bonfires. ↩
Although I'll admit there's a time and place for it. Sometimes I / we might get a bit carried away. See the previous footnote. ↩

Please stop selling me my future

2026-04-06T20:30:00+02:00

I hate to pass for a boomer, but [insert a benign comment about whatever has been going on lately]

I heard this phrase about a million times, and it always irks me. If you've got something to say, just say it. Maybe I'll agree, maybe I won't. The one thing I can assure you is that I won't give a damn whether or not it makes you sound like an old fart.

I get why no one wants to be the proverbial old man yelling at the clouds. That meme comes from somewhere, and those people do exist. And yes, they can be annoying as hell and rarely have much of actual interest to contribute to the converstation.

But claiming that "new" always means "good" is just as deluded, and in my opinion, also dangerous. Embrace change all you want, but please don't turn off your brain in the process and let novelty shut down any attempt at criticism.

The software world seems to be particularly prone to this bias, which is ironic coming from people who love to call themselves engineers yet can't help themselves from chasing after the latest framework of the week, technical debt be damned.

This leaves us with an industry that runs on buzzwords. Web 2.0. The Cloud. Blockchain. Fucking NFTs. And now the current craze about AI.¹

The argument is the same every time. The world has changed, progress is unstopable, and whatever you're being sold is TheFuture™, whether you like it or not. Adapt or die.

Which sounds a lot to me like an injunction to blindly follow whatever happens to be trendy today. If this is what passes for innovation, then I'll gladly change my name to Nedd Ludd.

And you know what ?

It's all a lie

9 times out of ten, the crap we're being sold ain't even that new.

Remember Zuckerberg's metaverse revolution ? When I saw the adds² for it, all I could think of was that second life looked better back in 2003. And even second life wasn't a new idea. People were already dreaming of and experimenting with virtual worlds as soon as we figured out how to make computers talk to each other, all the way back to 1980. Why do you think the genre of cyberpunk emerged around that time ?

Also, who's still talking about the metaverse 3 years later ?

We're told that everything in computing is constantly changing, and that the whole world gets turned upside-down every other day.

And yet most of the world's infrastructure still runs on C, a language that was conceived 54 years ago. The banking and financial systems are desperatly hiring people who still know COBOL, which is even older. LLMs are mostly based on research that was conducted in the 80's.

Even the web, which I would argue was the last truly groundbreaking idea in IT, is older than today's young adults, but we still treat it as a "new technolgy". Mostly because we still have no idea how deep its impact on societies really is.

Code bases don't change at the pace of hype.³ If you think Claude and Copilot can speed that up, go ahead and try, but don't expect me to care when you end up with a unmaintainable and bloated mess in six months.

Tech is not magic

Real progress is slow and deliberate. Breakthroughs are rare and tend to go unapreciated for a while.⁴

And what that progress brings is new possibilities. Some of them pretty exciting. But bringing these potentialities into reality doesn't follow magically.

Take video games. Back in the nineties, small teams of half a dozen people could deliver a game in about one year, sometimes even less. Pixel artists had to come up with all kind of crazy tricks to make up for the technological limitations of the time, but at the end of the day, they only had to draw a copple dozen sprites for each character.

Today low-end GPUs are capable of rendering 3d photorealistic environements in real time, but it takes several hundred experts up to ten years to deliver products they didn't have time to finish.

Artists now have to model the individual hairs of each character and can't get away with a simple color swap to fake some variety. And another team needs to come up with a convincing animation for when said characters stand around, effectively doing nothing, because what was ok with abstract graphics would just look dumb with today's level of detail.

Synchronizing all the new systems resulted in an explosion of complexity, and no single person can possibly hope to truly understand every aspect of a modern engine. This is not because the devs have gotten worse at their job (quite the opposite). This is because actually exploiting the new tech has multiplied the labor costs by a thousand, if not more.⁵

All this so that gamers can bitch about how you failed to make their fancy hardware shine, failing to understand that just because something is possible or even common doesn't make it easy. We've come a long way, but the tradeoffs haven't disapeared. You can't keep obsessing over having the prettiest pixels and at the same time complain that games are getting smaller and buggier.

Progress Uber Alles

Brace yourself for a sudden change of pace. You know what was pretty hype back in the thirties ?

Fascism.

Mussolinni and his pals had plans for a grand new world, and while they sure had a peculiar relationhip with the past, they weren't selling the crowds on a return to the middle-ages. And up until recently, it wasn't controversial to think it didn't turn out so great.

Those guys were big on tech too, and would have loved to get their hands on our current stack. And yet we spent the last 15 years building the tools of mass surveillance that their successors are now gladly using, convinced that we wouldn't be dumb enough to let it happen again.

When the war ended, it was widely understood that the disastrous economic conditions caused by the crash of 1929 had been a huge factor in the rise of totalitarianism, and most countries started to build a few makeshift guardrails around capitalism to try and keep it from blowing up again.⁶

A mere forty years later, we started dismantling those guardrails, effectively going back to the ways of the 19th century. But we called it "modern", so how could it possibly wake up the monsters from a mere generation ago ?

Add another forty years, poverty and inequality has exploded, and we're shocked to discover that the same causes produce the same results they did last century. Turns out collectively chanting "Never again" wasn't sufficient to keep the bad guys from returning.

Well, they're back now. All it took was an update to their terms of service for them to reach a position from which they could unleash world war 3.0. I wonder if the feodal structure of the current web had anything to do with that situation.

History wasn't doomed to repeat itself. but the notion that it goes in a straight line and can't ever reverse directions is part of what put us in the mess we're in today. Hurray for progress, I guess.

Complexity sucks. Deal with it.

I'm not calling every tech-enthusiast a potential fascist. And I'm not even trying to claim that new stuff always suck.

The world's gonna change no matter what, I get it. And despite its current state, somehow I still don't think we're doomed. Yet.

But it's high time we had a conversation about where the hell we're headed and whether or not we're about to hit a concrete wall. This involves many different topics, each complex in their own right, and they all intersect and conflict with each other in a fractal web of convoluted side-effects.

I'm no expert on any of those fields, but I know they can't be reduced to simple pro or anti postures. We'll never solve anything if we're not willing to face that complexity. Call me stubborn, but I refuse to simply live with the times and stop asking questions.

It's okay if we don't agree on something, and you're welcome to try and prove me wrong. If you give me some time, who knows, I might even change my mind.

I'm getting old enough to recognize some recurring patterns, though. That doesn't mean my intuitions are always right, far from it. But you're gonna have to try a little harder to overcome them and convince me of anything. If my skepticism makes me sound like a nostalgic old geezer who's afraid of change, so be it.

But please drop the bullshit and make an actual point, instead of rehashing the slogans you heard from a commercial. It's hard enough to try and think with all the noise that's going on, so I won't even bother to listen if you start sounding like a fucking lemming.

See ya, interwebs. Please stop moving fast and breaking things before there's no ground left to stand on.

I saw this blog post pop into my feed last week. Shortly before that, Adam Neely's essay on AI generated music (possibly the best thing I've seen on the topic yet) had already prompted me to mull over that "You don't want to be left behind" phrase I'd been hearing so much lately. So I guess this article was inspired by both of those pieces.

This started as a quick rant and kept expanding as I typed. As a result, it's a bit all over the place. I hope I managed to stay somewhat coherent, but if I didn't, fine. Rambling is what this blog's supposed to be about, after all.

Sadly that one seems to take much better than its predecessors and didn't keep to the tech world. To the point that fucking armies openly admit to using it to plan their operations, all too happy to switch the blame to a simple, if regrettable bug that will be fixed as the AI gets better.

Spoiler alert: it won't.

If we've really gotten dumb enough to let them get away with this, maybe it's time to just put the bots in charge of our nuclear arsenals and get this joke of a civilisation over with. ↩
Which tried to sell us on their product by showing us a virtual... board meeting ?

This is what was supposed to get us excited ?

The conspiracy theorists were right. Those people can't be human. ↩
The transition from python 2 to 3 took ten years. ↩
The paper's introduction undersells it, but Clifford Stoll is actually a pretty cool guy. ↩
Yes, a lot of that work can and already is automated. But someone still has to steer the wheel and merge all this stuff into a coherent whole. ↩
I'm told many countries envy France's social security system. And that's one of the few thing I can agree we did right.

Too bad many don't remember that it was part of the resistance's political program and explicitely conceived as a means to prevent fascist rethorics from exploiting misery again. ↩

Still enjoying the mandolin

2026-04-13T19:00:00+02:00

Having fooled around off and on for a little while, it's hard to tell exactly how long I've been playing the mandolin by now. I seem to remember that I started to get a bit more serious about it around may of last year, so I guess now is as good a time as any to reflect a little about it.

Long story short: I'm still having a blast.

I kind of switch back and forth between it and the guitar, depending on what's coming up and needs some work done, so progress is probably slower than it should, but it's still coming along nicely.¹

I'm now confortable with a bunch of simple chord inversions and can usually try out different positions on the spot. Some keys still trip me up,² and my chop definitely needs some cleaning up (I still tend to overplay when I should aim for a simple, tight backbeat, and can't always prevent that damn E string from ringing when it really shouldn't), but I can usually get by without too much of a thought on a simple progression.

Double stops are awesome

Lately I've been getting a kick out of double stop harmonies. I know those can sound great in a lead context, but I've mostly used those when playing backup so far, and I just love coming up with parts that outline the progression in a nice and subtle way. Those often don't sound that interesting on their own, but can add a really nice touch in context with other instruments, and it's an approach I rarely get to take on accoustic guitar.

As an example, I've been playing a very simple Niagara song with a bunch of friends, which is basically 3 chords played over and over. Here's the progression twice, once with the classic bluegrass chop chords, and then with more common (and easier) major positions:³

And here's what I came up with after fooling around with chord tones:

Kinda "meh" on its own, but here's how it sounds in "context" (ie with just a guitar backup and some quick approximation of the melody. Mando deliberatly too loud in the mix to try and make the part stand out):

I still don't have a good feel for when that approach is right for the groove, and I can see how this could get tiresome if overused, but right now I'm having a blast exploring that kind of lines. I kind of think of them like trombone parts in a New Orleans Jazz band, even though they're in a much higher register and therefore have a very different effect on the overall feel.

Running over thin ice: KISS is hard

As far as melody goes, I've mostly kept fooling around and haven't really put much thought into it beyond getting a few more scales patterns under my fingers. Theory wise, I'm not doing anything more complex than what I described in my previous note. I'll stop and analyze what's going on when I need to, but I'm trying to let my ears do the driving most of the time.

Dive head first, see what happens, and laugh it off when it goes horribly wrong. Which, needless to say, happens pretty often. Sometimes I manage to get back on my feet, sometimes I don't. Crash and burn, that's how you learn.⁴

Technique is clearly the one point that's lagging behind. The new tuning is starting to make sense in my head, but that won't do as long as the fingers don't internalize it too. So right now my eyes are still stuck to the fretboard, and I regularly get confused with some move that would have worked on the guitar, or overshoot a fret and land on a nasty minor second.⁵

I tell myself to keep things simple, but I have a hard time forcing the left hand to stay quiet. It seems like the muscle memory happily kicks in, not realizing it's in uncharted territory. The brain hears all the mistakes, but the fingers keep wiggling around like nothing happened. Maybe there's an unconscious "I can get out of this mess by playing more stuff" thing going on, too.

So I can tell I'm going to need a bit more discipline in that area.

One way I'm thinking of fixing this is to force myself to use a lot more of what I'm calling "pseudo tremolo",⁶ which is the same idea as regular tremolo but keeping the rhythm to regular 8th or 16th notes instead of going for the full effect.

Basically doing this:

instead of this:

It doesn't sound as cool (at least, not as cool as it would if I didn't suck at it to begin with), but it gets the job done and should give me time to think while still filling out the space nicely. Also, I should definitely start doing more of that on guitar. It won't sound quite as full, but I have a hunch it can still be pretty effective and should make for a nice change of pace.

Tone is in the hands

Technique is also crucial to get a good tone. And while the mechanics are familiar enough that's it's pretty easy to play something, making it sound good is another matter.

I could tell right away that I wasn't sounding quite right and would need to adjust a few things to produce something decent. But it seems like I've underestimated the matter by quite a bit.

Every instrument is different, and I knew from the get go that getting to know a new one well enough to truly make it shine was going to take a while. I already get tripped up when switching to a different guitar, so I wasn't expecting to get there in a copple of month.

Well, turns out that even sounding good enough for a quick jam is trickier than I thought.

Mandolin technique seems to be far more demanding than guitar, and simply getting used to the new string tension is not enough. I thought my fretting hand was doing okay at the whole "play with the very tip of your fingers" thing, but I quickly found out that I still had quite a lot of room for improvement on that front.

The good thing is that I know how to improve: slow the hell down and put in the hours. It's gonna take a while, but only time can fix the habit. I also know that its better to play simple stuff with good tone than the other way around, so I don't mind focusing on it and doing my chores, as it should help with the points I already discussed above.

It's slowly getting better, and I feel like it's transfering back to my guitar playing, too. It's pretty subtle, to the point that maybe I'm imagining it. But I noticed a while ago that some of my favourite guitar players,⁷ tonewise, had also played or even got started with the mandolin, and judging from the fact than it's just harder make the eight-stringer sing, I suspect this is not a coincidence.

Is there really something to it ? I dunno. Time will tell, I guess.

Nice gear is nice

Most of my early playing was done on a Gretsch New Yorker a friend had lent me. It's pretty nice, but I decided early on that I should get one of my own if I decided to get serious about it.

My first impulse was to just grab a Loar, as another friend plays one so I knew they were descent enough and they don't cost too much. But for some reason I couldn't find one on any european shop⁸ when I started looking at the beginning of last fall.

Kentucky⁹ and Eastman were the two brands that emerged from my online searches, but again, I couldn't find a good deal on one for a while. Price wise, the Eastman was clearly out of my budget, but I was willing to shell out on a used one if nothing else came up.

Finally found one at the accoustic shoppe. It was 200 bucks off because of a minor ding in the finish, the seller had a pretty good reputation, and it was located in the netherlands. Seemed like a no-brainer.

It arrived pretty well packed¹⁰ and, more importantly, perfectly set up. My first few strums had that awfull ring you get when the strings are less than a few hours old, which tells me they were put on right before sending.

I really don't know enough yet about this instrument to attempt a full review, but I'm more than satisfied. I still haven't given my friend his Gretsch back, so I've had the occasion to compare the two, and while the New Yorker is far from ridiculous, I can tell it's in a different league.

So that's cool, as I know I won't feel the need to upgrade for a while (and if I ever do, hopefully by then I'll have a better idea of what I'm looking for).

Next step is to get a decent pickup. I'll probably reach for a K&K, as I already have a pure mini on my guitar and haven't had to complain so far. And I'll probably start fooling around with strings pretty soon (I've kept to the standard D'addario set so far, but I'm very curious to hear how flatwounds behave on that thing).

Knowing myself, I'm sure I'll get to try tonerings, arm rests and whatever fancy gadget I come across at some point, but this can wait. Trying out gear can be fun, but I'm not quite in that mood these days, and I'd rather wait until I start knowing what I'm doing before indulging with GAS.

Shut up and play

Allright. Time to wrap this up.

Mandolin is freaking cool. I'd been tempted to try it for a while now, and I'm glad I finally got to it.

It's a much less common sound than guitar,¹¹ and just like banjo, this can be enough to stand out, especially in my neck of the woods. I'd be lying if I pretended I'm not hoping this will land me a few more gigs when I'm a bit more dependable with it.

Also, I'm enjoying it way more than banjo.

But the best part is defnitely getting to troll fiddle players by telling them you now realize how easy their lines actually are (completely disregarding the fact that they don't get to cheat with fancy frets, or that I would have no idea what to do with a bow).

Bonus points if you back that up by trying to play their parts back at them while being out of tune. Trust me, they'll love it!

Keep in mind I've been playing guitar for 20+ years, which is helping a lot. The process feels like figuring out how to apply things I already know, rather than learning them from scratch.

It won't last forever, but this does flatten the initial learning curve by quite a bit. ↩
I really should spend more time on minor keys. Also, fuck E flat. ↩
I wrote it in A because that's where we play it and it's less of a pain to notate (also I didn't think to check before writing it all down and can't be arsed to fix it after the fact), but the original is in A flat.

Just move everything down one fret if you wanna play along the original. Who knew avoiding open strings could have its uses ? ↩
I know this is far, far easier said that done, and I'm far from being as confident as my boasting may make me sound. But I do know that the best way to overcome the fear of failure is to fall flat on your face and realize it's not as terrible as it sounds.

Repeatedly.

Which is why I try and put myself in situations where I'll have no choice but to jump in and see how it goes. ↩
Again, laugh it off and call it jazz. ↩
Actual tremolo is pretty cool, too, but it's still too hit and miss for me to rely on it. Yet another neat thing I'll have to consciously avoid for a while. ↩
I could listen to this guy play "Mary had a little lamb" all day.

Sierra Hull's doing pretty good, too. ↩
I don't mind buying from an US dealer on principles, but taxes and shipping make this a pretty dumb move these days.

Also, this seems to explain why they can't be found right now. Maybe they'll pop up again. ↩
Got to try one a few months ago. They're pretty nice! ↩
The box was big enough to hold three of those and weighed almost nothing, which prompted the delivery guy to joke that it was probably empty. ↩
I've already had people asking me what it was, almost every time I played it in public.

Still waiting for someone to call it an ukulele. ↩

A tune from Canada: L'air mignonne

2026-04-20T15:00:00+02:00

Wanting to remember how recording¹ even worked, I decided to cover this canadian tune at some point during last fall. Took me way longer than I care to admit to finally come up with something vaguely interesting, and I hated the sound I was getting, so I shelved the project.

Had to plug in the microphone again last week for my last mandolin article, and I thought I'd try my hand at it again.

Well, here's what I ended up with:

I learned the tune at a local jam session about a year ago, and immediately fell in love with it. It's a dance piece, the kind where everyone just plays the melody over and over until everybody gets sick of it. I didn't expect that approach to work so well with only plucked strings, so I figured I'd turn it into a fiddle tune and have the intruments take turns improvising over it.

Which turned out more difficult than I thought. It seems that the simpler the melody, the more I'll struggle to come up with interesting things while staying close to it. So that's where I spent most of my time when I first tried it.

I made a point to improvise each break, so no take was ever the same as the previous one (although ideas from previous attempts obvisously crept up). In retrospect, that's a bit silly, and I could have used the opportunity to write down structured solos. Would have been a good exercise and I probably would have ended up with something cooler. Must be some stupid pride thing, like I don't want to "cheat" or something. Oh well.

Not a huge fan of the mix, but I'm no sound engineer, and that's the best I can do given my crappy room and crappier skills. I can hear most of what's going on, but that's because I know what I played, and I still wish things were a bit clearer.

The banjo track is from my first attempt back in October or November.² Everything else was redone over the last few days. I reluctantely did a bit of editing magic, mostly to redo the guitar break³ and the mandolin ending (it was fine in the take I'd kept, but sounded like crap for some reason. I'm guessing I moved in a wrong spot while recording, and I couldn't fix it with EQ).

Track by track recording is weird, and I know I'll always miss the energy of a live band, but hey. It's its own kind of fun until perfectionism kicks in and you get lost in tweaking things forever.

Hopefully I've learned a thing or two in the process. We'll see when I get to the next tune.

Here's a picture of the whole crew, from low to high:

Purists will have to forgive me for the electric bass. Ain't no way I can fit an upright in my appartment.

Oh, and if you don't speak French, the title means something like "The cute air", which sounds like crap in English. "The cute melody" ? Meh. What matters is that it's pretty cute indeed.

Hope you'll like it. See ya when the bug bites again.

As in "serious recording", with a DAW and all.

Setting up the old zoom recorder is simple enough, but it won't do for multi tracking. ↩
I know it is slightly off-beat in the first section, but fuck it.

It won't sound anything like the old take if I try to fix it now, so I'll have to redo the entire track if I want to fix it, and I just can't be bothered. ↩
That took an embarassing number of takes.

Beyond the actual playing, it took me ages before I could get something that didn't sound like garbage.

In the end, that's the instrument I like the most, tone wise, but boy, that took some luck. ↩

The quest for quests

2026-05-16T18:00:00+02:00

Like many, I got into programming by making small games. Being a fan of RPGs, I almost immediately wanted to try and make one¹, which led me to discover the roguelike genre. Since I sucked at doing anything graphical, those were perfect to mess around without having to actually try and draw stuff. Over the following years, I have started and abandoned about three roguelike games².

None of those projects were ever intended to become "true" games, or to ever get finished for that matter. I found that game design seems to interest me about as much as visual work. Rather, I was having fun implementing the various systems and trying to come up with an architecture that made some kind of sense.

It's been a while since I fooled around with some pseudo-game, but lately I've been thinking of a few ideas. Trying my hand at networking. Exploring procedural generation a little more, or trying to run a simple simulation.

I'm not sure what finally decided me, but one of those ideas seemed simple enough that I finally got started on something about three weeks ago.

Well, here's what I've got:

Introducing Questing Quest (working title)

Click on the image above to let the game respond to input.
Click outside to give back focus to the page and get your regular keybindings back.
Press escape while the game has focus to kill it and stop the music.
Refresh the page to restart the game.³

It's pretty clunky (I'm truly sorry for the awful collision detection) and ugly as hell but hey, it works. There's no win or lose condition, and frankly no real gameplay to speak of.

Oh, and it only responds to keyboard events. So I guess you're out of luck if you're viewuing this on a tablet or a phone.

Enjoy!

I wrote it in C⁴ and stole a bunch of assets from Itch.io, which explains why the art style is so inconsistent.⁵ A friend of mine sent me unfinished chiptunes he was working on while I was fooling with this thing, so I shamelessly put them in to test the audio system. I'm not sure they really fit whatever mood this thing is supposed to have, but I do like them for what they are. So thanks, Tom!

The original goal was simply to try and come up with a way to handle quests. Which led me to implement rudimentary dialog and event systems, so pretty much everything I never got to try my hand at with my previous roguelike attempts.

Obviously, I got distracted along the way and messed with a whole lot of other "gamey" things, to the point that I've barely tested the quest thing even though that was supposed to be the starting point of all this.

So that's the "game". Bump into an npc to activate a quest randomly chosen from a huge pool of... well, 2. Once activated, this quest will spawn either an enemy or an item in a random zone around the one you start in. Getting the item or killing the monster will update the quest.

That's it. Game of the year material, I'm sure.

By the way, if you think the result above is ugly, know that it started looking like this:

It might still suck, but it did come a long way, is what I'm getting at.

Going low level

Unimpressive as it may be, this is the biggest thing I ever done in C,⁶ and I'm getting a kick out of it. I've been wanting to try my hand at lower level stuff for a while, and somehow I found I enjoyed writing good old C quite a bit, despite all its infuriating quirks.

I dunno. Maybe I just enjoy pretending I'm an old greybeard. But I do think I'm starting to understand the benefits of simplicity, and C shines on that front. Also, managing to have it do what I want without segfaulting each time I change something⁷ is pretty gratifying, coming from higher level languages like python.

I'm still strugling to truly isolate sub-systems (seems like every module always need to #include 12 other files that probably should be left alone), but the code doesn't quite feel like a ball of mud yet.⁸

Part of that might be due to resisting the urge to try and be clever. Most of the code is pretty dumb, and therefore quite easy to follow. I didn't try to get fancy with architecture either: entitites are a single fat struct, and everything is stored in static arrays (the lib I'm using for hashmaps does some dynamic allocations, but there's not a single malloc in my own code).

No fancy macros either beyond a few simple shortcuts. The fanciest ones I have are dead simple and still quite useful to simulate varargs functions:

typedef struct {
  EventType type;
  union {
    // generic pointer for event that only need one parameter
    void *generic;
    // data for event type T
    struct {
      const char *string;
      int        number;
    };
    // ...
  }

} Event;

// shortcut to create an event
#define Mk_Event(T, ...) (Event){ .type = (T), __VA_ARGS__}

// Actual event-queuing function
void Event_Emit_impl(Event event);

// Actual interface, allowing multiple arguments that will get dispatched among
// the various union members of the Event struct
#define Event_Emit(T, ...) Event_Emit_impl(Mk_Event(T, __VA_ARGS__))

// Now I can fire event with data relevent to their type as easily as:
Event_Emit(EVENT_TYPE_SOMETHING, some_data);
Event_Emit(EVENT_TYPE_T, .string = "foo", .number = 666);
Event_Emit(EVENT_TYPE_WHATEVER);

Oh, and tagged unions are awesome. I turned almost every data structure I needed into one.

Starting things in the dumbest possible ways means that I inevitably had to rewrite large parts of the program as I realized I needed to handle things differently, but those went pretty well overall. I suspect the simplicity of the original code helped: easier to add complextity to something braindead than to change code that's already trying to be clever.

What's next ?

So I started out with a pretty simple goal and ended up with a pretty bad "game" that barely exercizes it. And I realize that I'll have to actually try and turn that game into something if I want to see if what I've implemented actually holds out.

The thing is, I can already feel the interest fleeting away. It's kind of weird. Usually when the itch starts scratching, I get obsessed and spend all my time on whatever it is I got into until I get sick of it.

Not so this time. I happened not to have much to do over the last weeks, so I kept at it mostly to keep busy, but at a fairly relaxed pace. Who knows, maybe this will help me hold my interest for longer that unsual ?

There's still about a billion things to do before this thing becomes remotely interesting, but again, I find my fun in implementing systems I'm not familiar with and have them kind of work, so I don't care if it remains weird and clunky.

I'll be away at the end of the month and pretty busy in june, so I don't expect to do a lot on this thing in the near future. But if the bug bites again, I do have a bunch of ideas to try out (assuming I still can understand a single line when (and if) I decide to get back to this project)).

So we'll see if this thing ever gets completed. I know it probably won't ever amount to much as a game, but hopefully I'll manage to at least try my systems in a situation closer to a real life scenario. Most of the stuff I want to fool with is still fairly technical, but who knows, maybe I'll also try to write a stupid little story to build on as well.

I may mention this project again if I manage to make some progress on it. Or maybe I'll just shelve the whole thing and never touch it again. Wait and see, I guess.

In case anyone's interested, the current code is here.

So. I dunno if there's much of interest to this post. But it's all I have to celebrate this blog's first birthday. Let's see if it's still around next year.

See ya until then, interwebs!

I never cared about the MMO kind, though. So that's at least one silly overambitious project I never got into. ↩
The latest in date being that one.

I remember abandoning at the point I had to re-do the inventory system after about 2 months of obsessing over tha whole project. For some reason, that was the last straw. ↩
Compiling to WebAssembly and putting it up on a page is pretty straigthforward, but interacting with it once it's loaded seems to be another can of worms. Sorry for the poor integration, I had to hack the generated js wrapper to try and make it a bit more bearable. ↩
Which I then compiled to WebAssembly to host it on here. ↩
No idea where the Darth Vader sprite comes from. I nicked it from the web maybe ten years ago and found it back in some old silly thing I wrote back then.

Also, be thankful I resisted the temptation of grabbing the Wilhelm scream for the spider death sound effect. ↩
It's a bit over 2000 lines of code, so still not huge or anything. ↩
Or even better, understanding what causes the segfault under 3 hours. ↩
Although I can see the event system devolving into callback hell if I'm not careful. ↩

The history of the Web

2026-05-24T22:45:00+02:00

I've been willing to share links to other places a bit more on here for a while, reflecting that hyperlinks are the essence of web and that the more of those, the better.

Part of doing that involves adding more sources to my RSS aggregator, which I'm slowly doing,¹ but I figure posting one off links to stuff I happen to find interesting is fine too.

I'm not sure whether I should add a dedicated page for this or simply treat those as regular posts. In the interest of doing what's easiest, I'll go for the second option for now and introduce a new category.

And so, I stumbled upon this site chronicling the early days of the web the other day while researching some facts about the era of the AOL portal, and thought it'd make for a fine first place to share:

The History of the Web

It's both a book in the writing and a blog, and it's pretty neat.

I've been reading through the archives over the last few days and I've learned a lot. My favourite tidbit so far is how Megadeth was apparently the first high profile band to have a promotional website back in 1994.

I got online around 1999, maybe 2000, and I was too young back then to care about what was actually happening. To a true early adopter, I was part of the latecomers who started to ruin it all. But the sense of wonder described in many of Hoffmann's post was still there, and even though I didn't give it much thought or realize what it meant, I remember it.

So I'm feeling some weird nostalgia as I read, as even though I didn't know most of the sites he describes, I did get to tinker with their direct successors.

It's interesting to see how fast business came in the picture, too. I knew about the dot com bubble, but somehow I had the impression that the commercialization of the web happened a tad later. Maybe I simply get that period confused with the one before it, when the internet was still ruled by Usenet.

It also reminds me that the history of technology is both fascinating and important. And the web and its early promises are part of that history, right on the heels on the UNIX wars.

I'm convinced that knowing at least a little bit of that story is one of the keys if we ever want to take back some kind of control over it, if only to learn to recognize the bullshit behind the hype cycles of today.

So hats off to Jay Hoffmann, doing his part to spread the tale. See ya and good reading.

I should really try and make it a bit less ugly someday. ↩

Spot the difference

2026-06-08T20:00:00+02:00

Daddy's Drunk Again, my bluegrass duet, has a gig booked in my hometown at the beginning of next month. The bar where we'll play has already contacted the local press to announce the concert, and has provided them with a photo they found on our website.

So far, so good. Nothing out of the ordinary.

But the other half of that duet noticed that the picture, as published by some local news sites, had been edited, undoubtedly by some kind of generative AI.

Check it out (original photo on the left, altered one on the right, click on the pictures to get them in full size):

I appreciate how the bot helpfully hid my pinky sticking out (a bad habit of mine that tends to get captured every time someone reaches for a camera). Too bad said pinky looks like it's been cut off as a result. Also, it apparently decided I should be playing an E chord instead of whatever I was doing.

But beyond laughing at the silly details, my main reaction is to ask why ?

I'm not claiming the original picture was perfect, and I'm sure it could use some editing. I honestly don't have an eye for that stuff. But I don't see how the one that got published is any better, even disregarding the various nonsensical modifications that just make it look fake.

I suspect someone (I doubt it was the bar that booked us) simply used an automated editing tool "just in case",¹ without noticing or caring that the tool integrated with some AI that happily hallucinated random changes no one had asked for.

Which makes no sense to me. Using the original file would have been faster than messing with it, and would have looked better.

The other hyposthesis is that no one even did anything, and that some piece of software (an email client, a phone OS, a CMS platform... who knows) automatically decided to "enhance" the picture as it passed through it. I know youtube has done this, and phones have been offering this feature for a while now.

The first option would be disapointing. The second one is terrifying to me.

I guess that's what they mean when they say you can't escape AI. Whether you like it or not, someone is going to force it on you no matter what. And here I am hoping that that someone is at least human.

This particular example is just one out of a billion, but it's the first time it happens to me and I'm split between getting pissed and not even caring.

It's not an embarassing or incrinminating deepfake. It's not conveying false information,² and its reach it gonna stay pretty limited, so it's really not a huge deal. But still.

Had we decided to use AI to edit our stuff, then whether or not that was worth it would be our problem. But we didn't, and now this fake version of us is out there, potentially making us look like AI endorsers (we both stand pretty firmly on the "anti" side of this debate).

All this for no benefit whatsoever to anyone.

I'll contact the website as soon as I'm done ranting here and ask if the file can be replaced, as well as whether the alteration was intentional of not. I don't plan to point my finger or blame anyone for this, as I just don't see what use that would be. But I would like to know when and where that happened, and which of the two hypothesis I mentioned above is right.

We'll see if something comes out of it. I'll edit this post or write a new one if it's of any interest.

Until then, I'll keep bitching to myself about how the web is getting more and more fucked with each passing day.

Post Scriptum:

So I wanted to link to a specific example of unsollicited AI modifications I remembered reading about some months, maybe a year ago. I went looking for it and gave up after almost two hours of finding nothing but adds pointing to stupid online, AI powered and proud of it editing tools.

Fuck you, internet.

Edit 2026/17/06:

After investigating for a day, procrastinating for a week, and then taking on the case again yesterday, I now know my first hypothesis was the right one. The bar apologized and admited to using an AI tool to try and make the photo a bit less blurry, and didn't notice the modifications.

I get it. I'm always tempted to automate that kind of routine fixes too, and while I'm sure it would piss off a professional designer, my untrained eyes wouldn't be able to tell the difference. The real problem here is really that the so called "tool" decided on its own to mess with random bits of the picture even though no one ever asked it to.

Tools aren't supposed to act on their own, by the way.

We're talking about a small local business that probably has a million other things to do here, and the scale is pretty small. So all in all this particular story is not a huge deal.

But seeing the rest of the world being more and more okay to rely on those things for anything more serious is just crazy to me.

Anyway. Problem solved ?

Not quite.

The picture was submitted to a "local events" site hosted by a regional newspaper, which is sourced by various institutional sites. The former was updated this morning. The latter aren't as I'm writing this.

Maybe I just have to wait a bit and the data will update on its own. Or maybe someone needs to trigger a manual refresh. I have no idea.

I'll wait for a few days and see if I need to ask for that refresh or not.

Sigh.

As I often do, to be honest. I'm hopeless with graphical editing.

I do stay clear of anything boasting to be AI powered, and I rarely try anything fancier than cropping, but I guess I should be careful not to fall in the same trap. ↩
At least, nothing important. I doubt the bar in the background will care that its signage is wrong.

(It's called "L'hermine", by the way. No idea where that "O" comes from.) ↩

Please don't poop on my books

2026-06-18T15:30:00+02:00

A while ago, the great library of Alexandria burned to the ground, and most agreed that it was a crying shame.

At least, most of the people who could read.

A few centuries later, a bunch of weirdoes set out to build a new library, much bigger than the old one, but instead of storing the books inside some dumb building, they piled them up on the clouds, way up in the sky.

That new library was accessible from anywhere in the world, and by then, most people could actually read and benefit from it. The subscription fee was pretty cheap, and cats ruled the whole place.

It wasn't perfect, but overall it was pretty neat.

And then at some point, some folks decided they'd rather eat poop than read books, and set out to build machines to produce crap in industrial, never seen before quantities.

As far as volume, it was impressive indeed, and now Alexandria 2.0 is overflowing with diarhea. From the floor to the ceiling, shit is everywhere. You can still get at the old books, but they're buried under thousands of turds.

I don't mean to kink shame anyone. What people chose to put in their mouths is none of my business. But I do resent somewhat being told that I'd better learn to enjoy the taste of feces just because a bunch of assholes decided to take a dump on my plate.

And now that the dung is leaking out of the shelves, it's starting to rain manure, and people who chose to stay on the ground wonder why the drops suddenly started to smell so bad. I hear the pigeons are going on strike over fears of losing their jobs.

The day Alexandria burned was a sad day indeed. But if we're gonna have to lose all the concentrated knowledge and silly memes of humanity, somehow having it all swallowed by flames feels more dignified that watching it disapear under a flood of poop.

.git/info/exclude is awesome!

2026-06-20T12:30:00+02:00

I spotted this article a couple days ago, which shows some alternative places to list files you want to exclude from being tracked in a Git repository beyond the usual .gitignore.

I knew about the global ~/.config/git/ignore, but never bothered with it. I probably should, though. The .DS_Store¹ example is especially relevant.

It always irks me to see those files in a local .gitignore. My tools and the various files they crap out shouldn't have anything to do with any individual repo, so why should I have to list them all in there ?

I can understand listing the most common ones anyway when many people work on the code, to try and avoid mistakes by someone who didn't set his global config. But I can still try and prevent myself from telling the world about whatever trivial script I decided to use on my machine, and for a small project that only me will ever see, I just don't see the point having that info up on github.

But the real gem is .git/info/exclude. I'm feeling lazy, so I'll just quote from the source:

The exclude file lives in the .git directory of every Git repository but changes to it are not checked into Git. It usually has a few comment lines on a fresh Git repository. This file is useful for ignoring things on a per-repo basis. For example, you may have a personal notes.txt file in a repository that you don’t want to check into git but you also don’t want to add to .gitignore because it’s unique to your workflow. In that case you would add notes.txt to .git/info/exclude.

I had no idea about that one, and man, it's perfect. I always end up with a million of those small personal files littering the root of all my repos. Notes, screenshots, small automation scripts specific to my environment, half assed code experiments... It's usually quite a mess, and as a result I never do git add . and always stage the files I want to commit manually.

Not a big deal, but it gets annoying, and this seems like the perfect solution.²

I like this so much that I added this quick function to my .bashrc:

function git_exclude() {
  # WARNING: use quotes to surround glob patterns (ie prefix_*), as those get
  # expanded by the shell and we end up adding each individual, currently matching
  # file instead of the general pattern we wanted.
  # Example:
  # $ git_exclude test_*.sh
  # $ cat .git/info/exclude
  # test_foo.sh
  # test_bar.sh
  # VS
  # $ git_exclude "test_*.sh"
  # $ cat .git/info/exclude
  # test_*.sh
  for f in "$@"
  do
    echo "$f" >> .git/info/exclude
  done
}

It's not perfect, though. Sometimes I have files laying around that I don't want to commit, but don't want to hide either. For instance, the various unfinished drafts for this blog. So I guess I shouldn't lose the habit of always checking the git status before doing anything, and the magical git add ., no questions asked, is still not guaranteed.

But still. Excluding the rest at least make the status output less cluttered, so I'll take it.

Quick digression: Too many shortcuts considered harmfull

Back when I discovered Linux, I loved spending ages tweaking my .dotfiles, and I had a million aliases and shortcuts like the one above, most of them collected from around the web.

I finally grew weary of the constant fiddling and learned to leave things alone. I still add a small thing now and then, but it's a lot more rare, and I always wait for a while before commiting it to my dotfiles repo.

The kind of tricks I learned to avoid are the ones that mostly serve to avoid learning the basic unix commands. I remember having a bunch of aliases to automatically add a bunch of flags to grep, which were very handy on my machine.

But as a result, I had no idea how to do a simple search as soon as I was in a different environment. Which was a lot of fun when I had to search logs on a remote server to try and understand an urgent bug.

I still can't be arsed to remember most of the flags to grep, but I did memorize the two I constantly use³ and force myself to just spell them out when I look for something. A quick check of the man page can fill in the rest, and I don't even need that 99% of the time.

I had similar "helpers" for find and a bunch of other common commands. It's fine to be lazy for the more esoteric stuff, especially if you don't need it often, but if it ends up crippling your understanding of the basics, it gets counter-productive. I got rid of most of those shortcuts a few years ago.

That one feels similar to be honest. I can tell I mostly wrote it to avoid having to remember the file's location, which is probably not worh it. On the other hand, my fat fingers love to mess up quotes and angled brackets, and paired with the shell completion of filenames, I can see that function preventing many stupid typos. Seems worth a try anyway, time will tell if I keep it around or not.

Don't worry, I can still make a fool of myself.

This article was supposed to end here, but while playing around with the exclude file, I noticed I had a few trivial edits on previous articles. So I committed them and pushed them on the live site.

Apparently I had forgotten to set this note's status to "draft", so it got published as well. While it contained nothing but a few lines outlining what I planned to write, littered with TODOs.⁴

I saw it pop into my feed reader, and sure enough, it had already been picked up by various aggregators:

Oops.

I'm not proud of that one. I don't mind passing for a fool, but polluting the feeds of others with objective crap sucks. Information overload is enough of a problem already not to add to it with stupid goofs. Sorry about that.

I do appreciate the irony of this happening right when I was talking about my git process and how it could use some improvements, though.

Also, let's not mention that this happened right after my bitching about the uncontrolled proliferation of some AI crap, which I still have to try and fix, okay ? At least this time I had nothing to do with it.

I had thought about setting up some hooks to deploy the site on a push to the remote but put it off out of lazyness and a general distrust of too much automation (see above). It definitely could have saved me here, as I only commit the articles when they're done.

Oh well. Live and learn. Guess I'll get on this before messing up again.

Sorry internet. I didn't mean to add to the ever expanding ocean of slop. If that makes it any better, at least that one drop was 100% human generated.

Some configuration file used on macs. No idea what it's for. ↩
I guess learning some discipline and not making a mess in the first place works too, but where's the fun in that ? ↩
-r and -n, respectively for recursively searching (especially handy as it means I don't have to specify a specific file as long as I'm fine including the current working directory) and for showing line numbers before the matches. ↩
I giggled while typing the TODO FIXME.

That was my nickname at work, as I did tend to leave a lot of those around. I got a bit better at cleaning them up since then, but not by much. On a first draft I still have no shame abusing them, though. A quick search for them is part of my publishing ritual.

Obviously, this doesn't help when the whole thing gets uploaded to prod when it shouldn't. ↩

Doc Watson lick on the mandolin

2026-06-22T19:30:00+02:00

Yesterday was music day in France. If you're not from this part of the world and don't know what music day is, basically it's a national event where anyone is allowed to play music in the streets.

It's supposed to celebrate amateur musicians and on paper, I'm all for this.¹ In practice though, I tend not to go.

In big cities such as where I live, it tends to draw huge crowds, and the older I get the less I tolerate being cramped with a mass of people, no matter the occasion. It's not phobic or anything, but it does tend to kill any enjoyment I could otherwise get from what's going on.

Also, and this might be specific to Nantes, the sheer amount of loudspeakers blasting away while located not 100 yards from each other tend to produce a wall of sonic mud that quickly gets tiresome. Call me a snob, but this, in addition to my previous point, tends to ruin the mood for me.

If you enjoy partying in the streets, go for it. But if you're like me, then here's a couple of tips:

In city centers, try and find a spot somewhat isolated from the busier locations. You don't have to wander far: a small park, a place, some side street off from the main roads... Anything surrounded by walls or trees to cut off the sound.

Those don't necesserally do much for the crowd, but at least you get to hear one band at a time.
If you can, go to a smaller town. You'll see less things, but the overall atmosphere tends to be a lot more relaxed.

Those tend to celebrate music day a day or two before the official June 21st date, so if you'd like to have the louder experience too, you can enjoy both!

And that's it for the travel tips.²

I had planned to stay home and enjoy a nice conversation with my fan, before noticing that I was all out of cigarettes. So if I was gonna head downtown anyway, might as well hang around for a bit.

Stumbled on a friend who was setting up to play in a decent spot, so I stayed and enjoyed his set (he did have to fight the surrounding noise, but he managed to stay on top of it). So overall, it was allright, and reminded me that's it's been a while since I wrote something about music, so here's a post about my favourite classic guitar lick and how easy it is to adapt to the mandolin.

The Doc lick

If you've listened to bluegrass music for any length of time, then you've heard this lick. It might be older, but Doc Watson is clearly the one who popularized it. You'll spot it everywhere in his playing. Which you should definitely listen to every day, because Doc is Awesome.

It's based on a very simple move I touched on the last time I wrote about bluegrass guitar, which basically consists of rocking back and forth between the minor and major third, making sure that the second of those notes falls on an open string to emphasize the dissonance.

Surround this with a simple motif from the major scale, and you get this:

It's really all about the two highlighted notes. Everything around it is just idiomatic filler, and there's a million possible variations you could come up with.

A very simple one I like to use is to simply turn the first two notes into a triplet:

Of course, you can also repeat the dissonant pair. Doc tends to stick to playing it twice, while Billy Strings likes to keep going and get real nasty before resolving.

Personally, I quite like repeating this whole four note motif when it's appropriate:

It's trickier than it looks and sounds best on faster tunes. I should definitely work on it to clean it up, but it's a nice way to fill up space without having to think too much, even though that one could get tiresome if used too often, so chose your moment wisely.

The lick is typically played out of the C position, but it works great in G, too (As Billy demonstrated in the example I linked above):

For some reason, it's much rarer to hear it in this key, even though Doc himself plays it right in the first measure of Beaumont Rag:

(Not an exact transposition of his version, but close enough to get the point.)

Again, this is just the tip of the iceberg. It's one of those licks you could spend your life exploring, and many have already. And it's certainly one that creeps up again and again in my own playing.

I thought this post was about mandolin

The one question I did not ask myself was how to transpose this lick to the mandolin.

Instead, it happened by accident. I just goofed up while fooling around in the key of C and recognized that classic dirty third color. From there, it wasn't hard to reproduce the whole lick:

It looks and feels very similar to the guitar version, so it's quite natural to pick up despite the different scale layout (the one bit that trips up my six-stringer brain is the open A, but that's not too bad. I guess I could grab it on the third string (seventh fret), though. I'll have to experiment and see which version sounds better³).

I played with it for a while, and then wondered why I couldn't seem to recall hearing that particular move played on mandolin.

I could be way off base, here. I haven't really gone fishing for mandolin licks yet, and mostly kept to exploring the fretboard on my own. Also, my ear isn't that great, and seems to recognize familiar patterns rather than actual notes or melodic motifs, so while I enjoy hearing other instruments doing their thing, I often have a hard time figuring out what they're playing.

Still, that color is distinctive enough that it feels like I should recognize it when it happens.

I'm sure it does crop up and that I'll think of an example right after publishing this article. But assuming it is used less often, the reason why is probably pretty simple.

Bluegrass guitar player are infamous for using capos and playing everything out of G or C, so the Watson lick is always right under our fingers. Also, Doc was such a huge influence on the genre that you're bound to come across it over and over, so it's no wonder that it quickly becomes a no-brainer.

Mandolinists tend not to use cheaters so much,⁴ though, and while you could move this lick to a closed position,⁵ it kind of needs the third to fall on an open string to truly shine, which drastically limits the number of keys where it's available or convenient.

The version I notated above is in C, and moving it to the lower strings lands you in F or in B flat, which are much less common than A or D in Bluegrass or Old Time music.

They do happen, though, and they're also a lot more common in jazz, so I hope I'll think of it next time I end up jamming on a swing tune. Haven't tried it yet, but I'm pretty sure it'll fit and I would hate to miss the chance to troll jazzers with some country twang.

So try it out when you get a chance. Stealing from other instruments is always fun, and stealing from Doc is even better. There's no reason why guitarists should be the only ones allowed to do so.

Here's one more for the road, this time in context (if playing at random and out of time qualifies as "context"):

See ya internet, and keep on picking!

Coming from me, "amateur" is not a slur.

In fact, I'd argue that we should have something like it for all other art forms. Theater, painting, hula hooping...

Amateur art is important, and should be encouraged and celebrated, but why should music be the only discipline to get its national day ? ↩
What do you mean, those would have been more useful had them been published before music day ? ↩
I suspect they'll both sound fine on their own but have a slightly different feel that will fit better depending on the situation. That's how those things usually turn out. ↩
I used to wonder why, but I'm starting to get it. Mandolin, at least in Bluegrass, tend to rely a lot less on open strings (especially when playing backup, when you don't want anything ringing), so capos just don't make as much sense.

I'll still look for a chance to use one just to piss off the purists, though. ↩
A six fret span on the mandolin is only slightly uncomfortable, which sounds crazy to my guitarist's brain. ↩

A pelican plugin to avoid publishing drafts

2026-06-24T14:00:00+02:00

So I messed up a few days ago and accidentally published a draft that got picked up by various RSS aggregators and I felt pretty dumb about it.

Turns out those aggregators routinely check for dead links and suppress them, so the entry disapeared on its own after a few hours.

But still, knowing myself, I'm sure it'll happen again and I'd rather avoid spamming unfinished crap into people's feeds if I can, so I started thinking about setting up some guard rails.

First thing that came to mind was to use git hooks, or maybe Forgejo's equivalent to Github actions, and basically only deploy the site when articles get pushed to the remote repository.

But thinking about it more, I realized that:

It's way too hot to read documentation.
Generating the site on a push means I would have to do it on the server.

The second point is not such a big deal, but right now I'm building the site on my local machine and uploading the results via a simple rsync, and I love the simplicity of this setup.

That's the whole beauty of static sites.

So if I ever need something fancier for deployment, I'll get to it, but until then I'd rather keep my current process.

Well. Let's turn the problem around. Rather than building the site when content gets pushed, let's instead check the local repository as we generate the articles.

Easiest way to do that was to write a pelican plugin, so that's what I did. Here's what I ended up with if anyone cares:

import logging
import subprocess

from pelican import signals


def warn_and_skip(msg, skip, generator, article):
    if skip:
        msg += "\nSkipping article generation"
        generator.articles.remove(article)
    logging.warning(msg)


def skip_outta_git(generator):

    # NOTE: this gets called *after* filtering out articles that pelican already
    # skips (like those with a draft status), so no need to explicitely check
    # for the "published" flag.

    # Bail out if the plugin is disabled
    if not generator.settings.get("GIT_CHECK_ENABLED", True):
        return

    skip_ignored = generator.settings.get("GIT_SKIP_IGNORED", True)
    skip_modified = generator.settings.get("GIT_SKIP_MODIFIED", False)
    skip_untracked = generator.settings.get("GIT_SKIP_UNTRACKED", True)

    for article in generator.articles.copy():
        src_path = article.source_path
        # Check for ignored files. This may be overkill, but better to err on
        # the side of caution.
        if skip_ignored:
            proc_check_ignore_return_code = subprocess.call(
                ["git", "check-ignore", "-q", src_path])
            if not proc_check_ignore_return_code:
                warn_and_skip(
                    f"{src_path} is set to published, but is ignored by git.",
                    skip_ignored, generator, article)
                continue
        # Check for untracked files or uncommited changes.
        proc_check_status = subprocess.run(
            ["git", "status", "--porcelain=1", src_path],
            capture_output=True,
            text=True)
        if (output := proc_check_status.stdout):
            if output.startswith(" M"):
                warn_and_skip(
                    f"{src_path} contains unstaged modification.",
                    skip_modified, generator, article)
            elif output.startswith("??"):
                warn_and_skip(
                    f"{src_path} is set to published but is not tracked in git.",
                    skip_untracked, generator, article)
            # Log and skip any other output, just to be safe.
            else:
                warn_and_skip(
                    f"git status --porcelain=1 {src_path}: {output}",
                    True, generator, article)


def register():
    """ Pelican plugin registration. """
    signals.article_generator_pretaxonomy.connect(skip_outta_git)

So now the blog will simply skip generating an article if its markdown source file is not tracked by git yet, hopefully ensuring that I won't publish a draft again.

I can disable it in my local pelicanconf.py to check stuff on my machine, and as long as I override it in publishconf.py, I should be fine if I decide to deploy minor edits in the meantime.

But truly, the real highlight of this afternoon project was that I got to use the morse (:=) operator, which always makes me happy.

So it works, but as I started writing this note, I realized it had one pretty big flaw: What if I decide to commit a draft ?

Now that the file is checked in, the current code will let it pass. I'll get a warning if I make a modification afterwards, but the more likely scenario looks more like:

Commit and push some changes, planning to finish the article later
Go do something else
Get back to the site, get distracted and start tweaking something unrelated, and decide to publish that tweak, confident that my system has my back.
Get burned. Again.

Sure, I'll be fine as long I make sure to check the article's status. But then I'm back to square one. Catching that very mistake is the whole point of writing the damned code.

Up until now, I've always edited my posts on the same machine and haven't felt the need to track changes until an article is basically done. The only reason I check them in to begin with is so the repo can serve as a "backup" of what's been published.

So this isn't a problem for me right now, but what if I change my mind ?

Guardrails that only work on specific conditions are effectively useless, and now that I spotted the problem, this false sense of security is making me nervous.

Guess I'll have to think of something else.

An exercise in simplification

This post is getting long already, so I'll spare you the details of what happened next.

I got the idea of checking the live site's RSS feed, and use that to tell if an article is already public as pelican generates them. It worked, but as I started cleaning up the code I realized, why bother ?

I could just keep a list of all published urls in a local file. As the site gets generated, I can just check for any article not already listed and ask the user for a confirmation, adding it to the list if it gets approved.

It's dumb and simple, reliable, and doesn't depend on specific habits that may or may not fit the situation. No magic, no trying to be clever. Just a quick explicit prompt to avoid getting caught with my pants down. The published cache can be checked in version control with everything else, and correcting any mistake is a simple edit.

So that's what I went with. Generating the initial list is a bit annoying, as you have to manually approve every single post that is already live,¹ but once that's done pelican will systematically ask me to confirm whether or not I want to include any new article whenever I built the site. Here's what it looks like in practice:

(rgaz) raphi@raphi-MS-7821:~/dev/web/rgaz$ make html
"pelican" "/home/raphi/dev/web/rgaz/content" -o "/home/raphi/dev/web/rgaz/output" -s "/home/raphi/dev/web/rgaz/pelicanconf.py"
Article "test_ignored" has not yet been published.
Ship it [y/n] (n) ? nope
Article "test_untracked" has not yet been published.
Ship it [y/n] (n) ? go away
Article "A pelican plugin to avoid publishing drafts" has not yet been published.
Ship it [y/n] (n) ? yup
[09:45:16] WARNING  Skipping: blog/test_ignored/                                                                   plugin.py:98
           WARNING  Skipping: blog/test_untracked/                                                                 plugin.py:98
Done: Processed 37 articles, 22 drafts, 0 hidden articles, 2 pages, 0 hidden pages and 0 draft pages in 0.85 seconds.

It's a bit annoying to use locally, as the devserver loop messes up the input and basically breaks everything, so I've disabled it in my local pelicanconf.py, and make sure to activate it in publishconf.py so that I get the prompts when it actually matters.

Also, the code is a lot simpler than what I had before.² Sadly the morse operator is gone, though =(

Maybe I'll polish it a bit and upload it to pypi. I tend to avoid doing so, as most of the stuff I've been hacking together lately is pretty quick and dirty and is usually tailored to my specific needs, and I'd rather avoit polluting the official index with code that may very well be useless to anyone but me.³

But this thing seems generic enough that it just might be useful to someone else, so I dunno. I'll test drive it for a little and see how it goes.

In the meantime, the repository is public, so you can pip install git+https://git.rgaz.fr/raphi/pelican_shipit it if you really want to.

See ya, Internets. Can't wait to see what my next stupid goof will look like.

Edit 2026/06/25:

I renamed the plugin from the lame check_published to shipit, because I felt like it. I've updated the repository's url above.

Adding a script to automatically generate it should be easy enough, though. ↩
I do have to do some shenanigans to ensure the code only runs when I want it to, but nothing too bad. ↩
The proliferation of useless libraries is a real problem. Many of them done by eager beginners that don't realize the problems they're trying to solve just aren't that interesting, of much of a real problem to begin with.

Of course I've been that beginner. Hopefully I've learned some restraint since then. ↩