evil

wayland has been "the future of the linux desktop" for a decade now, but it sets a dangerous precedent for modern open source. x11, trust me when i say this, is very much corposlop. ibm was literally a co-creator, project athena was basically fully funded by ibm and dec, and even through all its changes (x consortium, cde, x.org), ibm stayed a core member. however, when it comes to wayland, ibm/red hat is quite literally THE primary driver. kristian made wayland while a software engineer for red hat, and red hat pushed it onto fedora YEARS before it was ready.

if you go to the commit histories of things like xwayland or libwayland, a lot of core features are added by @redhat.com email addresses. same with gnome; gnome is still heavily red hat corposlop, and mutter was one of the first "capable" wayland display servers, so wayland over time has become pretty gnome-centric. the best example is middle click paste (which needed a primary selection protocol to be standardized). it was delayed for years purely because gnome didn't like it. or look at xdg-decoration, which gnome still won't support, forcing every non-gtk app to include extra code just to draw their own title bars.

the main thing is x11 is just so old that no one really owns it anymore. nowadays xlibre is a thing, and it is slowly getting better as the only maintained x11 fork. wayland is new enough that it is very clear who owns it, and it is massive corporations and people that do not have our best interests in mind. i will die on the middle click paste hill. i use it literally every day, it's actually useful, but because some gnome devs didn't like it, it was held back. meanwhile, in x11: xinput set-prop "[mouse]" "libinput Middle Emulation Enabled" 1.

rust is aggressively pushed as the silver bullet for memory safety, but it comes at the cost of massive cognitive overhead. the borrow checker is notoriously strict, often forcing you to fight the compiler just to implement basic data structures like linked lists or graphs. it actively discourages certain valid patterns of programming because it cant prove them safe at compile time.

beyond the syntax, the tooling encourages bloat. build times are measured in centuries, and it relies on pulling in a massive dependency tree through cargo just to accomplish basic tasks. the resulting binaries are statically linked behemoths.

additionally, rust suffers from the nodejs-virus. because it has a central package manager, people have gotten lazy, just like in the modern js ecosystem. "why write things yourself when you can just add a library that does it for you!" is my biggest issue with js and c++ to some extent, but rust has quickly overtaken c++ and is now competing in a race to the bottom with javascript.

c++ is what happens when you take a perfectly good systems language and bolt on every single feature every single person has ever asked for over the course of forty years. the result is a retarded language to say the least, where every codebase uses a completely different, incompatible subset of its features.

additionally, similar to rust, c++ faces dependency bloat. and it faces it a LOT. just look at BOOST. boost is an over-engineered monument to template metaprogramming idiocy. it turns simple tasks into compiler torture sessions; including a single boost header drags in a massive, retarded web of thousands of transitive includes. you can probably write a c compiler in the time it takes gcc to finish parsing a single file using boost::asio or boost::spirit.

for more, read this (harmful.cat-v.org/software/c++)

these are dynamically typed scripting languages that trade execution speed for developer convenience, but they take it too far. they run incredibly slow, making them terrible for anything computationally heavy unless you are just using them as glue code for c libraries. additionally, i have some VERY nice comments about pythons whitespace sensitivity, which i can not share due to it being "hate speech".

anyways... worse is their environment management. pip breaks system packages constantly if you aren't careful, and ruby's gem ecosystem is filled with monkey-patching that makes debugging a complete gamble. perl and awk are super lightweight, and builtin to pretty much every single unix system, and process text flawlessly without needing twenty megabytes of venvs'. tldr; use awk always, and use perl if you hate awk

nano is way too simple to do anything in, it's pretty much a glorified terminal notepad for people who just want to quickly edit a config file, but it is still a bloated mess. use nvi (or ed, its a good idea, trust me bro!) instead for simple changes. vim, on the other hand, depends on a meh modal editing system that often just adds an unnecessary layer of cognitive load when you are just trying to get text onto the screen. (and uses vimscript which is... an interesting language to say the least.) neovim does not fix it, all it does is replace trash (vimscript) with feces (lua).

emacs is fundamentally different. it is infinitely extensible and doesn't force you into a strict modal workflow unless you ask it to. you can modify it to do exactly what you want. it does one thing and does it perfectly; it evaluates lisp.

it's digital communism. need i say more? fuck communism.

true software freedom means giving the user the right to do literally whatever they want with the code. permissive licenses like bsd, isc, mit or placing it in the public domain don't enforce ideological conditions. if i write code, i want it to be useful to people, even if that means they throw it in a proprietary project and make money off it.

freebsd tries too hard to be a jack-of-all-trades. it has adopted a lot of modern linux-isms and corporate bloat, losing the tight, cohesive integration that originally made the bsd ecosystem appealing. netbsd focuses so heavily on portability and running on every obscure architecture known to man that it often neglects the modern desktop or standard server experience.

openbsd, however, is pure, clean, and does exactly what it says!

systemd is like a digital anaplastic thyroid cancer. just like atc does, it has aggressively spread far beyond what it should be. it has taken over logging, dns resolution, networking, time syncing, and cron jobs. this creates a massive single point of failure and essentially reinvents windows svchost on linux.

its insistence on using binary logs makes recovery incredibly frustrating when the system crashes and you can't just use standard text tools to read the output. if you like your sanity, and you don't like enshittification, please, for the love of God, switch to a distro with init freedom and use ANYTHING other than systemd.