Andrey Listopadov

GNOME is better macOS than macOS

Sun, 23 Nov 2025 02:57:00 +0300

Recently, I bought my first-ever MacBook. I’ve spent some time with it, and I gotta say - despite all that hot garbage that is thrown at GNOME for being an OSX clone, GNOME does the job better than I’ve expected, and certainly better than Apple. In some areas, that is.

Good old days of Linux

A bit of a backstory.

I’ve been using GNUplusSlashLinux for more than fifteen years. Most of the time, I used GNOME, starting from GNOME2, moving to Unity maybe for two years, then GNOME Shell, then KDE Plasma 5 for another two years, and switched back to GNOME Shell again. I’m not mentioning some of my at most month-long endeavors to other DEs, like XFCE, or tiling WMs, because they never stuck with me. So I’ve been there for most releases of GNOME Shell, followed them closely, even used to run Ubuntu GNOME when GNOME Shell became a thing, until it became the default in Ubuntu once again. Though by that time, I had already moved from Ubuntu to a different distribution for a variety of reasons.

I wasn’t always satisfied by GNOME, and was a fair bit vocal about it in the past - even got myself banned from r/gnome subreddit, for shitting on it too much. That’s why I experimented with other desktop environments, particularly Unity and KDE.

Unity felt like a breath of fresh air after GNOME2, mostly because Canonical took years of people trying to make GNOME2 more OSX-like, and made decent steps in that direction. A global menu, HUD, blur, buttons on the left - you name it, it was there. Granted, it wasn’t an OSX clone - rather, it was its own thing, and I still remember Unity days fondly.

Figure 1: Honestly, this was the best desktop

I switched to GNOME Shell almost instantly as it was released as Ubuntu GNOME spin, and while it was a bit janky, Unity started to lose steam, and GNOME looked like a hot new thing.

Figure 2: Anyone else remember that wallpaper? GNOME sure has come a long way

I did, however, run Unity on my older PCs, as it was far less taxing on resources than early versions of GNOME3, but then it was discontinued, and long-awaited Unity 8 with Mir never became a thing. So, when I was fed up with GNOME being a resource hog, often crashing, and moving towards Wayland, which didn’t work as good as it was advertised, I decided to try KDE somewhere around 2018.

And boy, how wrong was I, thinking that KDE is a buggy mess that would drain my resources even worse than GNOME. KDE Plasma 5 was nothing like I imagined - it was fast, lightweight, and slick. As a fan of old Unity design and OSX looks, I’ve configured my plasma, but it wasn’t a full clone, as other people often did. Instead, I tried to keep Plasma look like Plasma, but feel like a mix between Unity and OSX:

Figure 3: To this day, I still think this was beautiful. I’ve spent a lot of time fiddling with icon spacings in the top panel, combining widgets, writing my own in QML, just to throw it all away, a few years later

I’ve run Plasma 5 for about two years, and while I was enjoying it, there still were a lot of jank, bugs, occasional crashes (although Plasma recovered from them beautifully), but GNOME also became a lot better. So I switched back to GNOME, and I’m still running it on my old laptop, where I’m writing this part of the text right now:

Figure 4: GNOME 42 (Note, I have a 2K display and use GNOME without scaling with enlarged fonts. Helps a lot with too big GNOME UI elements taking up space)

As you can see, there are no fancy extensions - everything is the same as in a stock Fedora Workstation, because it is a stock Fedora Workstation. And I love it.

Over the years, I had a love-hate relationship with GNOME, but after a while, I came to accept it as it is, and now it feels like a perfect desktop environment for me personally. That, of course, is thanks to GNOME developers actually trying to make GNOME better, and me buying into their vision of what an OS should look and feel like. There is still some jankiness to it, but I’m willing to overlook it at this point, because after years of searching, I couldn’t find anything that suits my workflow better. And I’m fine with that.

A disclaimer

Before I go crazy on bashing macOS, I need to make a disclosure - I AM BIASED. I’ve been using GNOME for a lot of time, and a lot of things that feel logical to me may not feel logical at all to others. Especially for macOS users.

I’m fully aware of that.

Now, with that outta the way, let’s begin.

A new laptop

As I mentioned, I’ve just got myself a MacBook. I did it because today’s laptop market is a bit odd. It’s hard to find a decent non-gaming laptop with good specs. I mean, there are Lenovo ThinkPads, ThinkBooks, and even IdeaPads that are decent, but I already owned an IdeaPad, and while it served me for six years and I liked it, I don’t know if I want another one. Other brands may offer similar hardware, but I didn’t investigate much.

One of the reasons is OS choices. You see, I have run Linux as my main OS since around 2008. But I still have to use Windows from time to time. During university years, most of the non-programming software was Windows-only. After university, I had to use Windows to do media stuff, like music recording and video production, or design.

Design is probably the only task Linux can handle without much of a hassle, given that there are decent programs for that. For instance, I don’t mind GIMP, Krita, or Inkscape for most of my image-related tasks. I can even do video editing in Blender (and I do), but for some reason, it just works better under Windows. Audio production - not a chance. You’ll find me dead in the ground before I figure out how to set up a realtime kernel and configure Jack. Not to mention, VSTs just don’t work because many are relying on Windows APIs, and patching them through Wine is not a path I would like to walk.

So I had to use Windows, constantly rebooting from Linux to it every time I wanted to record myself, or work on some video for my channel. And I also had to use the one that came with my laptop - 6 years ago, it was Windows 10.

My parents recently got a new laptop with Windows 11 on it, and my god, it is horrible. After using Linux for more than fifteen years, I can’t even imagine how Microsoft is still able to get away with it. Ads are everywhere - on the lockscreen, in the start menu, in notifications, etc. You can’t even activate it without connecting to the network and signing into a Microsoft account.

Oh, and updates. Fucking updates are being forced, while I’m waiting for the next 5 hours until my video finishes rendering, because my laptop is too old to render in 4K.

Yes, it’s possible to “debloat” Windows, remove most of the jank they added, disable automatic updates, and have a decent, clean experience. I just don’t want to do that. The whole point of an operating system, to me, is to stay out of the way while managing resources, processes, and making sure my shit is done without major hiccups.

Now, when Windows 10 support is ending, all we’re left with is Windows 11, and god knows what bullshit awaits us in Windows 12.

So I thought to myself: “Ok, I like Linux, but I want to be able to do my media-related stuff, and I don’t want to invest in making Linux be able to do so. What options do I have other than that?” I just applied to a new job, and almost everyone there uses a Mac, and many of them are musicians, either hobbyists like myself or even professionals. After asking around, it appeared to me that switching to macOS could be the solution I’m looking for. It’s a Unix, so I guess my Linux habits won’t have to go through WSL hoops, and it has world-class support for media tasks. I think macOS can even be considered media-first when it comes to production, unlike Linux or Windows.

So I saved some money and got myself a new MacBook Pro, with M4, and decent specs. While the laptop itself is nice - I like the aluminium body, keyboard is nice (although I had an opportunity of using their butterfly one, and liked it better), the screen is gorgeous, and even the laptop speakers are great, but…

…but the OS…

macOS

This is the most counter-intuitive, user-unfriendly, confusing piece of software that I’ve used in my life. And I worked as a consultant in a cellphone store and used software for cashiers, yet it still was not as horrid.

I’m sure nothing I will write here will be new, and I’m committing an “internet crime” of “beating a dead horse” here, while it’s probably already reduced to vapors, but I still want to get it out of my system.

The Desktop

My laptop came with macOS 15 Sequoia preinstalled, so I haven’t used previous versions much, although I had used a Mac a bunch of times in the past when I was at the university ten plus years ago. However, I decided to immediately upgrade to the 26.1 Tahoe, so I wouldn’t get too used to the good-looking interface, and instead learn to get comfortable with this liquid glass crap. So I didn’t touch macOS for some years, and some things have changed, but the majority of annoyances I remember are still here.

A note on different desktops/WMs for macOS

I’ve started receiving some comments on this post, and I’d like to clarify that I’m aware of other window manager alternatives for macOS, like AeroSpace, Yabai and the like.

First, I’m not a fan of tiling window managers. Personally, I almost always have one window per desktop. Tiling never stuck with me. I’ve tried it several times during these fifteen plus years, and I don’t really feel the need for a keyboard-driven environment besides my Emacs. I mostly use touchpad gestures and the overview/mission control feature when I need to switch windows.

Secondly, I don’t really have that many issues with the current macOS WM, and I don’t really want to replace it. I was a GNOME user, remember?

Virtual desktops

As an ex-GNOME user, I like my virtual desktops. MacOS has had virtual desktops for a long time, but I think GNOME handled those better.

First of all, switching with the touchpad gesture feels a lot slower. In GNOME, it wasn’t an animation - the speed was tied directly to how fast you move your fingers, with easing after you release them. I got used to switching between desktops with a lot of speed, and on macOS, it’s not like that.

It seems it is also tied to the speed of the gesture, but it feels like there’s a cap on the maximum possible speed:

Your browser does not support the video tag.

An additional feature of GNOME is that it will automatically create additional virtual desktops once you’ve filled all of them, and there’s no limit to how many you can have. I usually have 4-5 desktops, but when I’m not working on something, it’s nice that I can only have one or two.

In macOS, you can have as many desktops as you want, however, they’re not added automatically. Or at least I couldn’t find a setting for that. Because of that, even if I’m not using all of them, sometimes a stray window is sitting on the last desktop, and I have to go through all of them to get to it.

Fullscreen and maximize button

For some reason, the developers decided that the maximize button should instead act like a fullscreen button in macOS. When you maximize a window, it is moved to its own, dedicated virtual desktop - and I like it. I have used this pattern in GNOME for a long time by installing an extension that brings this feature into GNOME.

However, and it is a big however, in GNOME, when I maximize a window, it creates a virtual desktop next to the one I’m on. In macOS, it also creates a virtual desktop, but it moves it to the far right.

So, imagine I’m browsing the web, seeing something interesting, and I want to open Emacs to take a note. I open Emacs, maximize it, and on the desktop to the left of Emacs, I still have my browser, and I can switch between these back and forth. In macOS, if I do this, the window is moved to a desktop at the far end of the list of desktops. You can rearrange those manually, but it’s clumsy. I would much prefer if the desktop were created to the right of the current one.

Figure 5: Emacs was opend on Desktop 1, but after maximizing it is now essentially at Desktop 5

You can prevent this, in some form, by turning on the “Automatically rearrange Spaces based on most recent use” in the settings. Then, a new fullscreen desktop is created to the right of the one you’re currently on, which is nice, however, then the spaces get rearranged all the time. Like, when you’re opening a link from the messenger, you switch to a desktop that has the browser open. The spaces get rearranged, such that the desktop with the messenger is next to the one with the browser, so you have to find the other one that previously was inbetween. It’s so bizarre that we can’t have fullscreen spaces created next to the current one without automatic rearrangement.

And, because it is a fullscreen mode, it also makes things go a bit haywire for some applications. Emacs doesn’t like this mode in particular.

Right now, I’m using four virtual desktops and manually organizing those, but maybe I need to adjust my usage pattern. Speaking of virtual desktops, let’s look at the Mission Control thing.

Mission Control

That’s another pain point for me. You see, GNOME also has something akin to Mission Control - you swipe up with three fingers, and you see all your open windows:

You can then move your windows between desktops or switch between them.

MacOS also has this, with the exact same gesture:

However, it is far less useful.

In GNOME, I can close windows in the Overview:

Figure 6: This close button is part of the Overview, not the window manager

I can tweak the dock:

Figure 7: Actually, the dock is only visible in Overview

I can start typing, and the search appears:

I can even swipe up again and bring up the applications menu:

Figure 8: Not that I use it that much though

There’s a lot of control! Wanna know how much you can control in the Mission Control?

You can move windows and desktops around.

…

That’s it!

What mission? What control? You can’t do anything.

Sure, one advantage macOS’ mission control has is that you can move entire desktops around - in GNOME, you can’t rearrange desktops themselves, only windows. And it plays nicely, with all this full-screen nonsense, but I still much prefer the GNOME approach here.

The Dock

Dock is a weird concept. It’s cool to have it, and I remember in my early Linux days I wanted a macOS-like dock so badly that I tried to make it out of existing panels and custom widgets. I installed various dock plugins in my desktop environments just to have it zoom in on icons when I hover over them. These days are long past.

Figure 9: remember Cairo dock?

Figure 10: remember Plank?

GNOME made a smart decision to only show the dock when you’re in Overview - their “Mission Control” variant. You don’t need the dock constantly taking vertical space from your windows, and you don’t have to deal with it showing up accidentally when you simply hover the mouse pointer at the bottom of the screen. Or at the side of the screen if it is your thing.

When it is only inside the Overview/Mission control, it makes sense as a favorites bar and a way of switching between applications. I haven’t used Alt+Tab (or ⌘ command+⭾ Tab) in years because of that. I would much prefer for the dock to be only visible in Mission Control, but sadly, there’s no way of doing it in macOS, as far as I can see. Moreover, Dock becomes useless in Mission Control specifically, so it won’t work that well in macOS.

What baffles me is that when you close an app, it stays in the dock, taking up space. Again, there seems to be no way of disabling it. Disabling the “Show suggested and recent apps in Dock” in system settings doesn’t affect this behavior.

You have to either use ⌘ Q, or right-click on the dock item and choose “close”. What’s the red button in the window for then? Usually, the app simply continues working in the background, as if minimized.

Speaking of which, so far only the minimize button seems to work in a sane manner.

Sure, there’s little point in actually closing applications, given that this laptop has a lot of RAM and CPU power, but it always felt weird to me that apps want to stay open all the time. I’m done with you - why do you think that you’re so important that you shouldn’t be closed? Do what you’ve been told.

The Finder

Linux has always had weird file managers. To me, nothing beats Microsoft’s Windows 7 file explorer - it was the least BS one in my opinion. GNOME’s Nautilus, or Files, as it is called nowadays, had a few long-standing problems, some of which date back ten plus years. KDE’s Dolphin was nice, but too had some weird quirks. However, it’s nothing in comparison to macOS Finder.

See the screenshot?

A normal file view, right? Now, what should happen if I shrink the window?

Your browser does not support the video tag.

The what? Who thought that this was a good idea? For those who didn’t get it, the grid of items remains the same despite the size of the window! Like, seriously?

The oddities don’t end there. Where’s the current path? For some reason, you can only see it when holding the ⌥ option, it appears at the bottom of the window. You can, in fact, toggle it in the settings so it is always shown, and while you can click on it to navigate, you can’t edit it, as it seems.

What really baffles me though is that it seems impossible to shift-select multiple files in grid view - only in list view. Even though, if you do shift-select files in list view, and switch back to the grid view, files stay selected. Seems to be related to how the media viewer works.

Another oddity is that when moving directories around, there’s no option to merge directories with the same name by default. I mean, when I move a directory to a different place, where another directory exists with the same name, I expect them to be merged, but the pop-up only says this:

When the ⌥ option key is pressed preemptively and held during the drag, the option to merge directories appears:

Like, you need to know, before the hand, that the target location you’ve chosen contains a folder with the same name you’re moving right now. And if you didn’t, you need to repeat the drag. Why not show it by default?

For the record, when the same thing is done in the GNOME file manager, it asks you if you want to merge directories, but you can’t replace them, so you can’t ever lose data. And if it contains files with the same names, it asks for each file if you want to replace it, or keep both. Of course, you can choose to replace all files, so it wouldn’t drag:

Cutting files is also super weird. You first copy the file as normal, then proceed to the directory you want to move the file, and press ⌘ command+⌥ option+v. Not only does the shortcut itself make your hand curl up as if you were a lobster, but also the semantics of this operation feel extremely weird - you copied the file, after all, why would it move afterwards? I guess, it’ handy in cases when you thought you wanted to copy the file, but you actually decided to move it, so you don’t need to input a whole new shortcut again, but it’s a minor win in my book.

Thankfully, I use graphical file managers rarely, so I can continue living in my comfort zone of Emacs’ DIRED.

Files and folders

But, while we’re at it, let’s talk about files in general.

I have some local music stored in the Music folder. Some videos and films are stored in the Videos folder. I also have pictures stored in the Pictures folder.

Crazy, right? Imagine using the file system to store files systematically?

I also try to keep things organized, so I manage all these with some directories, like band-name/album-name/track-name in case of music files, or year/place-name/photo in case of photos. I like it because if I want to listen to something, I can just drop the folder into the player, or open the image folder and relive those moments. Organizing these with folders is also handy for backing these things up - just drop the folder to the external drive and you’re good to go.

In macOS, as it seems, tags are the way the system wants to work with files. It’s a different approach, and I’m not entirely opposed to that, since filesystems are an illusion, after all.

But every once in a while, I open the Music folder, and I see a second Music folder inside it. Apparently, it is created when opening the Music app. I can’t use the Music app because it can’t play FLAC, which is what the majority of my local library is encoded in.

When I open the Videos folder, I often find a TV folder inside. I’m not sure what app creates it, but it wasn’t done by me, as I never launched the TV app. And it appears there far more regularly than the Music/Music one.

Other apps often create their own folders anywhere they want. The OrbStack app creates an OrbStack folder in $HOME. Some other app I installed created a folder in the Music folder for some reason, even though it didn’t store music in it, just some audio files.

It feels like that this is not my computer, but one I share with everyone else, and watch they do as they please with my filesystem. Never once was this a problem in Linux.

Why can’t apps keep their files to themselves? I’m tempted to create things like Music/My Music, or Pictures/My Pictures, and use them specifically, forgetting about the default Music, Pictures, Videos thing, but it is such a cumbersome solution. It feels like, when you invite friends to a party, and they go to your bookshelf, and decide that they’ll put some of their own stuff on it for the time being. And when they leave, they forget to take their stuff, but you don’t want to touch it, as it is not exactly yours. And you can’t throw it out, as your friends will be mad.

I don’t know.

The media viewer

Oh, the image viewer.

Let me ask you a question:

You have a directory with some photos. You want to go through these photos in the order taken and view them. What do you do?

In Linux, or Windows for that matter, the answer is simple: you double-click on the image you want to start with, the image viewer is opened, and you can use the arrow keys to go back and forth. Simple and effective!

What happens when you do it in macOS Finder? Well, the image viewer still opens, but the arrow keys do nothing! No, in order to go through images, you need to select the items you want to view, hover over the File menu in the top bar, press the ⌥ option key, and select “Start slideshow N items”:

HUH? Slideshow is cumbersome, as it is a slideshow - it’s not meant for going through images manually.

Alternatively, you can use a different viewer, called “Quick Look”, which supports arrow keys. Horray! But what is it? If you’re in grid view, why are the arrow keys following the grid too?

Your browser does not support the video tag.

HUUUUUH?

Who thought that this was a good idea? Hopefully, I won’t repeat this question all too many times.

The only reasonable way of using it is by switching to the list view and using the up and down arrow keys. Which is still not great, because Quick View is meant to be viewed temporarily. Any accidental click outside of it will close it, and you’ll have to find where you were and start from there.

You can put it into fullscreen mode, but then the arrow keys stop working. This seems like such a basic feature for an image viewer, but somehow they’ve managed to make it unusable. Not only that, but if this folder has any non-image files, like text files or PDFs, they’ll be included in the quick view too.

I understand that the purpose of Quick View is to view files quickly, and often it is a great thing to have, but at the same time, it’s super weird in behavior.

Hardware accessibility

OK, I can go on and on about the software part of the os, but to be honest, all of this is covered by other people rather well. And, in truth, I couldn’t be bothered to try all other preinstalled software, because it’ll take a lot of time to put it into this already long article, but also because I don’t want to. For instance, the Music app is also weird, and I already have an extensive post about how Linux music players are weird, so it goes without saying that I’ll need to replace it with something else. Like, the Quick View can play FLAC without any issues, but the Music app (formerly iTunes, I believe) can’t. Even GNOME’s player could do that, and it kinda copies Apple’s Music app in some aspects. Reencoding all my library into ALAC - Apple’s equivalent of FLAC for lossless audio is not an option for me. I did it once before when I was a happy owner of an old 4th-gen iPod touch, but never again - it is pointless, there are better music players out there.

So to me, the silver lining is that GNOME’s inbuilt software is in a lot of ways better than one in macOS. And KDE has even better software than GNOME in a lot of cases. So instead, let’s talk about hardware oddities and their operating system counterparts.

The Microphone

So, while I do care about my privacy, I can’t call myself a privacy maniac. However, one thing I like to have in my devices is the ability to mute the microphone. It’s best when there’s a hardware switch for that, but it’s so rare that I’ve only seen it once in my life on some Lenovo laptop.

I mean, it’s simply more convenient to do that than switch to a specific application that currently uses the microphone and toggle it there.

So, on Linux, I used the microphone key found on my laptop’s keyboard. It muted the microphone in the system settings.

When I got my Mac, I examined the keyboard, and found almost all usual shortcuts - you can change screen brightness on F1 and F2, you can change volume on F11 and F12, and there’s the microphone icon on F5. So I naturally assumed that this was a button to mute the microphone, after all, my old laptop had it too.

I assumed wrong.

There’s no way to disable the microphone in macOS via inbuilt means. The only thing you can do is to manually set the volume input gain level to 0, effectively making the microphone deaf.

Wanna know what the microphone button does then? I’ll show you:

Yup, it asks you if you want to use the speech-to-text feature. Cool, right?

And you can’t change what this button does.

You can set a different shortcut for dictation in the settings, but look what happens when you press the microphone key:

Your browser does not support the video tag.

It changes itself back to this button if you click “don’t ask again”! And then it asks you again once you press it! So what was the point of providing “don’t ask again” then?

Though I’ve managed to defeat this beast of a problem by writing some AppleScript. This script can be executed in the Shortcuts app, and by analyzing its output, we can rename the shortcut accordingly:

After adding this shortcut to the “Controls” menu, it acts as a mute button:

Your browser does not support the video tag.

Works well so far, and even remembers the current input level value, so I can still adjust it if needed. Even more, it works better than it did on Linux, because it constantly forgot what level the mic was set to and chose a default value of 20%, which was too low.

Here’s a text version of the script, if anyone needs it:

on run {input, parameters}
	try
		set currentVolume to input volume of (get volume settings) as number
		if currentVolume is 0 then
			try
				set storedVolume to do shell script "defaults read com.andreyorst.mictoggle volume"
			on error
				set storedVolume to 50
				do shell script "defaults write com.andreyorst.mictoggle volume -int " & storedVolume
			end try
			set volume input volume storedVolume
			return "Unmute"
		else
			do shell script "defaults write com.andreyorst.mictoggle volume -int " & currentVolume
			set volume input volume 0
			return "Mute"
		end if
	end try
	return "Error"
end run

I can’t share the whole script because no way I’m making an iCloud account for that.

The keyboard layout

Not strictly about the hardware part, since the keyboard itself is pretty good. It’s a bit of a shame that Apple stopped using their Butterfly switches, as I did like them more than the current scissor ones, but the keyboard is still better than the one on my old laptop.

One thing that bothers me, and which I got very accustomed to, is the fact that GNOME can remember keyboard layout per window:

MacOS can’t do that - and I don’t know what is the reason for that. The settings page for layouts has a setting called “Automatically switch to a document’s input source”:

However, I’m not sure what it does. It seems to work sometimes, but other times it does the opposite of what I want to. I only have two layouts. Is it that hard to keep track of that amount of data per window?

The keyboard layout (physical)

Though let’s touch the keyboard one more time. I know that Apple has at least two keyboard layouts for different markets - one for the US and one for Europe.

Figure 11: US layout

Figure 12: European layout

I specifically wanted the US layout, because all other laptops and standalone keyboards I had in my entire life had this kind of layout. Never once in my life have I seen the European layout on any device.

But, for some unknown reason, Apple sells its laptops with a European layout in my area, and when my wife had a Mac, it had that. Every time I used it, I was fighting my muscle memory.

Sure, it has more keys, and these contain some characters otherwise inaccessible without switching the layout, so it can look like Apple does a good thing. However, literally no one except Apple users had seen this layout, and it makes no sense to them. In my particular case, some already existing keys in the European layout are placed differently, like . and ?.

So, since I didn’t want to deal with that, I got myself a version with a US layout. Thankfully, there’s a “PC” layout in the system settings, so I don’t have to relearn anything. Using the “PC” layout on a European keyboard, however, is even more cumbersome.

No middle click on the touchpad

For some reason, there’s no such thing as a middle-click on a touchpad. In Linux, it is usually mapped to clicking with three fingers at the same time. I’ve been using it in Firefox a lot, and to paste stuff into the terminal once in a while.

However, in macOS, my muscle memory is now against me. I click with three fingers in Firefox, and usually it brings up the right-click menu, which is fine at least. But sometimes it is registered as a left-click instead, and it is super annoying. Re-learning to use @@html:<kbd>⌘ command</kbd> click will take some time, I guess

The camera cutout

Same as with the microphone, I’d like to have a physical way of blocking the camera, but because Apple moved towards a custom-shaped display matrix, it can’t be done as easily as before. It has a lot of sensors there, and blocking them with a huge plastic cover will make it impossible to close the laptop lid.

Again, not strictly about the hardware side of things, but the display in general feels weird because of this notch - it’s right in the middle of the screen, and I’m used to having the clock there, after years of using GNOME. Some say it’s more logical to have them at the far right side, as it is commonly done on phones, but phones have a much smaller and narrower screen. The same goes for notifications - having them in the middle feels more natural to me, because most of the content I’m working with is somewhere in the middle. But your opinion may vary (as if anything else I said here can be universally agreed on).

The good parts

OK, enough bitching around, let’s discuss some good parts.

The screen itself is gorgeous, colors are vivid yet natural, and the 14-inch model is actually both a bit bigger and a bit taller than my old 13-inch laptop. I like the screen a lot. I didn’t go for the nano-texture display, as I don’t work in environments where reflections are problematic, so I can’t say how it affects image quality. Maybe if I did, it’d be in the bad section.

The speakers are pretty good. And for a laptop, they’re actually amazing. They have depth, the upmp, and are loud enough to watch films with comfort - can’t say this about any other laptop I’ve had before.

Touchpad - oh, the touchpad. Simply put, the fact that it is a lot bigger (in fact, they had even bigger ones before), and I can press on it absolutely everywhere, is amazing. I was also surprised to learn that they aren’t actually pressed in physically. Instead, it is a glass surface, which has haptic feedback that simulates the click. Purely amazing. I’ve spent a long time trying to find anything remotely close to these touchpads on other laptops, but I never could find one.

M4 Pro CPU is a beast. Recently, I forgot a passphrase to one of my GPG keys and tried to brute-force it. My old laptop had AMD Ryzen™ 7 3750H, which isn’t fast by today’s standards, but it wasn’t a slow CPU either - it handled all of my tasks without major hiccups. I tried it first on the old laptop, and it could try about ~45 passphrases per second. The M4 could try ~750 passphrases per second. Everything is so fast I can’t believe it.

The macOS itself isn’t all that bad. As a matter of fact, writing this post helped me find how to fix a lot of problems I initially had - this post was a lot longer before that, but I had to cut stuff from it, as it was no longer applicable. There are still some oddities - it constantly bothers me with asking permission to run apps for the first time, because I install them through brew, or downloaded from the official website (again, I’m not making an Apple account, no, no). But I finally have a machine on which I can do both my programming tasks and media tasks without needing to keep two different operating systems to handle each task specifically. Finally, I can record my music with my right hand while writing code with the left - a dream.

Even the liquid glass thing is not as bad as I thought it would be. Thankfully, Apple added a tinted style to it, so it is less transparent, which helps readability.

And overall, I really like the device - it feels solid, and that it will last me another five years at minimum. Hopefully I didn’t jinx myself here, though.

Anyhow, thanks for reading, and please do share your experience with me, or if you know ways of solving the problems I’ve listed, I would be glad to know about them!

Comment via email

Am I becoming obsolete or just older?

Tue, 22 Apr 2025 00:36:00 +0300

Let’s set the tone for this post right away, I just want to get this out of my system: I despise the rise of AI in tech. Coding assistants, chat-bots, vibe-coding, agents. Oh, the vibe coding… WTF?

Figure 1: This will be an “old man yells at cloud” type of post.

I don’t like AI in general, although I know that neural networks can be used for good. Before you accuse me that I’m completely anti-AI, let me explain where I see this technology applicable.

One such example is modeling. I play guitar, and it’s a pretty expensive hobby. A good guitar itself can cost hundreds, or thousands of dollars, but then there’s guitar gear. Tube amplifiers and pedals are expensive. Not everyone has money to have several amplifiers for achieving versatile sound, and a bunch of effect pedals to work with these amplifiers.

The industry noticed that, and a lot of effort was put into modeling these circuits in software. Guitar pedals and amplifiers are basic electronics, for the most part - cascading transistors, condensers, operational amplifiers, etc. It’s possible to model them accurately in software, and I did so myself, implementing Maxon’s OD808 overdrive pedal in C++ as my diploma project for graduation. The diploma itself was about precise software modeling of analog systems, and the guitar pedal was a practical example I could show. You should have seen the faces of the diploma committee when I pulled out a guitar for a project demonstration. Better, you should have seen MY face, when the head of department took my guitar and started blasting Iron Maiden riffs.

However, modeling these schematics accurately and working in real-time is hard. Especially, when we’re talking about emulating tubes or tape machines. People still did, but the results were not as close to the real thing, as one might like, and sound engineers are picky for the details. But then there was another way of modeling - feed the raw signal through your equipment of choice, be it a tube amp, or some weird pedal schematic, capture the result, and train a neural network so it could reproduce it flawlessly. This is the technology behind Neural Amp Modeler and other such projects.

This is where neural network technology shines in my opinion - you get accurate results, even though accurately emulating entire circuits with tubes in real time is still a hard task for programmers. It sure can be done manually, and there are successful examples, where individual components of the circuit are programmed as separate modules, and then the whole circuit is constructed from them. That’s the approach I took with my diploma project as well, but it still takes much more time than just training a model with a pair of .WAV files. And the neural network method comes with another real benefit allowing you to capture your sound exactly as is for later use. For example, if you’re recording at the studio, and you want to patch things later or re-record certain parts, you can capture your studio sound, and then reproduce it later.

There are other fields, where neural networks can be helpful, I won’t go listing all such cases, I’m just going into this tangent so that you understand that I’m not against neural networks in general. However.

When ChatGPT3 was first announced, people started going crazy. We had no real breakthroughs for quite a few years, GPT2 wasn’t really good. Image and video generation models weren’t good either. Then suddenly, GPT3 talks close to being confused with a real person, and images generated by other models start looking correct, and not like a mush of pixels. People notice that GPT3 can generate code in most programming languages, and make attempts at problem-solving and such.

Fast forward a few months, and we have first coding assistants and IDEs with a primary focus on AI for development and refactoring. The internet is becoming worse by the day - AI-generated articles pollute search results, and you don’t know if the thing is real or not when looking at “drawings”. AI-generated music pollutes streaming services, often sounding awfully lot like some other artist, without acknowledging that it was trained on their music. Some streaming services even announced that now you can remix the music with AI if you have a paid plan. People accuse one another of the use of AI to pretend that they know how to do what they do. The worst.

Figure 2: A comment to the Generative AI is a Parasitic Cancer video by Freya Holmér

Then, there’s the new hot thing - vibe coding. I’m living under a rock, I know that, because I don’t follow news, tech hype reaches me mostly via gossip in real life. So when I first heard the term vibe coding, I naturally assumed that it’s another one of these “Lofi girl”-type work setups where you have a comfy environment for coding with good vibes.

Figure 3: this kind of stuff, just imagine she’s programming. I guess, I could generate an image where she’s programming for real, but then this post would be hypocrisy.

This is pretty much what I do when I have free time to work on my personal projects. I prepare myself a nice cup of coffee with steamed milk and peanut butter¹, sit down at my desk, put on headphones, and enjoy my coding time in the late evening. Vibes, right? Nope! Apparently, vibe coding is when you explain to your AI-based editor what the heck you wanted to do, except you’re much more into debugging code written for you. WTF it is calling vibe coding? I wouldn’t mind it being called AI coding, but vibe?

I get it, AI is a hot new thing, and people want to use new shiny things because it triggers a dopamine hit. But toying with something for fun, or being passionate about things should still remain reasonable. It’s fine when you do this for fun, or sparingly, but when all you do is now done by AI, it starts getting a bit too far in my book.

I see AI-generated images in presentations and I cringe.

I see how people brag about how they used AI to do “this and that”, even though the task at hand was easy and I cringe.

I see how people misuse AI for harder tasks that can still be done without AI perfectly fine, with a much lower error rate, and I cringe again.

I see posts about how vibe coding brings back joy to programming, and I only have one question - what joy? If you did enjoy programming, but felt down recently, I think AI is going to make you feel better in the short term, but burndown will hit you again soon enough when the novelty wears off. And if you didn’t enjoy programming in the first place, how AI is going to help you enjoy it? Because you don’t have to do it manually?

If you don’t enjoy the process, AI won’t make it more enjoyable. You will simply offload the unenjoyable part to AI, and then gaslight yourself.

Phew.

These are the kinds of thoughts I had in my head lately. And when I’m annoyed at something for no apparent reason I usually start reflecting on it in hopes to understand the source of the problem for me. Worrying over nothing is the worst thing you can do for your mental health. Like, If I don’t use AI, I can choose not to care about others who use AI, and continue to live my life like I did before. That’s what I did before, like when blockchain and NFT were the hot new topics in town.

However, AI-assisted coding practically hurts me even without me participating in it. First, I chose to ignore AI assistants, heck I don’t even use non-AI assistants such as LSP that much. So when I talk to people, who use AI, I get weird looks, like: “Man, you’re gonna be obsolete in 5 years if you don’t learn how to use AIs, it makes you much more efficient”. Am I?

I don’t think efficiency is in speed only - it doesn’t really matter how fast you can produce code. Programming is mostly thinking a lot, and then writing a little. It sure does matter to a business, because today’s main tactic is TTM optimization, but that’s another topic.

I think relying on AIs for coding is going to hurt us in the long run. Count me old-school, but I believe that today a lot of people in the programming world don’t know how to code. You’d be surprised how little people know these days. Ask them the difference between an array and a vector, and they won’t be able to tell the difference. Don’t get me started on advanced topics like asynchronous/parallel programming, or even more basic features like closures.

I’ve seen a lot of people who think that they know what they’re doing, but when asked about certain internal characteristics of the language/framework/library they use, that did matter to the problem at hand, they stumbled and couldn’t answer. And I’m no better, I was there too - I’ve been writing code for bare-metal in C during the first two years at my first-ever job and didn’t understand anything. Only after I delved deeply into the language and SOC stuff, I started understanding what and why. It improved my results at work and tremendously helped me beyond just C later. So I believe, that people can learn, but would they if everything is done by AI?

I can confidently say, that I know Lua deeply enough to understand how its bytecode VM works. I also can confidently say, that I know how most of Clojure works internally. But I still can’t confidently say that I’m a great programmer. A decent one, maybe, but I still don’t know a lot of stuff behind the scenes. This is why I constantly delve deeper into the technology I’m using, trying to understand the inner workings of it.

And now we have AI assistants, practically writing programs for these people, and they can’t reason about the code written by hand, let alone generated code. I’ve seen people applying for a job, and failing miserably on the simplest questions on the coding interview. They can output the solution for tricky Leetcode tasks, but can’t explain them. Some are even proud that they can make AI assistants solve the problem for them without them even trying to understand the problem. I, myself, can’t solve these Leetcode problems, but I still can write robust code for the real-world task at hand.

Recently, I encountered a message in a group chat, that pretty much triggered me to write this post, with the following contents:

There are orders of magnitude fewer code examples for ClojureDart, which makes it very difficult to train LLMs. Examples from regular Clojure will probably be pulled up, but the libraries won’t work - you’ll need to port them first.

For a beginner, this is a very large and painful entry threshold, especially if there is no desire to write the code yourself and delve deeply into the language.

Oh, how did people even learn to code before LLMs existed? I imagine it was so hard and painful! Imagine - learning the language by writing code and understanding what you’re doing, am I right? This is so wrong on so many levels.

First of all, if there is no desire to write the code yourself, why the heck do you want to be a programmer? This code is going to run on a machine, so it should be well understood, otherwise it’s a time bomb waiting to explode. And with LLMs and vibe coding, the whole point is that you don’t look into the code that much. Or at all.

And, I’m not talking about using LLMs - even without them hallucinating a solution today we can’t write reliable software that works properly all of the time. I get frequent crashes when doing mundane tasks - if I were to take a screenshot every time a program hangs or crashes, making me lose my work, my screenshot folder would fill up my hard drive. Most programs today can’t achieve even “four nines”, let alone five or six nines of uptime. Your Windows laptop will suddenly reboot to install updates, so even if your application can theoretically achieve “five nines”, the platform it is running on can’t. I lost work due to Windows updating the .NET Framework, why the heck does it require a reboot?

Today’s software is in a miserable state. We have a lot of over-engineered stuff at the base of our software. Legacy code creeps in, making writing new code harder. Bugs are today’s norm - I’m still amazed that everything is holding up, instead of falling apart.

If engineers were as bad as programmers today, we would all be dead, lying flattened under collapsed buildings. Oh, wait…²

So am I becoming obsolete or just getting older and more grumpy? I guess it’s both.

I always wondered when would I become one of those old people who don’t understand modern technology. I was born in the 90s, and saw firsthand how technology became more and more advanced - I had access to a computer since the age of three. My folks don’t understand modern social networks that well, let alone all this AI stuff. Now I’ve become a part of the club, I guess - I also don’t understand modern social networks and all this AI stuff. Heck, my dad is probably more advanced in tech than me, as he’s been doing this smart-home thing for a while now, and I’m not understanding any of it.

Programming is both a job and a hobby of mine, I like writing code to solve problems I often impose it on myself for the fun of it. I like to think about solutions, and if I can’t do it myself, I search online like in the good old days, learning in the process.

You can argue, that an AI chatbot is a glorified search interface, except it’s not exactly that in my opinion. Today’s AI chatbots don’t just present you with existing information, instead, they reconstruct it. LLMs are more or less a decompression algorithm, except not precise in most cases. They can hallucinate a solution, and still sound as confident as if it was true. Keep in mind, that an AI chatbot doesn’t understand what it’s outputting, for now at least. People do that too, unfortunately, but at least they don’t sound as confident when they clearly don’t know what they talking about (yeah, sure).

Sometimes, beginner programmers who only know how to code with LLMs face the harsh reality, that LLMs can’t solve all problems. For now. Maybe in the upcoming years, large language models will become so sophisticated that it would be possible. I don’t know. And If such a beginner realizes, that they still need to learn things, the internet is already full of articles generated with AIs by people who don’t understand the topic, making it much harder for them to learn properly. I’m facing this problem too, each time I want to learn something new, figuring out halfway through the article that it is an AI slop.

Maybe one day I will have to use AI because my job will demand it, and I will change my opinion on this whole thing. Or maybe I’ll change the job instead, depending on the circumstances. Blacksmithing looks interesting.

Figure 4: A poker I made

Or maybe woodworking? Or pottery? Unless AI would do these things too by that time. Of course not.

Of course not.

BTW, amazing recipe: 12 grams of coffee beans, grounded for double shot espresso, about 35-40 grams of salty peanut butter, and steamed milk. Nice texture and taste. ↩︎
AI is apparently used in engineering too now. ↩︎

Comment via email

GNOME Software

Wed, 06 Dec 2023 20:59:00 +0300

Have you tried using the GNOME Software? This thing:

Do you use it? Are you even using GNOME?

Oh, sorry, I think should point this out, it’s kinda important - I’m asking the developers of GNOME Software.

Because, apparently, they don’t.

OK, let’s start this post over.

GNOME Software

Wed, Dec 6, 2023

@rant GNOME tools ~8 minutes read

GNOME Software, or, just, Software, is an application that “allows you to find and install new apps and system extensions and remove existing installed apps”. I mean, that’s what description is given to it on the official project page. It is preinstalled on most distributions that use the GNOME desktop environment, except for, maybe Ubuntu, which has its own store for applications. But I’m not going to touch Ubuntu here, I don’t really want to touch Ubuntu at all, to be honest, although I have to use it five days a week.

At home, I use the Fedora Silverblue. I like Fedora, in my opinion, it is one of the finest out-of-the-box-oriented distributions today because of how pure it is. No fancy patches, or extensions, just pure GNOME as it is. In addition to that, the Silverblue variant is immutable, so in addition to providing pure GNOME, it barely provides anything else.

I’ve picked Silverblue because I like to keep my system clean, and immutability helps tremendously. Everything is either a Flatpak or lives inside the Podman container. To be frank, even before I used Silverblue I had the same kind of workflow on the regular Fedora distribution, and the same applies to Ubuntu that I use at work. If your system got messed up enough for you to care you can just delete the container, and recreate a new one, installing only the stuff you do actually require. But I’m getting off track here.

I feel that the fact that I’m using Fedora Silverblue is important for this post because this means that I’m using a distribution that I can’t make changes to. Well, I can, of course, but I don’t do that. Again, all my apps are either in Flatpaks or containers, so the system itself is barely different from the fresh installation. I had installed updates, but these come from Fedora, so I’m assuming they know what they’re doing.

So let’s get back to the topic - I install apps as Flatpaks quite often. I do so using GNOME Software!

And it is pain!

I have used GNOME since 2008 or 2009, can’t remember that exactly, so I’m a seasoned Linux user. I have used a lot of different distributions, and for the past five years, Fedora has been my daily driver because it is simple, reliable, and has everything I need. And what it doesn’t have, I can build from sources in the container with my own hands, so I don’t give a shit about stuff like AUR, Nix, etc. For simple stuff, like a music player, Flatpak is more than enough, and for stuff like Emacs, I’m running a container with all my development tools. And here comes GNOME Software.

For the past decade, ever since GNOME Shell was released in 2011 I have been using it. I had spent two years using KDE just to see if the grass was kreener on the other side but returned to GNOME eventually. And, for the past decade, I’ve been using GNOME Software.

I mean, what, do you expect me to open a terminal every time I need to install or update a package? Sure, back in the day I did that when I used Arch, and Ubuntu before it, but honestly, I don’t care if I need to input pm update in the shell or press an “Update” button in the GUI.

terminal is faster and more convenient for managing packages

Yeah, right. And how am I supposed to go and look for the screenshots of the app I’m about to install on the terminal? You could say it’s a silly reason, but during the post on Linux music players, I have done that a lot. Of course, when I know exactly what app I need, I can go to the shell, and type out the command in a fraction of the time that it takes for GNOME Software to fully load and become responsive. And that’s what brings me to the beginning of the post.

Dear GNOME Software developers, tell me, do you use your application or do you install everything from the terminal anyway?

I think that the developer should be, if not the main, but an active user of the project they’re developing. That applies both to open source and what you do at work - because if not, you don’t know your own software.

A theory is nothing without practice, and the same goes for software development. The code is a theory. You compile the code and verify that it is correct like any theory should be. The application of that code is practice.

And I feel that the GNOME Software developers don’t use the program they create. Here’s why.

As I said before, I use Fedora Silverblue, with everything installed as a Flatpak or inside a container, so the system is pretty much as if I just installed it. I rarely shut down my laptop, instead, I put it to sleep (not even into hibernation) most of the time. Now, imagine I want to go and install the Audacious music player. I open Software and start typing Audacious, and that’s what I see:

I stare at this for a few seconds, check that my internet connection is working, and realize that it happened again - GNOME Software just doesn’t do anything. I tried waiting for minutes, and the spinner didn’t go away. So I closed the app. I opened it again. And I still see the damn thing spinning because you know what? When you press the close button, the Software doesn’t actually close, it always runs in the background, for reasons.

So I have to go into the System Monitor and kill the damn thing. I reopen it again, type Audactions, after it finishes loading everything, and now I see the player:

And this happens to me every single time. On a system, that is, according to its promise is immutable, and hence this should probably happen even at the stock installation. And, you know what - it does! I have recently reinstalled Fedora on one of the laptops I have and left it working for a while, checking periodically if GNOME Software will behave like that. I didn’t have to wait for long, it happened the next day!

So this bug can be reproduced, with a bit of patience, on a clear installation! Yet, it haunts me for the last 5-6 years or so! Aarrgh! ARE YOU EVEN TESTING YOUR SOFTWARE AT ALL?

*breathes*

Sorry, I’ve got too ~~angry~~ dramatic even for my style of writing. I’m not the only one who experiences this particular bug, among other bugs:

A Reddit post describes this exact problem, and many others, specifically mentioning that they’re not new
A bug report was submitted to the official issue tracker, outlining the same problem. I like the comment there:

Without a log I’m afraid we can’t diagnose or fix the problem, so I’ll close this issue report for now.

Can’t diagnose? Seriously? Have you even tried though?

Seriously, as a software developer, I don’t understand this. I mean, sure, sometimes I don’t want to deal with bugs I personally don’t have, and it is open source, so I don’t really have to do that, someone else can and is welcome to. But to close the issue because there are no logs and it can’t be diagnosed, despite the fact that the issue exists? Especially, when it hits multiple people. I don’t get it. Don’t try to explain me, I won’t get it, because it’s hard for me to get it, so I’ll close the discussion for now.
Many search related requests are closed, yet the problem is still there.

It’s like they find a possible reason why this might happen, fix it, and close the issue without testing. I mean, unless you can reproduce the bug before the fix, how would you know that it is fixed?

I don’t know how the development process is organized in GNOME, especially for GNOME Software. However, I think that they don’t actually use their own thing, because it has so many obvious bugs that I can hit several during a single session. For instance, the Reddit post mentions this:

While installing, the window “reloads” a couple of times, as if it was refreshing.

Yup, happens to me every time.

Sometimes it feels like updates have been fetched, and the ones being displayed are the most recent, but updating only reveals those updates were not the newest ones and even updates need to be downloaded

Happens to me as well. To be more specific it happens like this:

You open the Software (that has been running in the background for long);
You see that the “Updates” tab has a notification;
You open the “Updates” tab and it shows a spinner;
Then the updates appear.

So I would assume, seeing the spinner, that it had fetched everything, but by pressing the “refresh” button, the spinner appears and goes for much longer, revealing that there are in fact more updates than there initially were. Literally happened to me while I was writing the previous line, as I’m writing and testing at the same time.

There’s another issue, that is closed on the tracker, but happens to me all the time, and is extremely easy to reproduce: while you install anything, the search stops working. The funny thing, it is closed as a duplicate of the issue with the name “Rework threading model”, which supposedly should fix all of that. However, how it is a duplicate? At best it is blocked by that ticket, but it doesn’t duplicate it in any way because it describes the actual issue. It should be closed only when the blocking issue is done, and the bug is tested to be gone. What a mess.

So, yeah, GNOME Software is full of bugs, as most of the software is today. If you’ve seen the “Preventing the Collapse of Civilization” talk by Jonathan Blow, you may remember there was a moment where he listed all of the bugs that happened to him in the past few days. Have a look, I’ve linked it with a timecode.

So, why am I complaining in the blog and not actually submitting an issue? Well, I don’t want to. GNOME has a long history of ignoring problems, saying that people use their software in the wrong ways, and so on. I just don’t want to go to their territory and be ignored too. Instead, I can write a quick rant in my personal space, where I’m always right, and no one can prove me wrong, ha ha ha! Obviously, I’m being sarcastic here, if you couldn’t tell.

I guess, someday these bugs will be fixed, it’s just a shame that they have existed for so many years, and it seems like the developers don’t care.

Anyway, that’s enough ranting for this year. Use what you’re making, and test your fixes, or at least ask for feedback once you think you fixed the bug. See ya!

Comment via email

Linux Music Players

Sun, 19 Nov 2023 22:57:00 +0300

I’m feeling ranty this week for some reason. Today will be no different and I’ll post another rant on the software world but not about programming. Instead, I want to tip into the consumer application world, and shit on the current state of music players on GNU/Linux specifically, although the situation is as bad as on other platforms IMO.

Not long ago I bought a new set of headphones and decided to upgrade my listening experience a bit. For the last few years, I usually listened to music on my phone via some streaming service - I’ve tried plenty and wasn’t really satisfied with any of these, although there are some good things each does. For example, thanks to Spotify and Google Play Music before it, I’ve discovered a lot of artists that I wouldn’t likely hit if not for their algorithm. Another thing - listening to music via a subscription service is dirt cheap.

My listening routine can be described as follows:

Pick an album;
Hit play;
Enjoy.

Yes, I’m not into playlists, especially not into various methods for organizing music based on mood, algorithmically, by genre, etc. In fact, I openly despise playlists. I hate when players shuffle my music (looking at you, Spotify), so all I really need from a music player is to act mainly like a CD player/Vinyl turntable. I load a specific album, listen to it, and I’m done with it. An album is a piece of art - shuffling songs is like shuffling episodes of a show or chapters in a book.

What I did like in Spotify, and Google Play Music before it, was discovering new music. The subscription model means that I can listen to all new releases whenever they come out without having to pay for each of them, purchasing only those I absolutely want to keep, but on some other service that allows me to download the actual files, and listen to them without connecting to internet on any of my devices and in any music player. For those wondering, you can save your music on Spotify for later listening, but you can’t use Spotify without an internet connection even for listening to your downloaded music, because Spotify needs to check if your subscription is still active. And you can’t extract music from Spotify, legally, at least, so if Spotify disappears, all your purchased music goes down with it. I often find myself in this situation when I’m on a train, kilometers away from any cellular network, and Spotify refuses to load my offline music because there’s “no internet”. So I prefer to keep music I really enjoy out of streaming services.

Discovering new music on a snap is great, and the subscription model works for that especially well, but one of the problems with most subscription services is audio quality. When I’m listening on my phone I usually don’t care - it doesn’t feature a great DAC, I’m listening through wireless IEMs, although of decent quality, this still limits the quality of sound to what Bluetooth protocol is available for my phone. And another important thing with music on the phone - I’m listening to it on the go, so there’s little time to concentrate on details, like when I do at home when I have time to just listen to music without any distractions. So before you suggest using something like Tidal instead of Spotify just to get the quality audio - I don’t really need this kind of audio fidelity on the go, and at home, I have my FLACs.

Now let’s go back to the main topic - you got your FLACs, how to listen to them on your PC? Well, you use an audio player, of course, but which one?

My operating system of choice is Fedora and there are plenty of audio players for Linux that I can try. For the past few years, I’ve been using MVP as my music player - it can play everything I need, it stays out of the way, and it is fast and resource-friendly. But it is extremely cumbersome to use. While not a problem for me, as I rarely listened to music on my PC previously, now that I have a good pair of headphones, I tend to do it more often. And user experience with MPV started to show. My main problems with MPV are:

It’s a video player primarily so its UI is oriented towards the video playback.
You can’t click on the song in the album and play it, the song list only appears when you switch tracks as a visual aid.
It plays everything in the given directory, even cover images.
- If you have a .cue file along with the album file, MPV will first play the .cue file, then it will play the album file, doubling the total length.
There’s no notion of a music library besides your filesystem - you just drag and drop files to the player.
It doesn’t remember where I was if you close it.
Wayland support is not great, for a quite long time the drag-and-drop feature did not work on GNOME at all for the flatpak package.

But these are the problems with stock MPV, there are plenty of other frontends for it, that may work better. I haven’t tried these, and maybe I will in the future. Ovoplayer looks promising, but sadly doesn’t have a package for Fedora, and for some reason doesn’t start from an Ubuntu container.

But this won’t be a rant if I’m going to list good players, so let’s start with “first-party” players, provided with the desktop environment. After that, let’s look at some modern players. Then, I’ll list some other commonly suggested players.

GNOME Music

As I’m using GNOME let’s start with the GNOME Music.

Figure 1: GNOME Music screenshot from the project web page

First things first, I used this player years ago and I remember it being OK. However, trying it today I can’t say that I like it. Well, can’t say I dislike it either, it just doesn’t work for me.

It has a nice UI, though I’d prefer a slimmer one. Importantly, it has dedicated tabs for albums, artists, individual song lists, and a separate tab for playlists. Unfortunately, GNOME Music doesn’t support .cue sheets. I have some releases that are using .cue sheets and I, personally, don’t want to go through the hassle of extracting individual tracks. As a result, these releases are missing from the Albums tab. There’s an open bug report asking for the .cue support that dates back to 2016.

These albums show up in the “Songs” section though, so you can listen to them, as a single stream. That’s not bad, considering that I’m usually listening to albums from start to finish, but what’s the point of having an organized albums section if it doesn’t show all of the albums, and you have to remember that you still have them in the tracks section. That can contain thousands of items because of the size of the music library.

Oh, and you can’t change your music folder, it only works with ~/Music for some reason. Well, I, personally, don’t have a problem with that - that’s where I store music on my PC, but it may not work for other people.

Amberol

GNOME had a neat idea - create a list of applications designed specifically for GNOME with its guidelines in mind. It is called GNOME Circle, and it is listed among GNOME’s core apps. The Amberol, at the moment of writing, is one of the first apps on the list, and it is a music player.

Figure 2: Amberol screenshot from the project web page

Similarly to GNOME Music, Amberol doesn’t support .cue sheets. Again, there’s a bug report for that, but the reason it doesn’t support .cue is due to the method they access files. Sandboxing, which is used by flatpaks causes problems, as the portal interface isn’t designed for this particular use-case.

Unlike GNOME Music, however, Amberol doesn’t show these albums in the playlist at all. Don’t ask me why, I don’t know. And unlike GNOME Music, there is no dedicated tab for albums, artists, or anything really - only a single playlist, consisting of all tracks in your music library. I know that Amberol tries to be a simple music player, but I wouldn’t say that GNOME Music was complicated. Going simpler than GNOME Music is hurting usability.

Lollypop

Another music player that is made using GNOME guidelines. It has more features than Amberol, and maybe even more features than GNOME Music:

Figure 3: Lollypop screenshot from the project web page

But once again - missing albums due to missing .cue support. Are you for real? Another 8-year-old bug report asking for .cue support with no resolution. Well, at least there is some discussion going on, so the ticket isn’t entirely stale.

What’s even weirder, it seems that Lollypop doesn’t have a tracklist, unlike the previous two players. It’s weird because while I don’t use this feature, it’s so fundamental to all music players we’re going to discuss further, not having it is just strange.

I’m starting to think that the GNOME project simply can’t have a decent music player. Let’s look at how KDE does this.

Elisa

A few years ago I was using KDE for a brief period, but I can’t remember if KDE did have their dedicated music player back then. Or maybe I wasn’t bothered to check, as I already used MPV. As far as I can see today the KDE Project has the Elisa music player:

Figure 4: Elisa screenshot from the project web page

Well, I tried it, and… missing albums, again! And again due to the lack of .cue support! There’s a bug report for that again, and there are even some duplicates, probably because their bug tracker web interface is abysmal.

Seriously, are .cue sheets that rare? Maybe they are hard to implement properly? Up to this moment, only MPV could deal with them with no problem, and it’s a shame.

Well, at least these .cue albums show up in the Tracks section, as a single track. Hitting play on one of them, however, plays a random album instead. Welp. It’s a shame though, the UI is clean, everything is mostly logically displayed, and there’s little wasted space, unlike in many GNOME apps.

Amarok

Another project is often seen on KDE systems.

Figure 5: Amarok screenshot from the project web page

No Flathub entry, that’s a good start. You see, I mostly install software through flatpaks because I use Fedora Silverblue - an immutable OS. This can cause problems, and I know that, but most of the time everything works fine.

Figure 6: Don’t worry, Clementine, I’ll get to you soon

Once again, missing .cue support. Which is weird, as there are reports on the internet that Amarok does support .cue since version 1.2.4. Maybe it was lost along the way, I don’t know. Well, at least it shows the albums in the list of all media, albeit as a single file. Thank you for not omitting these, at least. And it actually plays them, unlike Elisa.

The user interface, on the other hand, is weird. I couldn’t figure out if I’d pressed the pause button, as it doesn’t change shape, and the visualizer doesn’t stop immediately either. This is because there’s by default a two-second fade-out that has to play out before the track is put on pause, and the button doesn’t change until the track is fully stopped. I dislike fadeouts, crossfades, and other things like that, sorry.

Well, it’s an old project, and its UI is a product of its time, I guess.

Rhythmbox

Figure 7: Rhythmbox screenshot from Flathub

Another fairly old music player. Yet, the user interface is clean, uncluttered, and concise. Nothing but praise from me on the UI.

Again, no .cue support! WHY?

Well, at least, there’s a plugin. The flatpak version couldn’t see external plugins, so I had to install it as an rpm package inside a container (Silberblue works like that). And while it works now, for some reason, the .cue albums aren’t shown in the albums section. Instead, they’re shown under the Unknown section, and clicking on such an album opens a separate window with track listing obtained from the .cue file. So the experience isn’t great, unfortunately. But we’re close.

Clementine Strawberry

I told you that we’re going to talk about Clementine.

Figure 8: Strawberry screenshot from the project web page

Strawberry is a fork of Clementine, which is a fork of Amarok. Same as Amarok, the default UI is horrible, sorry. But, finally, a .cue support! Which makes it even stranger, as Amarok itself did not work with .cue files. Maybe I’m missing something?

Importing my music library I can now see all of the albums, and play individual tracks, but it’s so clumsy. When I open the album, and double click on the track, this only track is appended to the playlist. And it isn’t the one played either.

I do hate playlists, but what I hate even more is play queues, and this action acts like adding to a queue. I don’t want to deal with a queue at all - give me an album list, play the one I’m interested in, or start from a track I’m interested in going forward. Simple as that. In Strawberry, I have to clear a playlist, replace the playlist with an album playlist, or create a new playlist, and it’s just tiresome when all I want is to listen to a specific album.

Why is it so hard for most players today? Don’t tell me I’m using players wrong. I mean, I can get this from Strawberry, just going through several hoops. Well, we were going into older players, let’s look at something more recent then. Maybe some modern players took inspiration from Spotify and others and made something similar.

Tambourine

Well, I’ve kinda covered modern players already at the start of this post, but these were desktop environment-specific players. Mostly. This one is just an independent project.

Figure 9: Tambourine screenshot from the project web page

The interface is laggy and we’re back to no .cue support. It has potential, though.

Also, good luck searching for a “Tambourine music player”.

Nuclear

I’ve seen this player being praised online several times but never took a look.

Figure 10: Nuclear screenshot from the project repository

The startup time of several seconds and crashed when I tried to import my music library. It’s funny, though, this is what they say on their web page:

Say goodbye to proprietary music players filled with ads, tracking, and profiling. Nuclear empowers you to listen to what you want, where you want, and how you want, for free

They say it like there are no other non-proprietary music players without all of that. Well, maybe, if we’re talking about service-based players, like Spotify, but I’m here for a local-first player. Their user interface is filled with some online garbage, trending artists, and such, not sure what service it comes from. The local library is waaay below in the list, and, as mentioned, it doesn’t work. I’ve limited it to a portion of the library, and there is no .cue support, once again.

But again, it’s funny, when I pressed play on the album, the player immediately added something that wasn’t in my library to the queue right after it. Kinda disagrees with the statement they make on the web page. That’s not how I want to listen to music.

Tauon Music Box

Is the closest to no-bullshit among all of the ones I’ve tried.

Figure 11: Tauon Music Box screenshot from Flathub

It does support .cue sheets (wow), and managed to load my music library without many issues. One of the problems occurred with a three-disk album that doesn’t have disk metadata, for some reason. Every track appeared as a separate album in the list. But, to be honest, this three-disk album is hard for all other players I’ve tried (that support .cue), not sure why.

I like this player, but its UI is a bit too flat and too simplistic for my taste. Like, all of the buttons are just differently arranged rectangles. I can get used to this, but a bit more clarity wouldn’t hurt. Another small nitpick is that the album grid scrolls in fixed steps, and not fluidly - it just throws me off a bit.

Other than that - good player, can recommend.

Qmmp

Figure 12: Qmmp screenshot from the project web page

Well, most modern players didn’t make the cut, let’s go back and look at older ones.

If you want an old Winamp-like player, qmmp is probably what you’re looking for. It supports Winamp skins and acts pretty much the same way.

It plays everything, has the .cue support, and the only issue for me is that I can’t drag the window with the mouse. Probably some Wayland/GTK incompatibilities - it’s a Qt-based player after all. I have tried it in the past as well, though I vaguely remember having issues with it here and there. So I moved to Deadbeef.

Deadbeef

I’ve previously used Deadbeef, and I think it’s one of the best players available on Linux. I have never used Foobar2000 but as far as I know, Deadbeef is similar to it.

Figure 13: Deadbeef screenshot from the project web page (it doesn’t look like this OOTB)

For some reason, it isn’t available in the form of a flatpak, so I had to install it inside of a container, similar to Rhythmbox.

Again, it plays anything and has the .cue support. There are many plugins, and this player can be heavily configured. UI is a bit ugly, but who cares? And you can stylize it with plugins, replacing any element you don’t like. On my older setup, I had the seek bar replaced with a waveform, kinda like on SoundCloud. I lost my config years ago and don’t want to reconfigure it again, honestly, even if it looks like there are not many changes.

Still, it has many small problems. You can’t enable album repeat without going into the menu, the play and pause buttons are separate, and you do have to press play to play and pause to pause. In most players play acts as a pause when the playback is active, and vice versa.

I like how you can make a simple playlist look like these are separate albums. These lines between each album are just separators in a continuous stream of songs, yet, enabling album cover art makes it look even more like separate entries. It’s just an illusion, though, a clever one.

Audacious

Figure 14: Audacious screenshot from the project web page

Audacious is another good music player. After a few tweaks in the settings, it looks quite similar to Deadbeef. Unlike Deadbeef, I couldn’t find any way to separate albums in the playlist.

I don’t like playlists, but both Deadbeef and Audacious have an OK playlist experience. Disabling the column headers helps Audacious a lot, as you basically prevent any shuffling of your playlist by doing so. So if you’ve dragged a folder with songs into the player, and they’re in the correct order, you just hit play and you’re good. In some albums, I had tracks imported in the wrong order, and while it is a bummer - it is an easy fix.

And unlike most other players, Audacious managed to import this three-disk .cue album and have all disks organized nicely. That is until I accidentally hit “sort by the album”, and it grouped all three disks into one album again (after that I disabled the column headers). What is also weird, is that it doesn’t seem to support the disk metadata.

Skill issue?

Yeah, yeah, I know, that’s a fair point. But honestly, I don’t believe that using a music player should be hard or unintuitive. The default players in GNOME and KDE do an OK job, to be honest, it’s just the fact that they can’t play everything I have.

Remember how it was in the old days? You pick your CD, tape cassette, or vinyl record, put it into a respective device and you’re good. Yes, you had to swap disks if you wanted to listen to something else, and you couldn’t change the order of tracks. On the other hand, you’ve listened to music how the artist intended.

PC audio players felt liberating back then because you could reorder things, which usually was impossible on the physical medium. And they had many more features, unavailable on most playback devices back then. But today, I personally want to go back to a simpler time, but without having to deal with actual CDs. CDs are good as backups, as I still have some music disks from the 2000s that still work, and I don’t have any hard drive from the 2000s that works. Vinyl is also good, possibly even better to actually preserve data, but it is mastered differently, and I don’t have a turntable.

There are probably many more players I haven’t tried, and it’s almost impossible to do because there are too many of them. Again, Tauon Music Box was good, so it’s possible to create a modern player, nobody just really wants to. It does support everything I need, but I didn’t really like the UI, to be honest, and it has problems with multi-disk albums.

The struggle doesn’t stop there though. On Windows, it is a bit better - it has Winamp, AIMP, and Foobar2000. Mobile devices are, however, in a similar trouble as the Linux desktop - good luck finding a decent no-bullshit local-first music player for Android. I know, it has AIMP, VLC, and MPV but out of these three only AIMP is a music player. There are paid music players too, but I don’t know if any of them actually good. And I don’t have an Apple device, so I don’t know if it has good non-stock music players.

So I landed up on Strawberry for now - it works better than everything else, but I’d like something a bit simpler. Seriously, though - bring .cue support to GNOME Music and it got pretty much everything I need.

Comment via email

Overcolorization

Fri, 17 Nov 2023 22:45:00 +0300

Tree-sitter became more widespread and Emacs took notice and included a bunch of <lang>-ts-mode as alternatives to <lang>-mode into the core. This is good news and a welcome change, but I have some concerns about the approach.

When I first saw the Tree-sitter talk by Max Brunsfeld I was concerned that the language highlighting “fix” they’re talking about is too much. Here are the screenshots from the talk before and after Tree-sitter:

Figure 1: In some languages, variables have different colors depending on context, types have different colors, struct fields don’t have their own color, etc.

Figure 2: Everything is consistent now.

Here’s an important quote from that talk:

It might seem like a subtle improvement to you but I really think it actually achieves the goal of making it so that you can kind of get the structure of the code just from glancing at the colors.

Structure, from colors. I don’t know, I have never tried to infer structure from colors in the code. I do write mostly in lisps today, and to infer structure there I, personally, use semantic indentation, not parentheses, despite a popular belief. There are people who use colored parentheses to make it easier to see where the expression starts and ends, but in my practice, there’s no need for that, and colors can be used for other things.

Before lisps, I was writing mostly in ALGOL-based languages, and again, there aren’t many places where I could infer structure from colors. I don’t think I can do that with the provided screenshot of the code in the talk either. I can see the semantics better, yes, since types and field accesses are uniformly highlighted, but this tells me nothing about code structure - the indentation kinda does.

But I’m being picky here. The word structure is not the word I have problems with in particular. And I can get what they mean - you know that the type color is blue, so when you switch languages, and the language defines types at different positions, you can spot them easily, despite being in a different place. It can be seen when they show C and Go examples on the slides with Tree-sitter highlighting. While all of that is cool, I think that coloring everything is the wrong approach.

Before Emacs, I used NeoVim and Kakoune, and I was too obsessed with colors in my editor. NeoVim by default highlights many things, and I’ve even created additional rules to highlight struct fields in C code. Kakoune also allowed me to define my own extra rules and I used it plenty of times.

But when I moved to Emacs, I noticed that, unlike other editors, syntax highlighting is much more reserved. For example, Emacs usually highlights function definitions, but not function calls. At first, I was upset, and searched for ways to enable more syntax highlighting, but quickly learned that the underlying system is slow, and the more you highlight the choppier Emacs gets.

But after years with Emacs, I began to like the more reserved highlighting. By highlighting important parts, Emacs helps me focus on important parts of the code. A function call is not that important, you call them all the time - the definition, however, is. The macro call, on the other hand, is important, as it transforms the code inside its body, so it is better to know that something that looks like an ordinary call isn’t actually an ordinary call. Rust solved this by forcing the use of ! in macro names, but Emacs had a different solution to the same problem in lisps for a long time by using syntax highlighting.

The following screenshot demonstrates how Emacs highlights the macro calls. The calls to defun, defmacro, and when are calls to macros. They aren’t special language constructs, just macros, but they do affect the language, as they transform the code given to them into something else and that’s why it’s important to see that you’re calling a macro. Calls to the ordinary functions like apply, or log-level-satisfies aren’t highlighted because there is not much significance with them - they return some values and that’s it.

The macros above are both standard to and known by Emacs but users can define their own macros. And we need to somehow highlight these macros as well as already known ones. Tree-sitter parsers can do that in a very limited way - if the macro comes from the same file it can be detected easily. If not - you have to analyze all of the files imported by the current file. Which becomes harder, when files are in external dependencies, possibly in compressed archives, and so on.

That’s where the dynamic highlighting comes naturally. Emacs controls everything related to Emacs Lisp so it can do that without much effort, but that can’t be said about every other language.

This is how Emacs highlights the Clojure code for me:

Figure 3: No dynamic highlighting

Emacs can’t know anything about Clojure, and thus we can’t apply the same logic when it comes to highlighting user-defined macros and other runtime stuff. But, the CIDER package provides a facility to highlight things dynamically, based on the state of the program. In this particular case it helps to see that some names came from the global scope:

Figure 4: Dynamic highlighting shows a global var

Similarly, CIDER can highlight user-defined macros:

Figure 5: Dynamic highlighting is enabled, but the macro wasn’t made known to the REPL process

Same as in Emacs Lisp, Clojure macros are small compilers, so it’s better to indicate that certain calls are special:

Figure 6: After sending the macro to the REPL, dynamic highlighting shows the user-defined macro

Another use for dynamic highlighting can be found in languages with dynamic scoping, which today are mostly only lisps. It is important to know if the variable you’re using is a dynamically scoped one. Especially so, when let can both introduce locals and re-bind dynamically scoped variables. For example, again, in Emacs Lisp:

Figure 7: No dynamic highlighting

The issue here is subtle, but if foo uses dynamic-var internally, it will see the value changed to 20. Dynamic highlighting helps to indicate that dynamic-var is special and important:

Figure 8: Dynamic highlighting shows a global var

I’m using descriptive names, like local-var and dynamic-var but in actual code, it’s not as obvious, when something is dynamic. A few months ago, I encountered a weird bug in one of the projects I maintain, and it was related to dynamic var being used as a local one:

Figure 9: compile-command is a dynamic var

Here, the variable named compile-command is just a string, used to store a command to compile the source code. The name is innocent and semantically appropriate. However, it is a dynamic var introduced in the compile.el package, and changing compile-command can cause problems for any functions called from the body of the let block. In my case, some other package adviced one of the calls inside this let block, overriding the compile-command for them, breaking the package I maintain.

Sadly, by default, Emacs doesn’t highlight such variables. And, as I said, Tree-sitter can’t really help with any of the above cases without parsing all of the code. But it often can be achieved with an external package that consults with the runtime, like CIDER for Clojure and highlight-defined.el¹ for Emacs Lisp. Luckily the fix was easy, but if Emacs highlighted dynamic vars by default, this would not be an issue at all.

So my point is - highlight the important stuff, not just stuff.

Of course, for lisps all these nuances existed even before dynamic highlighting, so lisp hackers had to deal with them somehow. Thus, dynamically scoped vars use different naming conventions (e.g. *dynamic-var*), macros use different code indentation rules, and so on. These rules are still widely used today but highlighting is an additional visual aid, making important stuff easier to notice.

But let’s go back to the main topic. I’ve called this post “Overcolorization” for a reason, after all. I wanted to show you the importance of selective highlighting first, and I hope it will make more sense on why I think there is a problem.

One of the reasons, Emacs highlighting is reserved only for important parts of the code, is because it is slow. Tree-sitter makes everything much faster, and thus Emacs should be able to highlight everything now without slowdown. That fact worried me, as it would mean that code could suddenly become a mess of colors when the <lang>-ts-mode becomes the standard. I held hopes that due to Emacs being used by generally more conservative people, the old approach to syntax highlighting would remain, what would change is that actually finding the important parts of the code will be easier, because the parser gives us all of the info.

Recently, I was toying with the Elixir language, and decided to use the now inbuilt elixir-ts-mode, because the non-tree-sitter mode has issues with automatic indentation, and jumping across the delimiters. Tree-sitter should naturally fix this, and it indeed does, but what am I looking at?

Figure 10: elixir-mode on the left, elixir-ts-mode on the right

Everything is purple. I’ve included the old mode on the left, so you can see what it looked like before I switched to the new one, which is actually suggested by the developers of the original elixir-mode. I mean, it’s pretty, and the colors do look nice in my personal opinion, but remember the quote I mentioned?

It actually achieves the goal of making it so that you can kind of get the structure of the code just from glancing at the colors.

The colors here clearly do not help the matter here. You could object by saying, that the colors should be used consistently, and I agree with you, here the main issue is that the font-lock-keyword-face is used for both keywords and method calls, as well as for parentheses. The font-lock-function-name-face is used both for function definitions, parameter names, and calls. But not for all calls, some use font-lock-keyword-face and I’m not talking about method calls: see raise. The font-lock-type-face is used both for types and :symbols. The operators aren’t highlighted only because the font-lock-operator-face is not set in my theme.

The highlighting is all over the place. Thanks to the speed and power of the tree sitter the code was made to look pretty, not informative. The same happened for a few other languages, but Elixir is probably the most offending in my opinion.

And I can’t fix that! Say, I want to remove highlighting of the method calls - but I can’t because for that I need to unset the face used by them, removing highlighting of the language keywords too. Same with the argument colors - they use function name colors, and I do want to see function definitions highlighted. I could override the treesit-font-lock-rules used by Elixir, only the elixir-ts--font-lock-settings is a private var, and it can silently be removed, renamed, and changed, breaking everything I’ve tried to fix.

I don’t want this post to be a bashing of elixir-ts-mode developers, I’m glad that the new mode was made, as it is better in many ways, but the problem with syntax highlighting exists, and other languages are in trouble too. In Lua, the lua-ts-mode does highlight table access but doesn’t highlight method calls which differs from table access by one symbol. Are table accesses more important than method calls? I think they both are equally unimportant.

The real problem here is that Emacs isn’t ready for semantic highlighting. It does now have Tree-sitter, which is a common interface between most text editors, so the problem isn’t with Emacs speed anymore. What it doesn’t have is enough standardized faces to use across all languages.

Or does it?

font-lock-comment-face - face used to highlight comments.
font-lock-misc-punctuation-face - face used to highlight miscellaneous punctuation.
font-lock-delimiter-face - face used to highlight delimiters.
font-lock-bracket-face - face used to highlight brackets, braces, and parens.
font-lock-punctuation-face - face used to highlight punctuation characters.
font-lock-property-use-face - face used to highlight property references.
font-lock-property-name-face - face used to highlight properties of an object.
font-lock-operator-face - face used to highlight operators.
font-lock-number-face - face used to highlight numbers.
font-lock-escape-face - face used to highlight escape sequences in strings.
font-lock-regexp-grouping-construct - face used to highlight grouping constructs in Lisp regexps.
font-lock-regexp-grouping-backslash - face for backslashes in Lisp regexp grouping constructs.
font-lock-regexp-face - face used to highlight regexp literals.
font-lock-preprocessor-face - face used to highlight preprocessor directives.
font-lock-negation-char-face - face used to highlight easy to overlook negation.
font-lock-warning-face - face used to highlight warnings.
font-lock-constant-face - face used to highlight constants and labels.
font-lock-type-face - face used to highlight type and class names.
font-lock-variable-use-face - face used to highlight variable references.
font-lock-variable-name-face - face used to highlight variable names.
font-lock-function-call-face - face used to highlight function calls.
font-lock-function-name-face - face used to highlight function names.
font-lock-builtin-face - face used to highlight builtins.
font-lock-keyword-face - face used to highlight keywords.
font-lock-doc-markup-face - face used to highlight embedded documentation mark-up.
font-lock-doc-face - face used to highlight documentation embedded in program code.
font-lock-string-face - face used to highlight strings.
font-lock-comment-delimiter-face - face used to highlight comment delimiters.

These are all of the faces defined in the font-lock.el package. There are separate faces for function definitions and function calls - good stuff. I don’t see the face that can be used for method calls specifically, but are there any major differences from ordinary function calls? It even has a face for variable usage, not just definition.

Thing is, many of these faces are new, and did not exist prior to Emacs 29.1. It’s good that they were added specifically to be used with Tree-sitter-based modes. You can say that I should submit a bug to Emacs about the elixir-ts-mode not using faces properly, and I did, but the problem isn’t specific to elixir-ts-mode.

The Elixir mode is just a convenient way to illustrate the problem The problem when lifting technical limitations can cause problems. A famous quote says “Limitations breed creativity”, and I feel like that’s exactly what was going on with the old method of syntax highlighting in Emacs. It was slow, and couldn’t handle too much highlighting or too complex rules, so it was kept to the minimum, highlighting what was absolutely necessary. But with Tree-sitter parsers being able to process files with 20k lines under 30ms the performance is out of the question. Well, mostly, you still need to draw everything on the screen, processing abstract syntax trees generated by these parsers.

I want to end this post with a message to fellow major mode maintainers.

Please, use syntax highlighting to highlight, not to color.

Syntax highlighting is a tool, and highlighting important parts of the code makes programming less convoluted. Pretty colors are nice to have, but if the point is only to make the code look fancy, there’s no real value for what we’re trying to do in the end - write better code. Let’s help each other at least at that.

BTW, highlight-defined.el by default tries to highlight everything defined, so I limited it down to only highlighting known dynamic vars. ↩︎

Comment via email

Why no one uses @media (prefers-color-scheme: dark)?

Wed, 15 Nov 2023 22:50:00 +0300

I don’t get it - it’s the simplest way to enable dark mode for your website that works across all platforms. It works on Linux, Android, MacOS, iOS, and maybe even on Windows (I didn’t test it, I have no Windows). I see websites that either use JS to do that or do no dark mode at all.

Some time ago I started using the Stylus extension for Firefox to override CSS for websites that don’t do the dark mode. And you know what? For a quick fix for most pages, it is as simple as:

@media (prefers-color-scheme: dark) {
    html { filter: invert(100%) hue-rotate(180deg); }
    img { filter: invert(100%) hue-rotate(180deg); }
}

Yes, this introduces problems on some pages, for example, embedded videos, especially YouTube ones are hard to invert back. Images may look horrific if they’re done with something else than the img tag, gradients and colors are preserved but shadows are still inverted, and so on. But if you have a web page on the web it is you who can do it right, so I don’t have to fix it for myself.

@media (prefers-color-scheme: dark) {
  body, textarea { color: #dedddc; background-color: #1e1e1e }
  code { background-color: #2b2b2b; color: #dedddc; }
  pre code { background-color: #ddd; color: #333; }
  kbd { background-color: #161b22; color: #dedddc; border: solid 1px rgb(57, 63, 71); border-bottom-color: rgb(37, 43, 51); }
  tbody tr:nth-child(2n+1) td, tbody tr:nth-child(2n+1) th { background-color: #212121; }
  table { border: 1px solid #333; }
  td, th { border: 1px solid #333; }
  .post-list { h1 a { color: #dedddc; &:hover { color: #7a5fa4; } } }
  a { color: #7a5fa4; &:hover { color: #7a5fa4; } }
  header h2 { a { color: #86868e !important; &:hover { color: #7a5fa4 !important; } &:active { color: #7a5fa4 !important; } } }
  blockquote { border-left: .25em solid #424242; color: #bebebe; }
  .org-svg { filter: invert(90%); }
  .invertable { filter: invert(100%) hue-rotate(180deg) contrast(79%); }
  .highlight { filter: invert(100%) hue-rotate(180deg) contrast(110%); scrollbar-color: #9c9c9c #ddd; background-color: #ddd; }
  .title-group { .title { a { color: #dedddc !important; &:hover { color: #7a5fa4 !important; } &:active { color: #7a5fa4 !important; } } } }
  input, input[type=file], button { background-color: #161b22; color: #dedddc; border: solid 1px rgb(57, 63, 71); }
  .diff-added { background-color: #e2c3da; }
  .diff-removed { background-color: #9fe0d6; }
}

This is all it takes to make dark mode for this page and the rest of the site. Yes, I use some filter attributes for specially constructed images and code, and yes, some browsers may not support it, but it generally works well.

I’m bringing this up not because I’m some freak who wants dark themes everywhere - no. My PC switches to the dark theme in the evening automatically to be easier on the eyes with the overall brightness, and when I open some web page it often blinds me with a white background. Not only it is unpleasant, but it is also bad for your health, as at the end of the day your body is more relaxed, and a sudden flash of light forces your eye muscles to suddenly contract. It’s advised not to look at the screen for several hours before bedtime, but I have a lot of work to do after work, so I can’t really afford that.

I don’t browse the web that much, but have a look at the pages I did adjust because I refer to them fairly often:

Most of these are static pages.

Is it that hard to add a single @media (prefers-color-scheme: dark) {...} block to the style file?

Well, I’m not a web developer. I don’t know your ways and such. You can say that your pages are complicated, your stylesheets are complex and generated with some preprocessor, or you’re using some framework that doesn’t allow you to do that or whatnot.

I’ll happily take even the stupid invert filter - as long as it is easy on the eyes I’m good. And yes, there are ways of forcing dark mode on everything, so I guess you can pretend there is no issue here, but it is not true.

Dark mode makes it easier to read stuff in the dark without causing too much eye fatigue - that’s the whole point. Tone your colors down a bit, bring the contrast down so the light text isn’t cutting the eyes against a pure black background and you’re good. And please, don’t use JS for that, or at least consult¹ with the prefers-color-scheme query, so that your JS code synchronizes with my system-wide preferences.

Please add dark mode to your static pages. It’s not that hard.

The stackoverflow was painfully bright at the time of writing this post ↩︎

Comment via email

Game2 W4/4

Fri, 25 Aug 2023 18:35:00 +0300

Well, It’s unfortunate, but I couldn’t make the game in these 4 weeks. August is just too much of a pain in terms of the amount of different events - maybe even the busiest month in the whole year, for me personally. Judging by the commit history, I was able to work only for 11 days out of the 28 days given to me by the challenge - and I tried to do at least some work every day and commit everything I did. I’m saying 11 days, but maybe 5 of these were in this last week.

This last week was all about level generation and, unfortunately, I failed at it. I was trying to implement the Wave Function Collapse algorithm in Lua and for some weird reason, it didn’t work. After three failed attempts, I decided to cheat. My idea was to go and port my ClojureScript version to Fennel form by form and compile it to Lua after it works. However, it didn’t work as well, no idea why. For some reason, some branches in my code are just never visited at all, although I did everything the same way, and implemented missing pieces from Clojure’s standard library for this code to work. At least it terminated, but instead generated a complete gibberish:

>> (wfc (gen_world 9 9) coast)
[["🟩" "🟩" "🟦" "🟦" "🟩" "🟩" "🟩" "🟦" "🟩"]
 ["🟩" "🟩" "🟫" "🟦" "🟫" "🟦" "🟦" "🟩" "🟦"]
 ["🟦" "🟩" "🟫" "🟫" "🟦" "🟫" "🟩" "🟫" "🟫"]
 ["🟫" "🟫" "🟩" "🟩" "🟩" "🟦" "🟫" "🟦" "🟦"]
 ["🟫" "🟫" "🟩" "🟫" "🟩" "🟦" "🟩" "🟩" "🟩"]
 ["🟦" "🟦" "🟩" "🟫" "🟦" "🟩" "🟦" "🟩" "🟫"]
 ["🟦" "🟫" "🟩" "🟦" "🟦" "🟩" "🟩" "🟩" "🟫"]
 ["🟦" "🟩" "🟦" "🟦" "🟩" "🟩" "🟩" "🟫" "🟩"]
 ["🟦" "🟩" "🟫" "🟦" "🟦" "🟩" "🟩" "🟦" "🟫"]]

It is supposed to look like this:

user> (wfc (gen-world 9 9) coast)
[["🟫" "🟫" "🟫" "🟫" "🟫" "🟫" "🟫" "🟫" "🟫"]
 ["🟩" "🟫" "🟫" "🟫" "🟫" "🟫" "🟫" "🟫" "🟫"]
 ["🟦" "🟩" "🟫" "🟫" "🟫" "🟫" "🟫" "🟫" "🟫"]
 ["🟦" "🟦" "🟩" "🟫" "🟫" "🟫" "🟫" "🟫" "🟩"]
 ["🟦" "🟦" "🟦" "🟩" "🟫" "🟫" "🟫" "🟩" "🟦"]
 ["🟦" "🟦" "🟦" "🟦" "🟩" "🟫" "🟩" "🟦" "🟦"]
 ["🟦" "🟦" "🟦" "🟦" "🟦" "🟩" "🟦" "🟦" "🟦"]
 ["🟦" "🟦" "🟦" "🟦" "🟦" "🟦" "🟦" "🟦" "🟦"]
 ["🟦" "🟦" "🟦" "🟦" "🟦" "🟦" "🟦" "🟦" "🟦"]]

This reminded me of the importance of data structures and their properties I keep forgetting when programming in Clojure. Because in Clojure it’s just the thing you have, so you don’t think much about it.

You see, Clojure has 4 main data structures, baked up with literals: list (a, b), map {k1 a, k2 b}, vector [a, b], and set #{a, b}. Each of these has its own set of properties, for example, lists are only fast to add elements at the front, and vectors are fast to add elements to the tail. Maps are mostly like Lua’s tables, and sets are like maps in the way that they can only store unique elements, and are indexed like a map but iterated like a list.

In my ClojureScript implementation of the WFC algorithm, I used all these data structures and relied on their behavior. For example, the superposition for a cell after the world’s initialization is a set of all possible values for the cell:

#{"🟦", "🟩", "🟫"}

I used maps to store the recipe:

{"🟫" {:up #{"🟫"}
       :down #{"🟫" "🟩"}
       :left #{"🟩" "🟫"}
       :right #{"🟫" "🟩"}}
 "🟩" {:up #{"🟫"}
       :down #{"🟦"}
       :left #{"🟫" "🟦" "🟩"}
       :right #{"🟫" "🟦" "🟩"}}
 "🟦" {:up #{"🟩" "🟦"}
       :down #{"🟦"}
       :left #{"🟩" "🟦"}
       :right #{"🟦" "🟩"}}}

The map itself stores maps with sets that are later used in the algorithm. Other data structures are at play for other parts of the whole process, but I’m not going to touch them here.

Lua on the other hand has only one collection type - the table. It can serve as a vector, to which you can add elements at the tail, and you can use them as hash tables, where there can only be a single instance of a given key. Sets can also be represented if we just use a table where keys are elements and values are the same elements or something like true.

local superposition = {["🟦"]=true, ["🟩"]=true, ["🟫"]=true}

This is actually what the “Programming in Lua” book suggests. The recipe then looks like this:

-- Sorry, not sorry for formatting - all these brackets on separate
-- lines take a stupidly big amount of vertical space
{["🟫"]={up={["🟫"]=true},
         down={["🟫"]=true, ["🟩"]=true},
         left={["🟩"]=true, ["🟫"]=true},
         right={["🟫"]=true, ["🟩"]=true}},
 ["🟩"]={up={["🟫"]=true},
         down={["🟦"]=true},
         left={["🟫"]=true, ["🟦"]=true, ["🟩"]=true},
         right={["🟫"]=true, ["🟦"]=true, ["🟩"]=true}},
 ["🟦"]={up={["🟩"]=true, ["🟦"]=true},
         down={["🟦"]=true},
         left={["🟩"]=true, ["🟦"]=true},
         right={["🟦"]=true, ["🟩"]=true}}}
-- also, the table syntax is just horrible - why square brackets are
-- needed around strings for keys? Why can't we write {"foo bar"="baz"}?
-- And why can we write {foo="bar"}? Why variable foo is not the same
-- foo when used in the table? Why foo is now a string?  The syntax is
-- too smart for its own good.

Now, here’s the problem - how do we tell apart sets from key-value tables? We can write some predicates, like is_set that either check that all values are true, or create a constructor function that will add a hidden __index metatable with a is_set key set to true, but it’s all pretty janky, in my opinion at least. A proper data structure should have its own syntax literal and a set of functions to check the type. Lua doesn’t even give you the ability to distinguish sequential tables from associative ones¹. I don’t think that Clojure’s choice of #{} for sets is great, but it’s a lot better than nothing.

But there’s also another issue with our implementation of sets - iteration support. In Clojure, you can iterate over any type of data structure, and it will actually do it in a meaningful way.

If you try to iterate over a list, vector, or set - it will just iterate over the elements:

user> (map identity '(:a :b :c))
(:a :b :c)
user> (map identity [:a :b :c])
(:a :b :c)
user> (map identity #{:a :b :c})
(:b :c :a)

In the case of a set the order is not determined, so the order of results is arbitrary. If you try to iterate over a map though, it’s a bit different:

user> (map identity {:a "b", :c "d", :e "f"})
([:c "d"] [:a "b"] [:e "f"])

Same as for the set, the order is arbitrary, but you can see that the elements in the list are vectors. That’s right, when we iterate over the map we get back vectors, containing the key and its value, which we can then use in the function that we iterate with.

You may be thinking: “Well, that’s the same as what pairs does in Lua” but it’s not. Unlike what I have shown to you, pairs will always return the key and value, even for vectors. Yes, in the case of a vector, the key will be an index, and we can pretty much ignore it most of the time, but what about our sets? In the case of our set implementation, the key is actually the value we’re looking for, because the value is just true. So no, implementing sets as tables that store true as a value is a no-go for most use cases, we have to store the value both as a key and a value in a set:

local superposition = {["🟦"]="🟦", ["🟩"]="🟩", ["🟫"]="🟫"}

But I digress.

Another, very important property of Clojure’s data structures is that they’re both immutable and persistent. This means that whatever we do with the vector doesn’t actually change the vector - it returns a new vector that shares the unchanged part of the structure with the old one plus new stuff. Clojure author went to great lengths to make this process fast and reliable.

I used this heavily in the CLJS version of the algorithm. Perhaps too heavily, but it’s a different topic. What it gave me though is the ability to change the world without mutating the original world, so every step of the algorithm actually produced a new world, and I could trace it back to the very beginning if I wanted to. It is not as fast as the mutation-based approach but is much more sane to work with and debug.

My first implementation of the algorithm in Lua, however, was mutating the world. Not only it is hard to debug, Lua makes it harder because you can’t view the data structure you’re working with. You probably don’t remember it, but I made a complete rewrite of the pretty printer for the Fennel language, and I did it mostly because the original one produced the representation that was hard to read due to indentation going all over the place. Well, guess what, Lua doesn’t have its own pretty printer whatsoever. You have to write your own or import some library that does it for you, which is not feasible with TIC-80, as its screen resolution is too small to comfortably read anything, especially huge tables that contain lots of elements, like the world I was trying to generate. Can you feel my frustration?

Then I made a hacky deepcopy function (another part that lacks from Lua because tables²) to at least get a copy-on-write type of immutability in Lua. This slowed down things to the point that it was useless for the sizes of worlds I wanted to construct. And it didn’t fix the problem, so it was somewhere else. I wasn’t ready to re-implement the whole thing again, so I stopped here.

Another thing I keep forgetting is how great Clojure’s standard library for manipulating collections is. There are all sorts of operations on sets, you can transform maps, iterate on anything, rename keys, etc., etc. Lua has a very rudimentary library for tables, that can’t do almost anything. Sure, there are libraries like Penlight³, and lua-stdlib that could help with that, and I made a port of Clojure’s core namespace to Fennel (and therefore Lua) but again - TIC-80 makes it hard to use these libraries. So, no, Lua isn’t great at manipulating data structures, and porting Clojure code to it is a pain. What did I expect? Well, I’ve ported all the functions I used in my CLJS WFC implementation, things like map, keep, map-indexed, get-in, assoc-in, etc., but there were still problems with how to iterate over tables, as there is no sequence abstraction in Lua, and it’s hard to make it properly. I tried multiple times before, and the best I got was my lazy sequence library for Fennel, but even there I took some shortcuts regarding the situation with tables that have both associative and array parts. Sorry Lua fans, but combined data structures like that are stupid.

I’m writing this a bit early, as there are clearly some more days until the end of this week, but then again, I won’t have time to do any work neither this evening, nor tomorrow, or the day after that. It’s a shame though, I don’t want to abandon this roguelike idea, and maybe I’ll get back to it after the challenge ends. Or maybe not, I don’t know. I will have another chance to make a top-down game, but probably without an isometric projection.

Looking back on the development process for this game I can see that choosing the isometric projection was probably the wrong decision. First, I struggled with the projection itself, then with the projection of screen coordinates back to the world coordinates. Halfway through I ditched the isometric projection and started drawing stuff without it, in hopes that I will just enable it back when the world generation is ready. But then the world generation was a problem. I didn’t even get to work on enemies, items, menus, and so on. Well, a roguelike is a lot more involved than a simple platformer, so it is expected that it takes more time to do stuff, but I didn’t have that time unfortunately.

Lua isn’t the one to blame for all these problems though. While I did get some frustrations with its syntax, overall the experience wasn’t that bad. However, I will not probably use it for upcoming projects. The lua-mode package for Emacs is in a rough shape - there is no pairing support for do end keywords, like in sh-mode or ruby-mode. Indentation is extremely slow and often unpredictable.

The next game on the list is a Card game but I’m not in the mood for that at all, so I’m going to change this and make a side-scrolling shoot-em-up kind of game. It should be much easier, and with all of the frustration built up over the last month, this is probably just what I need.

I know that the distinction isn’t possible because the data structure combines both sequential and associative parts in one package, but at least Lua could give us some predicates that would check if the associative part has any values and if the sequential part is not empty. This way we would be able to detect if the table we’re looking at only has the array part, or only has the associative part which is much better than nothing. It can be done in Lua but it is slow and often unreliable. ↩︎
It is hard to properly implement deep copying because of metatables. ↩︎
I keep forgetting its name and every single time I have to search for it as “lua batteries included” to only find a reddit post with a link to the repo that just lists lots of libraries for Lua. ↩︎

Comment via email

Spam Rant

Tue, 26 Jul 2022 20:21:00 +0300

Who doesn’t dislike spam? Well, apparently this guy loves it, but in a kind of special way. I definitively don’t like spam, even a clever one, but unfortunately, we all have to deal with it to some extent. This is a rant on spam because I was just fed up with it once again.

There are several categories of spam in my life:

E-Mail spam.
Spam calls.
SMS spam.
Promoted spam.

I think you all are familiar with the first three categories, and as much as I dislike these, there’s not much to say about them.

At least, the first two are kind of easy to deal with. I don’t read 99% of e-mails that end up in my spam folder, conveniently managed for me by GMail. While I don’t really like GMail, and rather move to a self-hosted mail, Google does a pretty decent job at tracking spam, even with all smart features being “disabled”. I never answer calls that aren’t on my contact list, unless I’m waiting for some kind of delivery. This is an easy fix because you can make your phone only make a sound when someone from your contact list is calling you, or even writing a message.

But the last two categories are hard to deal with.

SMS spam

SMS is still widely used for delivering various kinds of information to people. And for some reason, it is considered an official communication channel by a lot of people. For example, when you need to secure an operation in your bank, it will likely send you an SMS with a confirmation code. At least this was the case until some years ago when most banks I use switched to using their respecting application on Android/iOS, which is used to show the code now.

But still, some companies may send you such codes from time to time, and that’s basically the only useful case for SMS today. Well, emergency notifications are also distributed via SMS in my country, which may give SMS a kind of official status, but these are also broadcasted via other channels. However, mainly due to the confirmation codes it’s really hard to ignore SMS, and most of the SMS messaging apps (on Android, at least) use a modern conversation view, as opposed to how older phones worked with SMS as per separate messages. And this leads to a problem.

The first one is that you can’t block SMS from non-contacts, because these security codes are likely to be sent from some corporate number. While you could add such numbers to your contact lists, and be done with it, the problem arises when you want an SMS from a new service, so you basically have to disable filtering. Which defeats the purpose.

And the second problem is worse because the spam comes from the same phone numbers that are used to send you security codes. My bank, for example, not only shows me ads when I use their official app but also occasionally sends me ads via SMS from the same number they use to confirm operations. And they use the same number for spam calls too! You basically have to accept this. I call it promoted spam because it uses the same communication channel it uses for important stuff, just so you couldn’t block it easily.

Other companies, like clothing companies, for instance, have these club cards, that you register in order to have a discount from time to time or some other benefits. Guess what, in order to register such a card you have to supply both your phone number and your e-mail. And while e-mail is easy enough to ignore, they just keep spamming you with new ads even though the last time you’ve bought anything from them was 3 years ago. For that matter, you can’t give them a fake phone number because of the confirmation code they sent you before applying for a discount.

The most fun part is that my phone operator has a paid feature that blocks such SMS spam! And they remind me of it every single time I get a spam message that they have an anti-spam feature I can subscribe to. It’s like, they know it’s a spam SMS, they let it through, and immediately after it reaches you, they send another spam SMS that advertises you an anti-spam feature! I’d rather change my operator than subscribe to something like that.

Just unsubscribe

This is what I often hear when I brag about spam or read about it online.

Well, first of all, not all spam is something I’ve willingly subscribed to. Some of it is automated when you register a club card or some other account of sorts, and usually, there’s no way to disable these messages upon registration.

Some services don’t even have a way to cancel subscriptions! I once participated in a micro-controller-related conference, and in order to sign up, I used my personal e-mail, instead of the work one. It was a giant mistake, motivated by the fact, that due to security reasons it was impossible to use work e-mail outside the office, and I thought that I may need my e-mail for confirmation or some paperwork when I’ll arrive. Not only I didn’t need it, but I still receive yearly emails about upcoming conferences, highlights, and other stuff. And there’s no way to unsubscribe. I don’t have an account, their e-mail is random every time, they don’t respect GMail’s “unsubscribe me” feature, and there’s no e-mail to write back to a real human to take me off the mailing list. I’ve made a custom rule that deletes messages from them automatically, but it still manages to come through somehow sometimes.

And I’m not even talking about malicious spam, which is a different kind of beast at all. You can’t unsubscribe from it, obviously. Otherwise, it wouldn’t be as effective as it is.

But as I’ve said - e-mail is easy enough to automate and ignore, but SMS isn’t.

Much like the situation with the conference, you can’t unsubscribe from most promoted SMS spam. Companies just don’t even admit they’re sending anything to you like these messages don’t exist. I’ve tried coming to a customer’s office and speaking with a manager about the issue, but they basically told me to give up, and accept the situation as is. I’ve changed operator since then, but the story repeated.

So, no. You can’t unsubscribe from the majority of annoying spam. It’s not a solution. Forget it.

Just ignore it

I’ve used e-mail for a long time, and in the early days, I spent a lot of time marking stuff as spam, because filters weren’t that good enough yet, and spammers were creative. But not all people spent time, analyzing what is a spam message and what isn’t. And, more importantly, spammers are creative, and when we’re talking about malicious spam, which wants not only to advertise something you don’t want but also to steal your money or personal information, scammers today are as creative as they have ever been.

I’ve linked a TED talk at the beginning of this rant, and there’s one example of spam, that I’m not getting too often, but still see in the spam folder from time to time. But I know some people, who were victims of such emails, sending money to scammers.

And that’s the problem. Spam works, and spammers get what they want more often than you think.

There are a lot of similarities between spam messages/calls and TV advertisements. They steal your time and focus and promote you something you likely don’t even need. And unfortunately, nothing can be done about it really.

You can be extremely careful, and not put your e-mail and phone number anywhere, and while this cuts a lot, there are still systems that probe wide ranges of phone numbers automatically. I’ve actually tried it several times, and still somehow managed to get spam, even though nobody knows about this e-mail address, and phone number.

With SMS there’s also a point of trust because so much secure information comes through this communication channel, I’m a bit afraid to use anti-spam systems. As they will likely send my SMS to their server, and we all know that user personal data leaks every week these days.

So, yeah, unfortunately, spam is something I just had to accept, and I’m not sure if the situation will ever get better.

Comment via email

Why is Paredit is so un-Emacsy?

Thu, 30 Sep 2021 23:40:00 +0300

Here’s a quick rant, kinda.

I’ve become a huge fan of structural editing recently. My structural editing journey was maybe a bit unusual, but I’ve finally settled on Smartparens for quite some time. Originally I was introduced to structural editing by Parinfer mode which had some Paredit functionality, so it got me interested. Then I have been using Parinfer-rust for some time, but when I got the job in Clojure, I realized that it has a major problem of generating too much noise in the Git in commits because it needs to reformat the whole buffer to work, which is way too aggressive, especially when working with multiple people. I’ve already written a small article about parentheses, and various structural editing solutions in this blog, but I’ve actually changed my mind regarding Paredit style editing since that time. Learning some additional shortcuts and chords was not as bad as I thought it would be.

So I switched to Paredit, but it had some bugs related to Clojure, and I’ve replaced it with Smartparens with Paredit keybindings, and I was basically (mostly) satisfied ever since. But recently I’ve read Mastering Emacs (a great book) and decided to greatly simplify my Emacs config. I was tempted to replace Smartparens with Paredit because it felt simpler and more focused, but I’ve figured out that it breaks the tempo¹. I’ve tried to fix most shortcomings of Paredit, but it felt too clunky, and I’ve dropped the idea, since Smartparens doesn’t have such problems, so I’ve returned to it. Funnily enough, the sole reason I wanted to replace Smartparens with Paredit was that I felt that the configuration is way too complicated, but in the end, with all these fixes, Paredit’s configuration was even longer than the one I had for Smartparens.

So here are some problems with Paredit that I’ve noticed after reading Mastering Emacs:

Most commands that should accept negative (or just an arbitrary prefix argument) due to being mapped on a key that usually accepts it, completely ignore it instead.

For example, M-- M-d that acts as M-backspace in most editing modes, just ignores the negative argument in Paredit. I’ve managed to fix that with the following advice, but I’m not sure that every such command can be fixed this way, as there might be no counterpart command. This aspect of modifying commands with the (negative) argument became really important to me, because I’ve started using more motion-related commands, and Paredit basically prevented me from becoming more efficient.

(defvar aorst--paredit-reversable-commands
  '((paredit-forward-delete . paredit-backward-delete)
    (paredit-forward-kill-word . paredit-backward-kill-word))
  "Alist of `paredit-mode' command and their backward motion equivalents.")

(defun aorst/paredit-support-negative-arg (orig-fn &rest args)
  "Find ORIG-FN in `aorst--paredit-reversable-commands' variable,
and apply its counterpart, when the `current-prefix-arg' is
negative."
  (if (eq current-prefix-arg '-)
      (let (current-prefix-arg)
        (if-let ((f (cdr (assoc this-command aorst--paredit-reversable-commands))))
            (apply f args)
          (if-let ((f (car (rassoc this-command aorst--paredit-reversable-commands))))
              (apply f args)
            (apply orig-fn args))))
    (apply orig-fn args)))

(dolist (f (flatten-list aorst--paredit-reversable-commands))
  (advice-add f :around #'aorst/paredit-support-negative-arg))

Transient mark mode deletion feature that was added in Emacs 24 is purposely ignored by Paredit.

This again can be fixed with advice, and actually works reliably enough, making me only wonder why Paredit maintainers decided to put censored swearing in the comment instead of implementing the feature itself. Paredit has everything needed to do this, and yet chose to ignore the feature. It’s easy to fix this with advice, but again, Smartparens does respect Emacs’ design decisions. Here’s the code I’ve written to fix this:

(defvar aorst--paredit-delete-region-functions
  '(paredit-forward-delete
    paredit-backward-delete)
  "List of `paredit-mode' functions that should support tmm region deletion.")

(defvar aorst--paredit-kill-region-functions
  '(paredit-forward-kill-word
    paredit-backward-kill-word)
  "List of `paredit-mode' functions that should support tmm region killing.")

(defun aorst/paredit-fix-tmm (orig-fn &rest args)
  "Allow deleting/killing a region if the expression is balanced."
  (if (and transient-mark-mode
           mark-active)
      (cond ((memq this-command aorst--paredit-delete-region-functions)
             (paredit-delete-region (region-beginning) (region-end)))
            ((memq this-command aorst--paredit-kill-region-functions)
             (paredit-kill-region (region-beginning) (region-end)))
            (t (apply orig-fn args)))
    (apply orig-fn args)))

(dolist (f (append aorst--paredit-delete-region-functions
                   aorst--paredit-kill-region-functions))
  (advice-add f :around #'aorst/paredit-fix-tmm))

In the end, after simplifying my config, I’ve completely turned off the transient mark mode, as it is really not as important as I thought. So maybe this is why Paredit authors didn’t bother to implement this feature, but I still think it’s not an excuse not to support it, some users may rely on it. And I still occasionally enable tmm with the C-space C-space shortcut, so support for this feature is still important to me.

Point position is wrong after using splice commands in inferior-lisp type REPLs and any other REPLs I’ve tried so far.

This actually looks like a bug, but I’ve also noticed that not a lot of people use structural editing in the REPL (maybe because of that?). It’s a minor inconvenience, however, I’ve had zero problems with Smartparens strict mode enabled in REPLs so far. This is very important to me, as I often write code directly in the REPL buffer, so I’d like to have all my structural editing features. Sadly, I wasn’t able to fix this myself.

All this may sound like I’m praising the Smartparens here, but it’s actually not true. Smartparens has a lot of its own quirks and problems, that I had to deal with. It is by no means a silver bullet, but in the current state it’s good enough, I guess.

My dream package would be something based off Tree-sitter (or any other blazingly fast parser) because it actually understands the structure of the code unlike Smartparens, which uses the regex-based search for that. Yes, regex can be used for implementing structural editing, and it works to some degree for languages other than Lisps, as shown by Smartparens, but it’s not near as accurate, as it would be with a proper parser. I’ve tried my best at implementing an algorithm that implements a backward syntax parser for Elixir to make Smartparens better understand the do: keyword, as it doesn’t require matching the end keyword, which broke the parser. It kinda works, but still breaks on some combination of symbols in the code, so it’s not nearly as good as a solution with a proper parser.

However, even with its quirks, Smartparens with the Paredit compatibility layer, and respect for the Emacs editing model, make it overall a better Emacs citizen than Paredit. Yes, it’s somewhat clunkier to configure, but in the end, you have more EMACSy structural editing than you get with Paredit itself, and I actually don’t really understand why is that, as Paredit is older, and was used by Emacs hackers for quite a long time before Smartparens appeared. If anyone knows the story behind that, please let me know!

If you’re interested to try out Smartparens, here’s my configuration, that makes it work similarly to Paredit in most aspects, so you don’t have to re-learn your muscle memory. I’m suggesting you try out Smartparens for yourself, and see if these features I’ve talked about are really worth the switch. It was for me for sure.

Tempo is the term from the Mastering Emacs book, which basically means that you don’t need to release Ctrl or Meta keys for some chord progressions, like when using M-- M-d instead of C-- M-d. ↩︎

Comment via email

Goodbye Google Play Music

Wed, 24 Jun 2020 17:53:00 +0300

Another good service is going to be shut down by Google. I was a happy user of Google Play Music (GPM) for a long time, and although it had some problems, I still enjoyed it. It has a decent web interface, and a fine mobile app, but most importantly I’ve listened to a lot of new music every day, and my library constantly evolved, thanks to Google recommendation systems, which is actually good.

But today I received a mail, in which Google asked if I want to transfer my GPM library into the YouTube Music service. I knew almost nothing about YouTube Music, so I searched a bit, and that seemed to be quite the same service, just re-branded, and with a bit more tight integration with the YouTube platform. So I’ve transferred my library and went testing their new service. At first, everything seemed to be OK, but eventually, I stumped into some issues.

Music availability and Topics

Here’s one album that I wanted to listen to:

But since I’ve transferred my music into YouTube Music, I’ve opened it there:

And, it is not the same. It seems that even though I’ve imported music collection from GPM into YouTube Music, apparently this doesn’t mean that I will have the same music. To make it more clear, in case you don’t see what’s the problem, here’s a table with song durations:

Song Name	Duration (Google Play Music)	Duration (YouTube Music)
Violet Storm	2:09	2:09
The Space Between	4:28	3:26
Swineheart	5:28	0:34
Silent Sirens	5:02	2:17
The Machine	5:59	1:15
Ouroboros	4:38	0:28
King of the Thistle Field	6:00	0:17
More Than Numbers	1:41	1:18
The Only Constant	17:27	17:27
Violent Sky	7:03	3:31
Total	60 minutes	32 minutes

Obviously, something is not right, as some songs are way too short, but there’s no clear way how to submit a report, and I’m totally unsure if the issue is going to be fixed since this band has quite a low amount of subscribers - 63 at the moment of writing this. And the reason for this problem is this YouTube topic. These topics are created automatically and will contain any garbage that was uploaded by someone, even if the tracks are cropped or edited. This is not acceptable for a music service. These topics can really hurt music bands.

I’ve then checked some other rather obscure bands (I don’t mean to offend anyone from these bands, your music is amazing), and found some differences in these albums. For example, Known/Learned album by Arcane - many tracks have different lengths in these two services, but song versions seem to be the same. Also strange thing:

Band discover-ability

Another problem is that bands with names that consist only of generic words are still handled poorly. This was an issue in GPM, and still an issue in YouTube Music. For example, if you open Need band page from their latest album at GPM you’ll see a page for the “need®” band:

I’m not sure if “need®” is a real thing. But if we will do the same thing on YouTube Music we will see this page:

For some reason, the page is called “I need $$”, has the cover from the “Every Day” album by completely another band, and even does not display this album alongside the two others. Well, at least in GPM it was just lowercase “need®”, which is still incorrect, but closer. However, Need band also has another of their albums at GPM, which are listed on a separate page, and if we will open this band page from one of those albums, we will see an entirely different band page:

The page is named “The Need” which is not the correct name once again, and there is a band with such a name, which is listed along with albums that I’m actually looking for. We can do the same thing on YouTube Music, and the resulting page has mostly the same content:

So in the case of this band, it seems that YouTube Music fully inherited the problems of GPM, and I’m not sure if re-branding is supposed to fix this or not with their topic system. And if it was my band I would be offended by such poor handling of band names.

Library management

Another issue with YouTube Music is that it sorts my library in a very strange way. E.g. when I open the “Artists” section I see this:

And there’s no way to sort this thing in a more manageable way, like alphabetically. Why would I want this? It’s way easier to navigate and search for some artists if they are grouped together. Currently, I have a lot of trouble finding one specific artist I want to listen to because of this. Literally spent about 7 minutes to find it, because I didn’t remember the artist’s name, but at least I remembered that it started with “R”, and there aren’t many artists that share this property, so in an alphabetically sorted list I would find it way faster.

And, GPM had a very handy feature, which seems to be missing from YouTube Music. Here’s how the artist page looks in GPM:

You can see that I’ve decided to add their latest album to my library, because I’ve liked it, and perhaps want to listen to it in the future. Here’s this artist’s page on YouTube Music:

I’ve imported my collection from GPM, and this artist is presented in my library, but there’s no way to tell which albums are in my library unless I explicitly check every and each of their albums for the “REMOVE FROM LIBRARY” button, and, perhaps, put this somewhere on the napkin so I won’t forget which albums I was actually interested in:

YouTube Music identity

I feel that the change, that motivated Google to shut down GPM and move its users into YouTube Music is simply because the Google Play thing is not attractive to an average user.

I’m thinking this way, because Google had a lot of services with such naming, e.g. Google Play Games, Google Play Books, Google Play Movies, e.t.c. And the Google Play thing seemed to be a big part of the branding, but perhaps not big enough for Music. And there are no new services that have Google Play in their names.

YouTube on the other hand is a very popular service, and its popularity increases daily, so calling another service after the most popular may seem like a good marketing move. I wonder if YouTube books will ever become a thing.

However, I don’t think that YouTube Music makes sense as a service. YouTube’s primary content type is videos. Sure there are music videos, and many artists used YouTube to host their entire albums as playlists with album cover art as a video, and some sort of a table of contents.

And YouTube Music seems to take this idea and turn it into a music service, where the video is not the main content, as not all tracks have music videos filmed for those. Previously GPM listed music videos under the album page, so you could watch these if you wanted to, but YouTube music takes the opposite approach, makes albums out of videos, and allows an option to play album versions of songs instead of music video versions (only in the paid plan). This kinda hurts the experience, because the video version is usually edited - it is often shorter, or simply a radio edit version. Or even, has some kind of generic band outro that breaks the flow when you’re listening to an album as a whole.

So for YouTube fans, YouTube Music may seem like a cool service, but for Music fans, YouTube Music may seem more of a downgrade as a service. Because we love music and do not usually care for the videos.

Alternatives

GPM will be shut down in December 2020. I don’t think YouTube Music will become any better by this time since too much music needs fixing, which was not done during the GPM lifetime, and will not likely be done until shutdown. And all this YouTube topic thing is not a good replacement for real albums that were available on GPM.

Thankfully there are alternatives like Spotify, Apple Music, and TIDAL, though their prices are different, and the music library maybe not be as big as GPM’s one. Although the library can be even bigger.

I’ve liked GPM because it allowed me to legally listen to countless amounts of tracks, albums, and bands without buying every single track I’ve liked. And I would not want to buy anything on Google Play Music or any other streaming service because of DRM. If there’s a way to buy something without DRM I will always prefer it. But paid subscription that allows me to listen to music without borders is an amazing thing, even if I do not own any of this music.

So I’m thinking to transfer my library to another service, and I guess it is goodbye for Google Play Music and YouTube Music altogether.

Comment via email

C Needs Better Syntax and Macros

Mon, 06 Apr 2020 15:42:00 +0300

Today I’ve decided that I want to write a little rant on the topic of language design. Since I’m a C programmer, and I use it on a daily basis, I’ve had many thoughts about C syntax over the past few years. I like C, and it is a good language, that defined modern operating systems, and software. But I think that C still needs a better syntax and macro system. Not because C syntax is inconvenient to use, but because the syntax is a tool of expression. And macros can extend this concept even further.

You know, we, programmers, use a programming language to communicate with computers. When people are communicating with other people, the language is constantly improved, by adding new constructions and removing inconvenient and old ones. This helps language to be up with the current realities, and not die like, for example, the Latin language. No one speaks Latin not because it is inconvenient, but because it is poor. And C syntax is poor as well.

Let’s have a little test. Imagine that you’re a C compiler, I’ll give you the beginning of the line, and you will try to guess what is happening in it:

int something…

What could it be? This is certainly a declaration of something, but what exactly? Maybe it is an integer variable declaration, like int something = something_else;. Or maybe it is function declaration, like int something(something_else);. Or maybe something is actually a macro? Then something may actually be something_else. And don’t think that if you see something(something_else); it always will be a function, because it can actually be a function-like macro that expands to whatever it likes to! Ah, that also can be an array pointer - int something[].

There’s no way to tell… unless we look ahead. Sure, it is not a problem for the compiler, and such things as functions, or arrays have obvious and well-known syntax. In the case of macros, well, you can’t know without checking it yourself or using some sort of a tool that can show if the thing under the cursor is macros or not. This may not be a problem for compilers, but for us, humans, this is an issue, because we see code, but can’t immediately see the connection between the code and what actually will happen. This may seem like a minor issue, but when dealing with large codebases which use tons and tons of complex macros, it became really tedious. Most of the time good tooling can help with that, but more certainty would be an improvement.

Of course, we can complain all we want, so instead let’s discuss how to improve this. I’ve programmed for more than 5 years in C at work, mostly writing bare metal software for SoC, so my interest lies in the niche of compiled/system languages. I’ve also occasionally used C++ at work, seen some Java syntax, and recently got into Rust. Rust is somewhat known as a language with quite ugly and verbose syntax, but I don’t think so, and its syntax improves much upon C and C++. And I’m sorry C++ guys, but C++ syntax is pile of trash¹.

Let’s compare the example code above with Rust variants for each of our guesses:

Function:
```
fn something…
```
Variable:
```
let something…
```
Pointer and array:
```
let something…
let something…
```
Uh oh, pointers and arrays are declared exactly how variables are, but that’s not a problem, because in Rust variables hold pointers, and type of the variable is specified after variable name and before assignment. So it is not an issue, because we know, that plain variable, array, pointer, hash-map, and everything else will have the same syntax.
Macro:
```
something!
```

Bang! Macros always end with !, which makes those easy to see and expect something to happen. This means, that Rust covers 3 out of four complaints I had, and the remaining one is meaningful in terms of the language itself, so this is kind of 4 out of 4. Though these are not the only problems with C syntax, so let’s dive more in-depth.

Type Cyntax

Let’s discuss the type syntax. C features these default types:

char - for 8 bit sized data.
short - for at least 16 bit sized data.
int - for at least 16 bit sized data.
long - for at least 32 bit sized data.
float - for single precision floating point data.
double - for double precision floating point data.

So far so good. Well, sizes are bit strange, like int and short are both at least 16 bit, but this is architecture dependent, and that’s another problem and another topic. There’s one more type that exists but doesn’t quite fit the previous list:

long long - for at least 64bit sized data.

Did you notice that? No? Then let me point it out. It uses two words to describe a single idea while previously we had single-worded types, that represented a single concept.

Well, actually all types that were listed above can use two words, e.g. unsigned char, but this describes that this very type is not only for 8bit but also has no sign. There are two concepts that are described with two words. Not for unsigned long long though.

To be honest, all those types except int, and char, can be written using two words that specify length. We can rewrite the previous list as follows:

char
short int
int
long int

It makes sense for char not to be short or long because it is widely used to store ASCII characters, which need 256 variants and this always needs 8bits. This also makes sense for int to be short or long, to fit 16 or 32 bits. Not for long long though! See:

long long int

Again three words to describe the concept of two. Anyway, I’m nitpicking because there’s a better approach available. And most C programmers use it, I believe:

typedef signed   long long int int64;
typedef unsigned long long int uint64;

And we’re now describing the whole concept with a single word: uint64. Look how easy it is now to get everything we need to know. Size? 64. Has sign? Check for u at the start of the word. This can be repeated for all other types:

typedef signed char   int8;
typedef unsigned char uint8;

typedef signed short   int16;
typedef unsigned short uint16;

typedef signed int   int32;
typedef unsigned int uint32;

typedef signed long long   int64;
typedef unsigned long long uint64;

Notice the common pattern? int repeats in every type name we defined. Rust went further and removed it:

i8, u8
i16, u16
i32, u32
i64, u64

I don’t think that i for signed is the best choice, but I’m fine with this. And types are now very consistent and short. Although compound multi-word types have one advantage over a predefined set of types because we have more control over whether we want our type to be signed or long, this is also error-prone, because someone may assume that long long long int is a valid type, while it’s not.

While we’re on types, I think that defining types before objects have little sense too. In Rust type is specified after object name and it reads well, e.g.:

   let    name  :  &str       =       "John";
// |      |     |  |          |       |
// define thing of some type, holding something

Compared to C:

   char *       name   =       "John";
// |    |       |      |       |
// type pointer thing, holding something

And it is known practice in C to read declarations in the opposite direction, e.g. name is pointer to char. There’s also a clockwise spiral reading rule that can be applied to functions and arrays:

str is an array of 10 pointers to a char.

Although for the function pointer it seems that counterclockwise fits better:

fp is a pointer to a function that accepts an int and a pointer to a char and returning a pointer to a char.

English is not RTL, why would we need that stuff in C? Rust uses one more construct to define this and it is :, which in C is used in ?: operator and in case statements. And, case _: is a well-defined syntax, since case is a keyword, so we can’t mix it up with type annotation. ?: is used only after =, so it’s also well defined:

          a     :  int   =       42;
//        |     |  |     |       |
// define thing of type, holding 42

   case 0 :           a     :  int  = cond  ?      1 :  0;
// |    | |           |     |  |    |       |      | |  |
// case 0 then define thing of type holding either 1 or 0, depending on cond

Case with case is like an edge case, and quite uncommon even with current syntax, so I don’t think that this is a problem. There is another use for :, which I’ve never actually seen in my practice, that it can be used for bit size indication instructs, so unfortunately we can’t use it for types in the same way how we use * both for pointers and multiplication:

struct item {
    int f : 28; // 28-bit field
}

But this just means that for bit fields we can specify that it is valid to use : for the second time:

struct item {
    f: int : 28;
}

Just like that in official syntax : as a bit-field specifier is the only valid syntax in struct, the second use of : could be also only valid in struct. This way we could use uniform syntax for type declaration. Here’s a side-by-side comparison of the standard syntax, and what I think is a better alternative:

typedef struct my_IEEE754 {
    union {
        struct sf_t {
            int fraction : 23;
            int exp : 8;
            int sign : 1;
        } sf;
        float hf;
    } f;
} my_float;

int main(int argc, char * argv[])
{
    my_float pi = { .f.hf = 3.1415f };
}

Now with imaginary syntax. I’ve kept those constructs that I’m fine with, such as struct initializer, and I also changed char*[] to [*char] so it could be read as array of pointer to char without falling back RTL:

typedef struct my_IEEE754 {
    f: union {
        sf: struct sf_t {
            fraction: int : 23;
            exp: int : 8;
            sign: int : 1;
        };
        hf: float;
    };
} my_float;

main(argc: int, argv: [*char]) -> int {
    pi: my_float = { .f.hf = 3.1415f }
}

I understand that not everyone will agree with me here. I also prefer trailing return type, as in Rust, and even though -> is reserved for accessing struct fields from pointers, which is also true for C++11, C++11 still can use it for specifying the return type of the function, so I think C also could do that.

Although it seems that without a type at the beginning it’s harder to tell when we’re declaring something, and when we using a defined variable, Rust uses a special keyword let, since types can be omitted:

let mut a = 42; // declaration
        a = 27; // later use

However, in C we always specify type when declaring a variable so let can be omitted:

a: int = 42; // declaration
     a = 27; // usage

Pointers in C also have one interesting error-prone syntax case. Look at this:

int * a, b;

If we read this right to left or use clockwise rule, we will see, that b is of type int and a is a pointer to int. But during my practice, I’ve seen many cases when other programmers read this left to right, e.g. “declaration of the integer pointers a and b”. Unless you really know what’s going on, you can spend a lot of time wondering why your code misbehaves. And one reason for it to misbehave could be that someone forgot to add another asterisk:

int * a, * b;

Because of this problem, there are three different conventions on where to place the asterisk - near the type, near the variable, or in between. I, personally use the last one, as you can see, but this code can also be rewritten in this form:

int* a, * b; // quite ugly
int *a, *b;  // more concise

The first one is quite ugly, and error-prone, because it may seem, that we’ve specified int* type and all objects will have that type. And the second asterisk looks really out of place because of that. The second one is a bit better, but I think that it fails to define an idea that we’re pointing to type. I rarely write such constructions, because it gets messy when you specify values, so I split this into two lines:

int * a; // easy to refactor
int * b;

This is less error-prone and easier to refactor. And I think that I would rework this to be

a: *int;
b: *int;

There’s another interesting moment. C supports multi-word types, but users can declare only single-word types. This is a kinda double standard for me. And even if we could create multi-word types would be a total mess! And multi-word types ruin one major aspect, and it is used in macros.

Macros

Macros in C are not like macros in languages that feature macro systems as part of the language, like Lisp, or even Rust. In C macros are simple text substitutions, and expanded before compilation by using a preprocessor. So if you will write #define five 5 and then use five in several places, right before compilation, preprocessor will substitute five with 5. five is not a variable, but simply a placeholder for specific data. This is the most simple macro, but that’s not all that a preprocessor offers. We can use many things like #if, #ifndef, #else e.t.c. to alter how our source code will be compiled. And this is a source of some problems as well.

The first problem we stated was that macros can mimic the code too well. Because macros in C differ from actual C code and are a foreign thing, there should be a way of knowing what is a macro. The other problem with C macros is that those are text substitutions. Consider the following macro:

#define vec(T)          \
    struct vector_##T { \
        T * data;       \
        size_t size;    \
    }

We can use such a pattern to create generics or templates if you’re familiar with C++. This macro then can be used like this:

int main()
{
    vec(int) vector_of_ints = { .data = NULL, .size = 0 };
    vec(float) vector_of_floats = { .data = NULL, .size = 0 };
}

To understand what’s going on here, let’s substitute the macro call by hand. First, we substitute vec(int), with macro body and remember int:

struct vector_##T {
    T * data;
    size_t size;
} vector_of_ints = { .data = NULL, .size = 0 };

We’ve passed int as a parameter to our macro so we substitute T with it:

struct vector_##int {
    int * data;
    size_t size;
} vector_of_ints = { .data = NULL, .size = 0 };

Next, concatenation will happen at each ##, producing vector_int:

struct vector_int {
    int * data;
    size_t size;
} vector_of_ints = { .data = NULL, .size = 0 };

At this point, we’ve got macro fully expanded, and that’s how main function looks:

int main()
{
    struct vector_int {
        int * data;
        size_t size;
    } vector_of_ints = { .data = NULL, .size = 0 };
    vec(float) vector_of_floats = { .data = NULL, .size = 0 };
}

Then this repeats to vec(float), producing the final code:

int main()
{
    struct vector_int {
        int * data;
        size_t size;
    } vector_of_ints = { .data = NULL, .size = 0 };
    struct vector_float {
        float * data;
        size_t size;
    } vector_of_floats = { .data = NULL, .size = 0 };
}

Pretty cool, right? Wrong. We can’t do the same with long long:

int main()
{
    vec(long long) vector_of_long_longs = { .data = NULL, .size = 0 };
}

Because vector_##long long will produce vector_long long, and we can’t have multi-word user types. We can fix this by creating typedef, but this means that we have to create typedef for any type that we want to pass into such macros. Meaning that the pointers also gonna need typedefs:

typedef char * string;

int main()
{
    vec(string) vector_of_strings = { .data = NULL, .size = 0 };
}

This is one side of the problem. The other side is that we’re operating with text, not AST. To understand the difference let’s look at some Lisp macros, for instance, Clojure time macro:

(defmacro time
  [expr]
  `(let [start# (. System (nanoTime))
         ret# ~expr]
     (prn (str "Elapsed time: "
               (/ (double (- (. System (nanoTime)) start#)) 1000000.0)
               " msecs"))
     ret#))

I’m not going to teach you Lisp here, but still, let’s quickly understand what’s going on here.

This macro does three things, first, it creates local binding start# (# will generate a unique suffix for the name), which will hold current system time in nanoseconds, creates local binding ret#, that holds the result of an expression that we pass to time and then prints line which shows the amount of msecs that it took to evaluate the expression. In the end, the ret# is returned out of this macro.

To understand this, let’s expand macro in this expression (time (+ 1 2 3):

(let*
  [start1 (. System (nanoTime))
   ret1 (+ 1 2 3)] ;; our sum expression
  (prn (str "Elapsed: "
             (/ (double (- (. System (nanoTime)) start1)) 1000000.0)
             " msecs"))
  ret1)

So what macro did is, took the given AST, took (+ 1 2 3) expression out of it, and generated a new AST, where this expression is used in let* form, and the result is returned after time is measured. It’s a simple macro, but it shows some neat things about Lisp macros. Of course, it doesn’t represent Lisp macro system as a whole, but the general idea of Lisp macros is that you take one AST and change it to produce another AST at compile time. And you need to understand that we did not manipulate text here, but the code itself.

This macro is simple enough, so let’s write it in C:

#include <stdio.h>
#include <time.h>

#define time(code)                                           \
    __extension__({                                          \
        clock_t _begin      = clock();                       \
        __typeof(code) _res = __extension__({ code; });      \
        printf("Elapsed: %g sec.\n",                         \
               (double)(clock() - _begin) / CLOCKS_PER_SEC); \
        _res;                                                \
    })

int main(void)
{
    printf("%d\n", time(1 + 2 + 3));
    return 0;
}

Sure it works, and it uses some compile time magic, like __typeof, and GCC statement expression extension __extension__({ … }), but in the end this is still textual work. It will fail if we can’t get __typeof correctly, for example, if we want to measure our for loop:

time(
    for (volatile int i = 0; i < 0x1000; i++) {
        printf("%d\n", i);
    }
);

This will error, because for has no type. The problem is that we can’t return something if there’s nothing to return. If we could analyze AST and produce valid code it would work.

Another example of a C macro, that disables the evaluation of code is this log macro. The idea here is that the function, that we pass to log may be slow, because it needs to get a huge amount of data, so we need a way to disable logging while still keeping all of our code. Before looking at C, here’s the Ruby variant:

$debug = true

def log(&code)
  if $debug
    $stderr.puts code.yield
  end
end

log {"message: #{expensive_logger}"}

So the idea here is that we’re passing a function, and it will be evaluated only if $debug is true. Here’s the C version:

#include <stdio.h>
#include <stdbool.h>

bool debug true

#define log(fmt, ...)                          \
    do {                                       \
        if (debug)                             \
            fprintf(stderr, fmt, __VA_ARGS__); \
    } while (0)

int main(void)
{
    log("message: %s\n", expensive_logger());
    return 0;
}

Here we can see … and __VA_ARGS__. These are special ways to pass and access a variadic amount of arguments to the macro. This may seem like a little bit of AST manipulation, but again, this is just textual work, as __VA_ARGS__ expands to the sequence of arguments separated by commas, which means that we can’t do much with it.

To understand why direct access to variadic arguments can be needed in macros, let’s look at another more complex macro from Clojure - thread first macro ->:

(defmacro ->
  [x & forms]
  (loop [x x, forms forms]
    (if forms
      (let [form (first forms)
            threaded (if (seq? form)
                       (with-meta `(~(first form) ~x ~@(next form)) (meta form))
                       (list form x))]
        (recur threaded (next forms)))
      x)))

This is a more complex macro, that transforms AST, as shown in the time example, but in a different way. To understand it, we have to see what form of code it takes:

(-> 1
    (+ 2)
    (* 3 4)
    (/ 5))

And what code it produces:

(/ (* (+ 1 2) 3 4) 5)

What essentially happens here is, that we pass list of expressions to ->, which is (1 (+ 2) (* 3 4) (/ 5)) (lists in Lisp are delimited with parentheses), then we take first out, which is 1, and put it to the second position in (+ 2) thus creating (+ 1 2). Then we repeat it until we produce the final expression. Here’s a table of steps, where x, form, and forms illustrate the values that these variables are holding in the macro above at each step of the loop. When form turns empty, we return x:

`x`	`form`	`forms`
`1`	`(+ 2)`	`((* 3 4) (/ 5))`
`(+ 1 2)`	`(* 3 4)`	`((/ 5))`
`(* (+ 1 2) 3 4)`	`(/ 5)`	`()`
`(/ (* (+ 1 2) 3 4) 5)`	`()`	`()`

What’s interesting in this macro, and in Lisp in general, is that your code is your AST. This means that you can take it and change it however you want to, with the language itself. There are no other facilities for this, but those you use when you write regular code. This is not suitable for C, because the relationship between syntax and AST is not 1 to 1 as in Lisp, so we have to use preprocessors.

In the example above, we saw iteration over forms that we are passing to macro. You can do something similar to that in C:

#include <stdio.h>

#define first(x, ...) #x
#define rest(x, ...)  #__VA_ARGS__

#define destructive(...)                              \
    do {                                              \
        printf("first is: %s\n", first(__VA_ARGS__)); \
        printf("rest are: %s\n", rest(__VA_ARGS__));  \
    } while (0)

int main(void)
{
    destructive(1, 2, 3);
    return 0;
}

Because __VA_ARGS__ is just a comma-separated list of arguments, we can pass it to the macro, which takes 1 explicit argument x and a variadic amount of rest arguments. The example above converts arguments to strings, but you can spot the general idea. Executing this code will print:

first is: 1
rest are: 2, 3

But this is not really useful in the context of the language, because there’s no way to continuously iterate over such lists of arguments without defining a finite amount of iterator macros for a given amount of maximum possible arguments ². So such a thing as thread first macro isn’t really possible. Which is a shame, because if there was a way to loop through macro at compile time something like printf could easily be defined as a macro. I’ve done printing macros based on this technique, which used Assembler primitive functions to display strings and numbers, and it performed way better than classic printf. This may seem like a strange point because usually performance of printf is not something you really want to improve, but it depends on the task, and in my domain, a serious performance drop is noticeable when using printf while working with bare metal emulation, which I do. Also, Rust doesn’t support variadic arguments in functions, but its println! macro surely does, because it is implemented in terms of iteration over the argument list and produces final printing code:

macro_rules! println {
    () => ($crate::print!("\n"));
    ($($arg:tt)*) => ({
        $crate::io::_print($crate::format_args_nl!($($arg)*));
    })
}

What I’m trying to say is that defining Domain Specific Language (DSL) for your project is good both for you and your project. It will make you more productive, and your code will be cleaner and usually much more compact and readable.

And that’s the point of the macro system in the language - it changes language to fit your concrete problem. Most C programmers say that macros are bad and should be avoided, but I think they are just scared of those because the implementation is really bad and you can make your code very tangled up with all #if #else #endif stuff. So what we can do with that?

Macro processor alternatives

While we can’t really change C, it is still possible to fix some issues outside. Let’s take a look at other macro implementations for C:

PHP - Use PHP to produce C code. I dare you.
Perl Preprocessor - use Perl to produce text or generate code. Not strictly related to C, but can be used in C, as well as in any other language. While I think that Perl is a fine choice, many people probably will not think alike. But Perl is excellent for text processing, so I think it may be a good one for C macros.
cmacro - macro processor for C written in Common Lisp. This is the most interesting discovery so far.
m4 - GNU M4 macro processor. It should improve the current state of the art in C macros, but I’ve never seen someone using it.
Probably tons of other projects.

Cmacro got my attention. It seems to provide good AST manipulation primitives for C code and seems like a complete solution. It also comes with a set of usable macros in a separate package.

The problem is, that if you’re going to use any of the solutions listed above, you will add additional development dependency for your project. This is not a huge issue but may cause problems or inconvenience for other developers that decided to contribute to your project. That’s why built-in support for a good macro system is needed.

While macro processors can be changed and integrated on a per-project basis, it’s not that easy to change syntax. Yes, good macro preprocessors can extend syntax, as Cmacro does, but this will not solve all problems of C syntax, such as pointers to functions, that return pointer to function and take several pointers to functions, that take some arguments, as arguments. Just try to write this, and any Lisp code will look like candy for you. Look here³ if you don’t want to waste your time, as I’ve wasted mine already.

Alternative syntax?

Although I’ve listed some different preprocessors that can fix or enhance the macro system in C, who said that we need to solve the problems of C syntax and macro system independently?

Instead, we can create language, that transpires to valid C. There are many languages that took this approach, and while I think that most of those change syntax too radically, it still may be good for us. To name a few:

Gambit Scheme - CGambit is a compiler for Scheme, that generates portable C code.
Nim - a language with Python-like syntax that can be compiled into C.
Vala and Genie - GNOME projects aimed toward C with improved syntax and support for classes through GObject.

So C as a host language is not a new idea, but which of these languages expand macro abilities, while still staying close to C syntax, just improving it in different areas? None. Vala is more like C++, but the macro system is not enhanced compared to C. Genie and Nim are Python-like, though Nim got pretty good macro support because you actually can change AST. Gambit also greatly enhances the macro system, because it is a Scheme.

However all these languages, except, maybe, Vala, differ from C dramatically, so this may not be a good choice for everyone. I’m sure that there may be a language that suits this better, but I’m unaware of it as of today.

There’s one more language though, that catches my eye as a C developer, and it is ZZ. It features Rust-like syntax, which is good for me, and procedural macros. Though it’s not compiled down to C, it uses C ABI, so this may actually be a good point of transition of your codebase. The language is quite young, and I did not use it personally, so I can’t really recommend it.

Conclusion

To summarize my thoughts through this rant:

C is an old language, its syntax is ugly, and it doesn’t have to be this way,
Macro system in C is very lacking, and it doesn’t have to be this way either,
There are solutions to the problem, but neither of those can fix everything without caveats.
New languages, such as Rust and ZZ, are trying to fix problems of C, but the amount of legacy code written in C will not make the adoption easy.

So in my opinion the best solution to all of this is for C developers to provide a new standard with improved syntax and macro system, and keep the name of the language, so new code could be written in it, while still keeping old code working by using compiler flag that specifies standard, obviously. While this is not optimal, and a lot of work, I think the future of C depends on this.

C++ in my opinion has the worst syntax because it has so many of it for a single thing. Like there’s too much different initializer syntax, two ways of specifying return types, a lot of implicit things that are syntactic sugar, and so on. When I was trying to get into C++ it was a mess, like where do I use this initialization, and where do I use that? For professional C++ developers that might be a good thing, but do we really need this kind of thing at all? This is something like a balance between lines of code and amount of different syntax for the same thing, and I would prefer more lines of code wrapped into a macro that is used for this particular task I’m working on, and not several different syntax variants that are available all the time. ↩︎
This SO answer describes how to iterate over variadic arguments in C macro. General idea is that you define a finite amount of reduction macros, and call one depending on the overall amount of parameters that were passed initially. E.g. you define helper1, helper2, helperN, and when you call your macro with 5 arguments it will select helper5 and call it, helper5 then will call helper4, and so on until it reaches the last one. ↩︎
void(*f0(void(*f1)(void(*f2(void(*f3)(void)))(void))))(void(*f4(void(*f5)(void)))(void)) {return f1;} ↩︎

Comment via email