All you had to do was google “thinkpad” and pick out a stock photo.

I think I see where your confusion comes from. Either that or you are writing programs with willful and reckless disregard to the importance of standards.

A process (or program) has multiple outputs. The return code is a one byte value that is set by the process when it ends, and often checked by the parent process (interactive shell, script, program) to make decisions regarding the flow of control. This value is severely restricted in its usefulness, to “provide data”. The type (unsigned byte) limits the range and precision, and you can’t write to it asynchronously or before you’re ready to gracefully end the process. The name is deceptive: this is not the same kind of “return” as the return instruction in programming languages. It simply describes the way a process ended, nothing more. It should never contain meaningful data, and always adhere to the POSIX conventions.

Why? Because everybody does. More than that, everybody writes programs that expect a return code of zero to mean success, and a return code other than zero to mean failure. It was decided before I was even born. It’s an implicit agreement that we adhere to (except Powershell because they’re special). Deviation from this will only lead to compatibility issues and confusion.

If you want to convey meaningful data, you should use an output stream. The POSIX standard states that programs should communicate using strings, and that the standard input and output streams should be used for this unless other methods are needed. If your program produces meaningful data and you want to convey it to the parent process or another program, you have to write it to stdout, and the other program has to accept it via stdin. This exchange is facilitated by the shell through the pipe and redirection operators. It frees up the return code to meaningfully indicate the exit state of the program without mixing it up with the data produced by it, and once again, it’s what everybody does, and what everybody expects.

To be pedantic: there is no such thing as a boolean value. It’s all just bytes and larger numbers behind an abstraction that allows a higher-level programming language to implement Boolean algebra by interpreting numbers a certain way. One such abstraction is the POSIX convention of treating a return code of zero as success and everything else as a failure. This consequently defines how Boolean algebra is implemented in POSIX-compliant shells:

• The if statement tests the return code of the command specified in the header, then executes the then branch if the return code is zero, the else branch otherwise.
• The while loop similarly tests the command in the head and executes the body if its return code is zero.
• The boolean && and || operators treat zero return values as true and nonzero return values as false. Go try it out.
• Even the true and false commands are just programs that immediately return 0 and 1 respectively.

If you start treating nonzero return codes like a success value with meaning, the only thing you’ll achieve is that your scripts won’t be compatible with the shell. stdout exists. Use it.

Local Unbound with Tailscale’s split DNS has been solid for me. I use it as an OPNsense service with the web GUI, but the standalone YAML config looks simple enough.

I’ve never used Linkwarden, but the /data folder is often used by Docker containers to store the application’s data, so it’s likely an internal path. You’ll have to create a volume that exposes the internal /data path to the host filesystem, then whatever is written into that directory will be made available to both the container and the host system. Any file or directory in the container can be exposed this way.

I usually put my data volumes in /srv (where my large RAID array is mounted) and config volumes in /config, into a subdirectory named after the service, and with the minimal necessary privileges to run the container and the service. You could, for example, create volumes like this:

/srv/linkwarden/postgres_data:/var/lib/postgresql/data
/srv/linkwarden/linkwarden_data:/data/data
/srv/linkwarden/meili_data:/meili_data

The volume path (left side of the colon) can be anything. The right side is where the services expect their files to appear inside the container.

That’s… that’s what a distribution is. A base OS with bundled, preconfigured user applications.

Take a gander at the git repo: https://github.com/basecamp/omarchy

It does as much as most desktop distributions. More in some areas. It has merits regardless of your politics. I know I’ll be borrowing some of the scripts.

Because it’s a competently-made, new distribution with interesting features. Not everything you don’t understand is a fucking conspiracy.

The Lemmy backend, the default web frontend, the Jerboa app, and the lemmy.ml instance are all owned by the same person.

I don’t know which label is the most accurate, but he supports Putin’s war, which lands him in the “shitbag” category. Being technically not fascist does not negate supporting the military invasion of a sovereign country, the ethnic cleansing of its people, and the rape, murder, and torture committed by the invaders.

We’re all shipping the penguin and the wildebeest.

You are literally on Lemmy. The project owner’s views are well-known.

I’ll just link my comment from the other day: https://lemmy.world/comment/19749012 (also read Morphit’s reply, it gets worse)

Yes, and that is one of the tools that would be evaluated. My immediate problem is that it requires a working OS to rollback to the last filesystem snapshot if the configuration change (which is still not atomic) is interrupted.

The area where filesystem-level snapshots would be amazing is the /home partition, whenever a teacher asks the computer to be cleaned before an exam.

on limewire

Not only has this made me realize how fucking old I am, but I also got curious about how Limewire is doing, and…

In September 2025, LimeWire acquired the Fyre Festival brand, including its intellectual property, trademarks, online domains, and social media assets, from Billy McFarland via an auction held on eBay.

…according to Wikipedia. At this point, my 2025 bingo card would serve better as kindling.

Thanks, that’s even more fucked up.

What’s even even more fucked up is that the package still installs an executable to /usr/bin/firefox, but it’s just a wrapper script that launches the Snap application… and also replaces your desktop shortcuts, application launcher shortcuts, and favourites with its own Reforged Edition file if you’re running GNOME, Unity, MATE, or KDE Plasma.

# [...]

# GNOME Shell
OLD="firefox.desktop"
NEW="firefox_firefox.desktop"
FAVS=$(gsettings get org.gnome.shell favorite-apps 2> /dev/null)
if echo "$FAVS" | grep -q "'$OLD'"; then
  NEWFAVS=$(echo $FAVS | sed -e "s#'$OLD'#'$NEW'#")
  gsettings set org.gnome.shell favorite-apps "$NEWFAVS"
fi

# MATE
OLD="/usr/share/applications/firefox.desktop"
NEW="/var/lib/snapd/desktop/applications/firefox_firefox.desktop"
OBJECTS=$(gsettings get org.mate.panel object-id-list 2> /dev/null)
for object in $OBJECTS; do
  object=$(echo $object | cut -d\' -f2)
  launcher=$(gsettings get org.mate.panel.object:/org/mate/panel/objects/$object/ launcher-location)
  if [ "$launcher" = "'$OLD'" ]; then
    gsettings set org.mate.panel.object:/org/mate/panel/objects/$object/ launcher-location "'$NEW'"
  fi
done

# [...]

# TODO: handle other desktop environments

exec /snap/bin/firefox "$@"

I’d classify that as malware.

Install the OS, clone the config, rebuild, walk away and go to the next computer.

Honestly, I’d automate it to be even fewer operations. The Windows process is already down to only four keystrokes, and three of them are just to boot into PXE. The fourth is just a pause to make sure every computer has booted into Clonezilla (Debian preloaded with the cloning software and my own scripts, pulled from a TFTP server) before they start pulling the Windows image and the network becomes saturated.

If it ever comes to pass, there will be an extensive evaluation to determine which tool is best suited for the job and the environment. The Prime Directive applies: we must not disrupt classes that are in progress or about to start unless they specifically ask for something.

Support for atomic updates is one feature that I won’t compromise on, and while Ansible will definitely be part of the toolkit (on that note: fuck WinRM, all my homies hate WinRM), its idempotent model on its own is not enough to guarantee disruption-free deployments. If the process fails for any reason, the system must roll back to its last functional state. I don’t know if Nix can do that, but when it becomes relevant (so probably never in my professional capacity), I will find the right tool.

(for the record, that is not my downvote)

I’ve tried, at least in theory, to migrate an entire university’s classroom computers to Linux. Even in the absence of technical limitations, the one obstacle I can’t overcome is entirely human. The living fossils Our esteemed tenured professors refuse to change their habits because they need their Netbeans, they need their Eclipses, they need their Visual Studios. In a lot of ways, it feels like wayland-protocols’ governance. A single NACK from a stubborn fool kneecaps the entire project, and now the university gets to spend hundreds of thousands of euros upgrading the computer labs because the perfectly usable computers are juuuust barely outside Win11’s requirements.

Sidebar: Back when I was a student at that same university, when Windows was small enough to allow dual-booting with Ubuntu from the same SSD, my Prog-1 teacher insisted on using Joe. He hated Vim, Emacs, and Nano with an equal passion.

Edit: Just to give some validation to the people who need it, I should point out that Nix would be the ideal OS. We use Clonezilla to deploy a painstakingly prepared golden image of Windows with all applications and configuration changes before every semester. If a teacher forgets to request a software (despite the five separate e-mails and posters around the university), we have to pray that it’s available either as an MSI or through winget, otherwise we have to manually remote into each affected computer (up to several hundred) and install it one by one.

I would give my left testicle and half my liver for the ability to have a centrally hosted Nix config file that can be edited whenever and then deployed as the computers come online.

That’s not the full picture.

The proprietary store backend really isn’t consequential. Most websites are, and if you have a modern computer, you’ve got proprietary firmware running at ring -3. At best, it’s a distraction from Snap’s real issues.

Snap packages are compressed filesystems, similar to squashfs. When an application is started for the first time, the filesystem has to be decompressed and mounted to the root filesystem, which (depending on the computer) can take a long time. It also litters your mount points with loopback devices.

Snap’s sandboxing only works on systems running Systemd. No Devuan, no Artix, no Alpine; the packages will work, but without sandboxing.

The worst part is Canonical’s desperate attempts to make snaps happen.

• Ubuntu ships with a modified apt that first checks if the desired package is available as a snap, and if so, installs snapd and the snap package without asking or even notifying the user. Strike that, it’s even worse. https://feddit.uk/comment/20490326
• Canonical repackages third-party software as snaps, which has caused issues for the developers who aren’t involved in the repackage: https://mastodon.social/@TTimo/111772575146054328
• In fact, they have published malware on the snap store because review practices are shit: https://forum.snapcraft.io/t/exodus-movement-exod/38904
• Canonical has forced other official flavors (Xubuntu, Kubuntu, etc; to note: they’re not maintained by Canonical) to ship their systems without Snap’s direct competitor Flatpak out of the box. https://www.omgubuntu.co.uk/2023/02/ubuntu-flavors-no-flatpak

…and I’m sure there’s more that I’m forgetting about.