>>18112
>>4531
I've used/use Nix and Guix in certain environments. But the "benefits" they provide aren't required for most _single user desktop_ systems. Even those being used by modern webdevs and programmers. I'll spare the reader the long explanation of why this is so and leave you with a simple: These "benefits" have been part of several other tools for _decades_.

Let's take reproducible builds as an example. Most desktop users do not care about these outside of "security" aka I can trust what the vendor shipped is what I'm installing. This "feature" is part of most binary distros now and has been for some time. Debian even has a full page dedicated to them. This isn't a hard feature to implement.

One "benefit" of Nix/Guix they tout is being able to install multiple copies of the same application. Something portage has allowed since the early 2000s. Again. A feature being provided by a tool that's been around for a long time.

Being able to backup the system config and state? Why not use the file system? Why not use a file system that does this out of the box? Why is it rolled into the package manager at all? Doesn't that violate the "UNIX way"?

GNU Guix will fail to catch on because of the same reason most other GNU projects failed to catch on (outside of compilers, coreutils, and Emacs). It will fail due to the foot cheese eating ideological political brain damage that is GNU communism. The GNU license is a virus parading itself around as "freedom". It was supposed to ensure no one could take some code, modify it and ship it without giving its "improvements" back to upstream. In reality all it did was cause large corporations like Red Hat, Google, Facebook and all of the others to subvert the FOSS community. Since they can't steal the code they buy the FOSS organizations. Then they dictate policy and censor all discussion that goes against what they're doing. They pay off whomever they need to in those positions to get their policy followed. If you don't go along and can't be bought you get murdered instead (RIP my friend Ian).

Let's take a look as some of the "progress" within the Linux FOSS community over the last 15 years. For our example we'll use X11 which is the core of the desktop/GUI on Linux distros.

In the old days X ran as root. It needed to run as root to access hardware devices and certain files within the system (in UNIX everything is a file). It had to run in userspace because Linus is a fag and didn't want to allow such things into the kernel. Hence a "standard" never developed until someone decided to create X and run it in userspace.

X ran happily as root in userspace for decades and no one cared. At the time most of the people were accessing X over a network on a LAN and sometimes a WAN. Systems rarely got exploited via X because there was always a better way to do such things. Since in *nix any fag can spawn a shell using a wide variety of exploits.

But one day people noticed that this might be a problem since X was so widespread and so much relied upon it. The solution? We no longer run it as root. We now have this thing called SetUID. It allows you to spawn an instance of X and run it was a regular user account. But it can get root privileges when it needs them because the setuid bit is set. This was an attempt to contain the problem. We see this all of the time in UNIX-land. Containers within containers within containers on a system that's one shell away from being full compromised at any given time.

People ran X with setuid bit happily for decades. You were probably running it that way if you discovered Linux sometime between the mid-90s and mid-2010s. No one ever really got exploited via X because there were better ways into a system. Most users are no longer allowing X to access the network stack anyway. So if someone had managed to get into the system remotely there were bigger problems for the sysadmin to worry about.

At some point someone noticed that X with setuid was _feasible_ to exploit. They said things like
>Oh my! Anyone with access to the X server can see me typing my passwords! They can take screenshots of the desktop! This is not secure!
Around this same time some idiot decided that init scripts weren't good enough either and a project called systemd was started. Another idiot started a project called consolekit. There were many others as well. They all mostly did the same things (excluding systemd which does many things. I guess I should have said logind instead.)

So not X with setuid is suddenly not secure enough and something must be done about it. So major distros stopped shipping with X compiled with the setuid flag. X now runs as a user with no ability to get root privileges. But this breaks 99% of software on the platform because shit like a file manager needs to access disks and games need to access the GPU and you get the idea. Solution? CONTAIN IT!

Along comes (e)logind and consolekit2 to save the day. Now we run a massive application with 100,000+ lines of code as root. It starts as soon as you log-in to the system. This process starts X. Whenever X needs to do something as root it talks to this daemon and the daemon decides if it's allowed to do whatever it wants to do as root. When it's done the daemon revokes root access and returns it to running as user.

So now instead of one large application that is hard to understand and harder to audit running as root we have 2 large applications that are hard to understand and hard to audit with one running as root and the other running as user unless it needs to do something as root in which case shitty application 1 lets it become root temporary. I'm trying to explain this to a non-technical person here so this isn't technically correct. But it gets the point across. Yes it's really as stupid as it sounds.

In time consolekit2 is deprecated for being hard to understand/maintain. So everyone switches to (e)logind for this task because it's under "active development". Never mind the fact that there are tons of bug reports and known exploits and it's running as root. Some fag logs in and pushes an update to the docs or some new crappy extension for it from time to time. It's deemed good enough.

But these same fags point as X11 and they say
>look! It's old! We can't understand how it works! It's not secure by default! We need to replace this!
so along comes a new project. It's called Wayland. After 15 years of active development it still can't do half of the useful shit X has done since the 80s. It can't work with old applications and legacy applications. It can't even work with a lot of new applications. It expects all other applications to implement 75% of the shit X used to do for them. It can't do basic shit like taking a screenshot of your own desktop. Why? SECURITY! If application A could see the window of Application B you might get your password snooped. Never mind the fact that if someone was already in the system they could just install a keylogger or something. These people have brain damage. Why solve real bugs when we can be lazy faggots and call our own bugs features in the name of security?

So now we have (e)logind + Wayland running. But as a said before Wayland can't run games, legacy applications and a lot of non-legacy applications because wayland is shit. Solution? LET'S RUN X UNDER WAYLAND.

Enter Xwayland. An X server for your Wayland. Where we run the entire X server for so-called "legacy" applications and games. Now instead of one display server we get to configure two of them. Which do not play nice together. Even copy/paste doesn't work. They're always fighting over access to your hardware as well. But at least no one can take screenshots of your desktop after they've already obtained remote access to your workstation!

This is UNIX brain damage combined with good old laziness. This is the modern FOSS community. Where we keep shoving applications into containers inside of VMs inside of other containers in the name of "security". When the base system is insecure by default. Because it was never designed to be secure in the first place! It was designed so hackers could play around on old PDP-x microcomputers in the by-gone days of the late 1960s and early 1970s. Back in the good old days when the hackers were taking LSD, listening to the Grateful Dead and working in a lab next door to the CIA's brainwashing therapy sessions (Hi Uncle Ted!).

Hacks upon hacks upon hacks. That's what UNIX is. An OS where bugs are deemed features and shit is broken on purpose. Where we claim pipes and text streams are all powerful killer features then we design applications that can barely pipe data between themselves. Where you can crash the OS with a simple random string of bullshit in the shell. Where retards that undertake self inflected torture sessions laugh at other retards that haven't had the misfortune to rm * their entire file system yet.


Pointing at some half baked project and claiming it's the solution to all of the UNIX's problems has been a regular thing since the 80s. Projects come and projects go. Usually they cause more problems than they solve. We spend 15-30 years hacking around those problems then we replace them with something worse and more complicated. When will it stop? How did it ever get this bad?

It only took me 15 minutes of using Guix to find a race condition. Which broke symbolic links in my PATH. Which resulted in the application I just installed not being accessible from the shell. It was on the system but I couldn't run it. No error message. No hint that anything was amiss. I had to consult the Guix wizard and he told me;
>ah yes this is a known problem. Re-install the application and it'll probably work. Be careful not to install two applications at the same time
and it worked. Half of the time. But who knows when it'll break again silently in some odd way. My worse fear it is nukes my PATH all together leaving my system totally unusable with no way to recover without ssh'ing in and manually fixing configs from another machine. You say it's impossible. I say every application in the world is filled with bugs and I've already broken both Guix and Nix multiple times without even trying. Perhaps that race condition is fixed by now. Who knows how many we haven't found yet.

What good is the system restore and reproducible builds when it can't even manage my $PATH correctly? Why should I go diving through a mess of symbolic links and randomly named directories when I need to find the application on the file system? I know you'll say
>just use the included tools!
people always do. As if their scripts are somehow more reliable than my own or anyone else's. What if the scripts are broken and corrupted? What then? Oh yes; re-install or reboot. The UNIX hackers creed. Why fix something when I can write a script to poll it and reboot it? Most every server on the internet operates that way why not my desktop as well?

I've been around for a long time. I remember browsing /. and the mailing lists back around the year 1998. They said Linux was take over the desktop market share any year now and GNU Hurd would finally be coming out soon. A few years later some faggot flew two planes into some buildings in NYC. I was browsing /. and taking a break from everyone freaking out about the days events on the WWW. There was an article about Linux where they said it now had 2% of the desktop market share and would become the new OS for normalfags soon. Everyone laughed. They said it would never get installed widely without support for Windows games. Someone was lamenting the fact that Apple was dying and would probably be out of the market all together soon. Someone cracked a joke about Hurd not being ready yet.

Time passed. Decade after decade people kept posting the same things. Linux can run Window's games now. But no one uses it. Because it suffers from the same problems as it did back then. Stupid defaults, smug faggots that parrot buzzwords, political ideological in-fighting, lagging behind in hardware support because vendors ship bullshit and constantly recreating the wheels because the US Army decided shit like X and init scripts weren't "secure" enough. We even re-implement shit built into the kernel in userspace now because we're retarded. But that doesn't stop people (shills) from showing up anywhere you talk about it to shill for Potteringware or to post muh actually it's GNU+Linux copypasta. We have no fewer than 9,000 different desktop environments and Window managers running on three different display servers. None of them play nice together. Five different toolkits to write GUI applications. 100s of helper applications to manage the mess of config files and make all this shit work together badly.

We even set-up thousands of symbolic links and stop our applications and libs twice in our file system. All to "reproduce" a mountain of shit. Sure we could just statically link libs to each application like Windows. But that's not SECURE. It's better if we dynamically link all our libs to every applications then store config+state information about those applications+libs twice in our file system. Just in case the system breaks for no reason. Which is will. This is more "secure". Never mind the fact that no one ever audits any of this code and we've got 100s of millions of lines of it just to boot to a basic desktop.

Perhaps we could shove it all into yet another container. Maybe we'll finally abstract it all away and fix the problem. That way we can run our video game and web browser inside of a container running an NT kernel, inside of a container running the Linux kernel, which is inside of a full fledged virtual machine running on a minimal and glow nigger approved hardened Linux kernel where we can't log-in to root and probably don't even own the hardware. Thin clients are the future after all! Who needs a workstation when you can just rent a VM for $5 a month?

The brain damage runs deep buried under lots of buzzwords and empty promises.