Felix Rambles

This was supposed to happen a month from now, but it's been so quiet around here lately, it makes no sense to wait.

As you've probably guessed, I'm ending the blog. Should have announced it earlier, sorry. Since last autumn, I've been posting a lot more on my linklog, not to mention the new journal. And long-form writing is best placed in specific site sections anyway. Besides, like I wrote elsewhere some time ago, it's best for blogs to end at some point, not unlike books. Get it out of your system, rest for a while, start again elsewhere when you feel up to it. Makes sense to me.

Besides, I achieved my initial goal with the blog, namely finding my own voice online again. Achievement unlocked!

Naturally, the archive will remain in place for now. That's the beauty with static site generators: what you write stays put. Almost makes up for the hassle of using them.

Then again, next time I'll know to do it better. That's what experience is for.

Before ending this post: we live in uncertain times. Not sure how much longer this site will be able to stay up. Got the domain paid til next August, at least. See, the problem with our commercial internet is, it doesn't last. I'd call for academia to take over again, except academia has also become largely commercial.

Good people have been working to set things straight again, but it's an uphill struggle. Seek them out. Try to help.

Thanks for staying with me. See you around.

This is probably nothing new, but whatever. One of the reason why humans were so successful is that unlike most species (except crows apparently) we posess a theory of mind. In plain English: we're aware that we're thinking, so we can reason about our own thought processes; we know what we know and what we don't, and adjust our strategies accordingly. This proved so useful, some thousands of years ago we gave it a name: philosophy.

But what is philosophy, more exactly? Wiktionary offers several definitions, among which: a comprehensive system of belief; a general principle; an academic discipline that seeks truth through reasoning rather than empiricism.

This last one is relevant here, because as it turns out, a lot of useful truths are abstract, so you can't apply empiricism to them. Take for instance the concept of transitivity: if consolidation of capital creates poverty, and poverty creates crime, does that mean unbridled capitalism creates crime (then calls the cops to clean up its mess)?

Oh wait, that's not abstract. Or rather, poverty and crime aren't. Responsibility, now that's been a matter of debate for centuries. Likely because nobody wants to bear it, so we keep making up complicated ways to pass it around. Much like with money and debt, go figure.

By now self-driving cars have killed multiple people, and we still haven't figured out who should be held responsible.

It's easy to blame technocracy for that, too. The idea that only "hard" sciences are valid, and that political decisions can somehow be "objective". I was reading about it just the other day in fact, by pure coincidence.

But frankly, I blame 19th century philosophers: privileged white men who spent their time in ivory towers thinking of ways to justify genocide in-between teaching at some fancy European college. And that's a lot of damage to undo.

I rant about this tendency all the time, but inventing the wheel again isn't bad as such. After all, the wheel had to be reinvented a few times over the past two centuries or so. For trains. For cars. For moon buggies. So why all the discontent when people do the same thing in IT?

The first (and least) problem is needless reinvention. By all means, do it if you have to. Not because you don't like what color the wheel is painted.

But mostly, invention is only the first step. From there to making it usable by anyone you have more work to do. Lots and lots of boring work. My favorite example: the turbojet engine. First invented in 1930, they took two more decades (or four, depending on how you count) to become commonplace. What took so long? Countless engineers the world over worked their asses off to turn the invention into a product, that could be safely used by millions on a daily basis.

That's the problem with invention, see. The world's first wheels were probably wonky too. Who knows how long it took wheelwrights to figure out how to make them smooth and balanced, never mind reliably so.

And inventors don't like putting in all that work. That's what killed most of Clive Sinclair's brilliant inventions, too. Even his wildly successful home computers were infamously wonky. Some of the bugs were never fixed.

If airplanes worked that way, they'd be falling out of the sky all the time. You know, like they used to a century and change ago. We couldn't rely on them.

Luckily, we have engineers around. I mean trained engineers, as opposed to code monkeys who slap the "e" word on their business cards cause it sounds cool.

As I struggle to complete a web port of my new Babble programming language, I set some time aside to have a little fun.

Ever since the Turbo Pascal IDE introduced countless bedroom coders to syntax highlighting, it's been hard to imagine programming without this little feature. Modern text editors often come with support for dozens or hundreds of languages. It helps the eye a lot, and makes the screen come to life. In fact I've argued in the past that the now-common C syntax was at first a form of syntax highlighting, making it easy to visually pick up variables from operators at a glance.

It's not the same without colors however, and this is especially noticeable when using a new or lesser-known language, that text editors display as-is. Luckily in many editors it's easy enough to add support for your favorite, and it makes a big difference. My little toy now feels real! But support for doing so differs considerably between editors, with equally varied results, so this ended up being a journey in itself.

Turns out I have no less than five programmer's editors installed (not counting a couple of Basic environments): Geany and Mousepad on the desktop, then Nano, Micro and mcedit in the console. Guess which set was easier to work with.

Belated happy New Year 2022! In my previous blog post, I wrote about ways to make a text user interface in Linux / Mac / BSD. That's all good and well, but comes with various disadvantages, depending on the method chosen. And if you're running locally, on a machine with a graphical desktop, you might want to have a nice GUI after all.

Now, if your programming language of choice has access to a toolkit such as Tk, then you're all set, in principle. In practice, it can be a lot of work, and arguably overkill for simple scripts. But what else to do? Obviously, there isn't an equivalent of tput or ANSI escape codes for the desktop -- it's nowhere near so simple. Luckily, other options exist.

As the name suggests, Xdialog is a graphical clone of its text-based counterpart, that tries hard to be compatible (and the other way around). Sadly, its latest version is so old it uses Gtk 1.2! Good luck finding either packaged for a modern Linux distribution.

A more reliable option is Zenity, that's part of Gtk3 and usually preinstalled along with it. It has simplified command line options compared to (X)dialog, but in return features modern controls like a tabular list and desktop notifications. It also makes it much easier to use forms, for example. Plus, certain controls can receive their data on standard input and thus handle a lot more than if it came from the command line. See the official manual and this year-old blog post for how to use it (the manual page is simply insufficient).

Last but not least, there's yad, a fork of Zenity with more controls, more field types and so on. Its last release was more than four years ago, but that's not a problem just yet.

Either of these should be easier to use from more languages than the text-based dialog, seeing how you don't need to fiddle with temporary files or capturing standard error. And choice is a good thing. Have fun making more software!

With one week to go, I have one more blog post in my budget for this year. Might as well make it something fun.

Text user interfaces always have a place even with today's advanced computers. They're fast, accessible, and can run over a network without ever being aware of it; a rare example of transparency. And there are several different ways to make one, at least in Linux.

Now if your language of choice has access to the curses API, or another terminal control library, guess you're all set. But it's often just not an option in your target environment. What to do then?

The venerable Dialog utility (based on ncurses, and maintained by the same person for the past couple of decades) is one option: a small program that can handle a variety of common interactions like choosing a file to open, or entering dates, while looking good and being easy enough to use. It's also easy to call from Python thanks to a popular wrapper library, but also from Tcl or shell script for example. Just make sure it's installed where you need it.

Kind of opposite from Dialog sits tput, that always comes with (n)curses, though usually in a separate package with various names. This is a low-level alternative, for when you just want to move the cursor here and there and show colorful text all over the screen. It also needs to run once per operation, and that adds up quickly. To fix that we must dig even deeper. Beware of Balrog.

So, a friend just pointed me at this; Winged Gods and walking griffons: A plate with a depiction of Scythian Gods has been found in Middle Don.

Oh, really? Dear archaeologists: nowadays we depict famous singers with wings and the like. Doesn't mean we consider them literal deities¹. Is that what your colleagues will assume about our present civilization in two thousand years?

¹) Or rather: we kind of treat them that way, but we're also in on the joke.

The Ancients weren't stupid. In fact they were mostly like us. Except for one thing: they had a very different worldview. Even today, other cultures don't share the western civilization's obsession with a pretend, impossible scientific objectivity, and instead adopt more nuanced stances.

Which reminds me that European alchemists likely didn't believe in literal angels and demons. They were simply trying to build a conceptual framework for dealing with new discoveries, and their language included spirituality because it was part of their lives. How else? We've tried reductionism, and look where it got us: treating people like cogs in a machine. Abstractions. Statistics.

They weren't any smarter than us in the past, either. But often much wiser.

Eight months ago, I (re)learned the Nim programming language, as mentioned in a blog post at the time. It proved a good choice for a handful of filler projects, but nothing else since. For some others it just didn't work out. And I dismissed that as normal... until yesterday, when the official website published the transcript of a conference presentation from earlier this year, named Zen of Nim

How badly I misunderstood this language and its creator. To wit:

If the compiler cannot reason about the code, neither can the programmer.

Unh... Look. You... realize the compiler is a dumb machine, while the programmer is a human being, right? Who is almost certainly about as intelligent as you are. Which is much less than you think you are. Otherwise you'd trust your fellow programmers a little, or at least give them the benefit of the doubt.

There should be one and only one programming language for everything.

That... is just plain dangerous, in addition to being false. Monocultures are a recipe for disaster, for many reasons.

I stopped reading at that point, but now I'm thinking. Ours is a culture of arrogance, itself built on top of a mentality that values "intelligence" (or rather a narrow, skewed definition thereof) above all else, including practicality, never mind the actual needs of others. But this is too much.

Having a safety on your gun is good. Having to solve a sliding puzzle every time you need to fire the gun makes it useless.

And that's why Python is the most popular language in the world right now, while this new crop of compiled languages struggles to find adopters. Unless, of course, they have the backing of Google or Mozilla, with their marketing power.

Funny that, I thought it was a meritocracy, where the best X genuinely wins.

It keeps coming up lately, but not quite like this. Free Software is an Abject Failure sounds inflammatory, but please go read, and consider the arguments. Warning: it's long.

Did you? Good. Now you know how people fight and win Communist revolutions only to become dictators and install a totalitarian regime with centralized economy instead of the Communism they promised.

Tip: even a commons has owners. It doesn't "belong to everybody". At the very least, resources need caretakers. And one thing any caretaker must do is fend off vandals. That's exclusionary by definition. It has to be, in order to keep those resources in good condition for everyone else's benefit.

The fires of idealism are necessary to set things in motion. But they must be tempered by the cold shower of pragmatic concerns, lest you burn down the very thing you were trying to build.

Funny how software proves yet again to be a social, which is to say political, issue. You know, as opposed to an exercise in abstraction, somehow divorced from its real-world uses.

I don't have any solutions. The Commons Clause, an add-on for liberal licenses, looks like it could help. And the Artistic License 2.0 is a statement I like. But ultimately we need to figure out better ways of working together, because neither law nor tech are enough by themselves.

There are still good ways and bad ways to do it. Don't turn into a dinosaur.

I'm always on the lookout for more software to get creative with, but not every week brings such a bounty: three of them coming one after another, all so useful and fun I can't wait to show everyone. Follow me.

For one: I already knew about the *ledger family of apps, but hadn't paid much attention before coming across the Plain Text Accounting website. And it's fascinating. While my trial run lasted less than a week, for various reasons, ledger-likes prove easy to use and educational. If you happen to use Debian, the top three are available in the repositories, having reasonable size and dependencies.

Speaking of Debian. While looking for something to inspect JSON files with, I found much more: VisiData, a tool to view, explore and manipulate (mainly) tabular files such as CSV, but also capable of dealing with formats from SQLite databases, through XML and even zip archives or directories on disk. I have an old version here, but it's still plenty useful. Just somewhat cryptic initially, but documentation helps.

Last but not least: if the previous two seem too nerdy, I also looked at a bunch of Kanban board apps, and one of them is unexpectedly nice: Nullboard runs in any mainstream browser, saving data to local storage and/or files. It's also simple, clear, fast and works as advertised. Very lightweight, too. Not my thing to be honest, but it's a different way of looking at things and I might find a use for it yet.

Thought there would be more to say about one or two of them at least, but not today. Until further updates, enjoy, and remember: stay curious! You never know what other people thought of that could inform your work in novel ways.