I hate how Desktop UI in general has been moving towards Mobile design for the last decade.
Everything has to always look like the latest shit from silicon valley, I despise it.

Imo all the work that was put into UI design for the last 20 years has been wasted effort.
I still use GNUStep and OpenMotif based Desktops because I genuinely think that those are better designed, and they haven’t been touched in forever.

Even if you happen to use older NVidia cards from before they started doing signed firmware blobs the experience is miserable.
Nouveau has 0 dynamic power management, so the only way to change clocks speeds is via a debug interface in /sys/.
Everytime you change clock speeds the driver can crash. And while some software does become usable it tends to be very unstable because some features are just not implemented or only half-implemented, leading to graphical glitches and unpredictable behaviour.

It’s a shame because I really feel like nouveau could be a great piece of software, but unfortunately nobody is working on it anymore.

I do this for a server in my LAN. I use DHCP+TFTP to boot grub over the network via PXE, and then grub boots the Kernel with the root pointing to a NFS share:

menuentry 'GNU/Linux NFS' --class gnu-linux --class gnu --class os {
        load_video
        set gfxpayload=keep
        insmod gzio
        insmod part_msdos
        insmod part_gpt
        insmod fat
        echo    'Loading kernel ...'
        linux   <TFTP Root>/vmlinuz root=/dev/nfs ip=dhcp nfsroot=<NFS Server IP>:/export/rootfs/<Root Dir> rw loglevel=6 threadirqs
}

Doing this makes managing that installation much easier. It’s just a directory that lives on the Main Server.
I don’t even need to boot the other Server to update the software in it, chroot is enough. And I don’t even have to worry about doing separate backups, because I already back up the Main Server’s Storage regularly.

This whole thing feels like a celebrity ad.

Maybe they left it running for a while. The current Steam Client is basically an Electron App.
I miss the old Steam Client that was made entirely in Valve’s own GUI Framework which was written in C++.

Hey, I’m posting this via lem.el! I’ve been using it for a few months now.
Could still use some work, but far better than using a Web Browser.

You can use the lsof utility though to list all currently open file handles.

I befriended this guy in an online game. Eventually we became friends on Steam and it turned out we both had a lot in common and we started playing a few other games together as well.
One day he told me that he got a girlfriend, who he later then married. After some time they got divorced and he hasn’t messaged me since.
I really miss staying up until 6 in the morning, playing long AoE2 and Stronghold Crusader matches with him.

I rather deal with that than any Micro$oft® Garbage®.

Eclipse 15 years ago was OK. Decent Debugger, useful Plugins (like WindowBuilder). It had issues, but instead of focusing on those they over time just kept piling crap on top of it.

Hmm Good argument, but does Vim also have the ability to support a lemmy client?!?

https://codeberg.org/martianh/lem.el

Honestly a major reason I like emacs better is because most features/programs in it are written in lisp, and I rather write lisp than lua.

s/VIM/EMACS/

I pretty much share the same experience. I avoid using docker or any other containerizing thing due to the amount of bloat and complexity that this shit brings. I always get out of my way to get Software running w/o docker, even if there is no documented way. If that fails then the Software just sucks.

Coding directly in assembly is rare.

I used to think that, but when you’re dealing with a lot of low-level stuff you’ll eventually realize that Compilers are pretty bad at generating fast and reliable Assembly where it’s needed. Also, some Architectures have specific machine instructions that Compilers just don’t take advantage of, no matter what flags you enable.

Exactly. All modern CPUs are so standardized that there is little reason to store all the data in ASCII text. It’s so much faster and less complicated to just keep the raw binary on disk.

Some old software does use 8-Bit ASCII for special/locale specific characters. Also there is this Unicode hack where the last bit is used to determine if the byte is part of a multi-byte sequence.

Unless your machine has error correcting memory. Then it will take literally forever.

Your CPU has big registers, so why not use them!

#include <x86intrin.h>
#include <stdio.h>

static int increment_one(int input)
{
    int __attribute__((aligned(32))) result[8]; 
    __m256i v = _mm256_set_epi32(0, 0, 0, 0, 0, 0, 1, input);
    v = (__m256i)_mm256_hadd_ps((__m256)v, (__m256)v);
    _mm256_store_si256((__m256i *)result, v);
    return *result;
}

int main(void)
{
    int input = 19;
    printf("Input: %d, Incremented output: %d\n", input, increment_one(input));
    return 0;
}

It doesn’t help that they keep deprecating and changing standard stuff every other version. It’s like they can’t make up their mind and everything may be subject to change. Updating to the most recent release can suddenly cause 10s or 100s of compiler warnings/errors and things may no longer behave the same. Then you look up the new documentation and realize that you have to refactor a large part of the codebase because the “new way” is for whatever reason vastly different.