The EU's take on free speech and freedom in general shows a deeper understanding of freedom than any country has ever shown in the world. Freedom is not just free speech, freedom of religion, freedom of expression, freedom of the press, and so on, individually. With freedom comes responsibility and the rights and freedoms of one person should never violate those same freedoms of others. That implies there has to be a balance between all the different kinds of freedoms as well as all the different kinds of fundamental human rights.

Freedom of speech means nothing if it violates others' freedom of religion. Freedom of religion means nothing if it preaches hate agains people who think differently or compels its followers to kill them. Freedom of the press means nothing if it leads to social media being overwhelmed by desinformation. To name just a few.

That does not mean there cannot be any grey areas. Sometimes the perception of a thing is not the reality of a thing. If a person feels their rights and/or freedoms have been violated, they can take it up to court and let the judge (or in some EU countries a jury) make a ruling on the matter.

I stopped using Ubuntu and taking it seriously when it introduced 'netplan', the idiotic network configuration system where one ill-placed whitespace character could lead your entire system into a boot loop (especially in conjunction with systemd, Linux's own version of svchost.exe).

Repeat after me: whitespaces are NOT tokens and should be ignored.

USB-C is a joke. Or at least the connectors and receptacles are. The most frequently occurring issue with USB-C ports on laptops is that the receptacle breaks off because they are simply too fragile.

While fascinating from a technical perspective, I never understood the benefit of this. Why not simply use a proper Linux setup, for instance in a VM?

It reminds me of the time those Italian seismologists and geologists were brought to trial and imprisoned for not having given enough warning about an impending earthquake.

Fortunately, in the end, but after many, many years of wrongfull imprisonment their innocence was confirmed and they were finally set free.

Speaking of sham trials...

Wayland is a solution to a problem that never existed.

X11 - especially Xorg - is perfectly capable of handling all the stuff Wayland is supposed to handle, and more and also perfectly capable of being extended to support anything new.

Moreover, X is a protocol that has existed for nearly 40 years. That makes it pretty much a stable protocol. And, that my friends, is the main issue some people have with X: it has a stable protocol. X provides the canvas, with a couple of extensions. It is up to another program to provide, for instance, the compositing or the window manager.

Some people tried to merge the canvas and compositing part with Wayland, which one should never do.

Systemd: svchost.exe for Linux. One great-grandparent PID to rule them all. Violates UNIX philosophy. Tries to do everything on its own and does not even manage to do it well. Therefore, MAJOR security attack surface.
Secure boot: Get your boot keys from your local hardware vendor (who in turn must get them from M$. Want to run an Operating System your vendor does not like? Bad luck.
UKI: Your vendor will support it. Nothing else. And given enough time the idiots behind systemd will find "valid" reasons to prevent a non-UKI kenel from booting. And since most if not all major distros nowadays depend on systemd...

Linux used to be about freedom and freedom of choice. That freedom will be gone once the circle is complete and UKI becomes the norm. Support freedom and freedom of choice and pick a Linux distro that does not depend on systemd, secureboot or UKI.

"The fact something works for you doesn't mean it's not broken for someone else. This is Linux, you are free not to adopt any piece of software developed for it. That's the beauty of open source."

And herein lies the problem: that freedom is mostly gone. If you want any kind of GUI nowadays, you're more often than not stuck with systemd, because literally EVERYTHING depends on it. It is not impossible, but it is not for the faint of heart either. The best solution so far seems to be to use a distribution that is specifically built not to rely on systemd. Devuan for instance. But even Devuan ultimately uses replacement libraries under the hood that provide the services that elsewhere got gobbled up by systemd, precisely proving the point why systemd was a bad idea in the first place and still is.

The UNIX philosophy is having a program do one thing and do it well. Systemd tries to do everything on its own (although it does call other programs) and does not even do it well. And you know, having a process with PID 1 that is not simply a binary that only does the bare minimum to initialize itself and then hands off the control to a program responsibly for the next step in the boot-process is a disaster waiting to happen. Less code in that binary means less of an attack surface. Systemd is a universe's worth of an attack surface...

"Yes, modern systems where the boot process isn't cobbled together by scripts..."

The UNIX philosophy is just that: let the boot process be handled by a small program which only does the bare minimum to initialize itself only to hand off the more complicated stuff to scripts that each do one thing and do it well. The very philosophy that systemd is in violation of by attempting to do it all by itself, and not do it well to begin with.

"Also linux is a single machine single user model "

Last time I checked Linux was stilll multi-user and could be put into a cluster using various types of software.

UEFI was never designed to be our friend. At the core of it lies the secureboot process, a buzzword that sounds like a good idea, because if weren't a buzzword it would be: startup the system with a known set of drivers, digitally signed so that tampering with them will prevent a system from coming up. This is in and of itself not necessarily a bad thing. However, there is also a downside to this: control of the secureboot architecture and platform lies with a single company. A company that has stated that it reserves the right to revoke any signing key that it feels threatens the security of the platform. In other words: in order for a system to be considered secure and trusted, we as consumers have to trust in the benevolence of a single company. That is a vendor lock-in waiting to happen.

What Mr. Poettering is now proposing to do is that we fall for this scheme and dig ourselves deeper into vendor lock-in land. This guy seems hell-bent on dismantling the last remaining bit of freedom of choice we have where Linux is concerned. Systemd, in and of itself already a violation of very core of the UNIX philosophy and still every major distribution jumped straight onto the bandwagon and made every single aspect of their Linux flavour dependant on it. Now, we're stuck with systems full of potential security holes, because everything is handled by a single monolithic process, instead of following the inherently better philosophy of writing small scripts or programs that do a single thing and do it well.

It used to be that Linux was all about choice. Don't like the BSD rc style bootup process? Use sysvinit. Or vice versa. Don't like either of them? Use another init flavour (or systemd if that's to your liking). But now entire portions of the userland -depend- on systemd to work. And why? Because some idiot with the barest of programming skills (remember the litter of bugs in the early versions of systemd) decided it could and should be done differently and the great masses of the people blindly followed suit.

Having very strict gun laws means nothing if those laws are hardly enforced or very difficult to enforce.

The Second Amendment strikes again.

There is a reason array indices are signed integers (and on 32-bit platforms they are not limited to 65536 elements): it allows you to specify negative indices. In other words: element 0 is strictly speaking not the first element of your array, it is the middle of your array.

It is a trick systems programmers often use: get a pointer and then inspect the data right before that pointer.

By the way, having 1 as the first index into an array really makes no sense. Computers start counting at 0, not at 1.