All good, but I think it’s really often a misconception that a DE like KDE, which is big and brings tons of features, must be more ressource intensive than a (feature wise) smaller DE. Which, as the benchmarks show, is surprisingly not the case.

Look on phoronix for benchmarks. Plasma consumes less RAM and CPU than even XFCE.

Typewise is echt scheiße … weil ich kann jetzt nicht mehr ohne tippen ^^

(Also klare Empfehlung.)

That is - IMO - what critical thinking is meant to be … thinking about alternative explanations and evaluating their viability or probability.

Unfortunately a lot of people use the term “critical thinking” as just another way to rationalize why they are against something, without actually weighing the options.

Dark humor is like food… not everybody gets it.

Landwirtschaft und selbstständig? Sind das da nicht fast ausschließlich kleine bis große Betriebe? Von denen kenn ich’s dann wiederum, dass man sich dort die Überstunden anrechnen lässt und dann im Winter abbummelt.

Reißt die Produktionsmittel an euch, hat so ein Rauschebart mal geschrieben.

Dessen Nischl seh’ ich hin und wieder.

They should have code-named this release “Brooklyn”.

Awesome Keyboard with AI Support *

* On supported Operating Systems **

** With separate subscription.

Völlig nachvollziehbar. Die Drucker von heute halten ja auch nix mehr. So wie der Drucker der Tochter die ganze Nacht brummt, muss der auf jeden Fall repariert werden. Also alles plausibel.

There’s nothing wrong with UDP. At least not that I know of.

You should consider using distrobox and/or apx, so you can effectively run any software from any package manager from any distro.

You could have a bottled archlinux where you install and run cutting edge stuff.

ZFS cache will mark itself as such, so if the kernel needs more RAM for applications it can just dump some of the ZFS cache and use whatever it needs.

In theory. Practically unless I limit the max ARC size, processes get OOM killed quite frequently here.

For fileservers ZFS (and by extension btrfs) have a clear advantage. The main thing is, that you can relatively easily extend and section off storage pools. For ext4 you would need LVM to somewhat achieve something similar, but it’s still not as mighty as what ZFS (and btrfs) offer out of the box.

ZFS also has a lot of caching strategies specifically optimized for storage boxes. Means: it will eat your RAM, but become pretty fast. That’s not a trade-off you want on a desktop (or a multi purpose server), since you typically also need RAM for applications running. But on a NAS, that is completely fine. AFAIK TrueNAS defaults to ZFS. Synology uses btrfs by default. Proxmox runs on ZFS.

It likely has an edge. But I think on SSDs the advantage is negligible. Also games have the most performance critical stuff in-memory anyway so the only thing you could optimize is read performance when changing scenes.

Here are some comparisons: https://www.phoronix.com/news/Linux-5.14-File-Systems

But again … practically you can likely ignore the difference for desktop usage (also gaming). The workloads where it matters are typically on servers with high throughput where latencies accumulate quickly.

As with every software/product: they have different features.

ZFS is not really hip. It’s pretty old. But also pretty solid. Unfortunately it’s licensed in a way that is maybe incompatible with the GPL, so no one wants to take the risk of trying to get it into Linux. So in the Linux world it is always a third-party-addon. In the BSD or Solaris world though …

btrfs has similar goals as ZFS (more to that soon) but has been developed right inside the kernel all along, so it typically works out of the box. It has a bit of a complicated history with it’s stability/reliability from which it still suffers (the history, not the stability). Many/most people run it with zero problems, some will still cite problems they had in the past, some apparently also still have problems.

bcachefs is also looming around the corner and might tackle problems differently, bringing us all the nice features with less bugs (optimism, yay). But it’s an even younger FS than btrfs, so only time will tell.

ext4 is an iteration on ext3 on ext2. So it’s pretty fucking stable and heavily battle tested.

Now why even care? ZFS, btrfs and bcachefs are filesystems following the COW philisophy (copy on write), meaning you might lose a bit performance but win on reliability. It also allows easily enabling snapshots, which all three bring you out of the box. So you can basically say “mark the current state of the filesystem with tag/label/whatever ‘x’” and every subsequent changes (since they are copies) will not touch the old snapshots, allowing you to easily roll back a whole partition. (Of course that takes up space, but only incrementally.)

They also bring native support for different RAID levels making additional layers like mdadm unnecessary. In case of ZFS and bcachefs, you also have native encryption, making LUKS obsolete.

For typical desktop use: ext4 is totally fine. Snapshots are extremely convenient if something breaks and you can basically revert the changes back in a single command. They don’t replace a backup strategy, so in the end you should have some data security measures in place anyway.

*Edit: forgot a word.

So if I put a movement sensor that triggers a light in front of a jewish household, they couldn’t leave on sabbath because their movement would trigger a fire?

To execute more than one process, you need to explicitly bring along some supervisor or use a more compicated entrypoint script that orchestrates this. But most container images have a simple entrypoint pointing to a single binary (or at most running a script to do some filesystem/permission setup and then run a single process).

Containers running multiple processes are possible, but hard to pull off and therefore rarely used.

What you likely think of are the files included in the images. Sure, some images bring more libs and executables along. But they are not started and/or running in the background (unless you explicitly start them as the entrypoint or using for example docker exec).

The point with an external drive is fine (I did that on my RPi as well), but the point with performance overhead due to containers is incorrect. The processes in the container run directly on the host. You even see the processes in ps. They are simply confined using cgroups to be isolated to different degrees.

If the application in question doesn’t need to write anything, it also doesn’t write outside of docker, so it also won’t wear down the SD card.

If the app has to write something, a fully read-only container will simply not work (the app will crash or fail otherwise).