Needlessly absolute take. Yes, there’s going to be parents, who’d rather pay extra than look into what other games they could give their kid, as well as loyal Mario fans, who will pay pretty much any price. But there’s obviously also players who do weigh up their options based on price, and who will make different decisions when they have to decide between two titles, when one of them is cheaper. Especially with the additional invest for a new console and the more dire economic situation, I could see many players not buying into the Switch 2 at all.

I mean, if it’s still shit and it’s getting even worse, I don’t know why we wouldn’t continue to mourn that, or at least call it out.

Well, traditionally, console prices were subsidized by the more expensive game prices. They’d sell the console at a loss to then make that back per game. Them raising both the console price as well as game prices is what makes it awful.

Yeah, I don’t have first-hand experience with Arch for that reason either. Well, and also because I do want a distro to set things up for me. You could set up the snapshotting (with BTRFS and Snapper) on theoretically any distro, but not having to figure out how and what settings are good, that’s why I go with openSUSE.
I might look into NixOS at some point. It obsoletes the need for OS snapshots, because the entire OS configuration is made in configuration files. But from what I hear, it helps to be a programmer (which I am) to really appreciate NixOS.

And yeah, don’t know much about Bazzite either, but from what I’ve heard, it really has some design decisions that make it feel more like a games console. The atomic/transactional updates, for example. As I understand, updates and such are applied to a copy of your OS, which gets swapped in when you do the next reboot. This helps keep the system stable after applying updates, but implies that you can’t really just poke around manually in your root partition.
It can be helpful for users not looking to experiment, but yeah, can be a pain, if you do want to.

As for a real-time kernel, the JACK FAQ says you don’t need it, but the distro might limit real-time scheduling anyways: https://jackaudio.org/faq/linux_rt_config.html
I’ve had JACK running on my system about a year ago, although I didn’t really have a need for low latency, so I can’t say, if it actually worked correctly.
Perhaps also worth pointing out that “Pipewire” is becoming a thing, which tries to make interfacing with JACK and PulseAudio much easier. I believe, I also used Pipewire back then. But yeah, folks who’ve dealt with JACK a lot more than I have, seem to be really excited about it, so it’s presumably doing a great job.

Yeah, I always hesitate to recommend distros. 😅
There’s tons out there and they all exist, because some smart person decided to put in lots of work, as the existing ones didn’t match what they wanted.

If we exclude Ubuntu/Debian-based, that narrows it down somewhat. The other major distros are:

• Fedora: Rather much tied to the corporate side (Red Hat / IBM), tends to be rather up-to-date. Kind of has a focus on GNOME, but other “Spins” are available.
• Arch: Community-driven, pretty much a DIY distro, so the initial setup is somewhat challenging. It’s really up-to-date, so much that it’s referred to as “bleeding edge” (rather than cutting edge), meaning you might get faulty updates from time to time. It’s also often loved by minimalists, because they can decide for each component, if they want to install it.
• Well, and perhaps the most niche of these – which is what I’m on – openSUSE: Has the best integration of KDE (not by a huge margin, but still). I like it in particular, because of its snapshotting system. It automatically starts snapshotting your OS (not the user files) once per hour or whenever you make changes to the installed packages. If something breaks, you can boot into a previous snapshot from the bootloader and roll things back.
  It’s the most “maximalist” mainstream distro, in that it preinstalls relatively much software. Personally, I think the other distros are a bit silly with their minimalist tendencies, but yeah, I’m biased. And well, downsides of openSUSE are that it is somewhat niche. You’ll find a helpful, tight-knit community, but it’s less likely that guides mention how to do things on openSUSE. Similarly, you’re less likely to find pre-packaged software for openSUSE. May have to compile from source more often, although SoS has a good amount of software, too.

As for whether a different distro is too much experimenting, if you do jump into it, you’ll understand why I talked about the desktop environment instead. 🙃
The DE makes a much bigger difference. Some people conflate distro and DE, because certain distros will have certain default DEs.
But if you used the same DE on two distros, honestly the main difference you’d notice is a different package manager. Where Ubuntu Studio and Mint use apt, openSUSE uses zypper, Fedora uses dnf and Arch uses pacman. They handle somewhat differently, but largely do the same things (i.e. install/update/remove packages).
Obviously, there are more differences to the distros, like how quickly they update and some of the default configuration, like the snapshotting I raved about, but ultimately it’s still a Linux system with much of the same software running on both…

Well, that was kind of a general statement. Mint is boring. That’s what it’s good at. That’s why it’s loved and why it’s recommended for new users. Specifically, it’s similar to Windows in many ways. It’s somewhat more customizable, but that’s about it.

With you having used Linux twice before, you could consider something less Windows-like, less boring. I’ll be talking about the desktop environment (DE) rather than distro, because it has much more influence on this. You can use these DEs on various distros.

• My personal favorite DE is KDE Plasma. The default-layout is also Windows-like, but it’s got all of the bells and whistles and options you could imagine. It’s kind of power-user heaven and almost like a toolbox to build whatever workflow you want.
• The other big, popular DE is GNOME. It’s more macOS- and Android-like and focuses on a specific workflow. People who can get used to that workflow, then often really like it. The workflow itself is sometimes frustratingly uncustomizable, but it’s also fairly customizable when it comes to the details, typically by virtue of also having lots of features, which can then be customized.
• Well, and I guess, I’ll throw in Xfce, too, since that’s likely what you used, back when you used Ubuntu Studio. (Ubuntu Studio uses KDE since the October 2020 release, but used Xfce before then.)
  Xfce isn’t necessarily what modern beauty standards would get flustered by, but many folks like it for its simplicity and because it is perhaps even more boring than Mint (without being Windows-like). There’s a good chance that it still works a lot like back when you used it.

Perhaps also worth mentioning that Mint’s DE is called “Cinnamon”, although it’s developed by the Mint devs, so if you like that a lot, it’s typically worth sticking to Mint.

I mean, yes, but I was rather wondering, if that extra space was maybe why it couldn’t find it. Maybe you had to manually enter the SSID and accidentally put in that extra space? Then again, I don’t even know, if you took that photo…

'fucking shit router ’

🤔

Well, Mint is still one of the top recommendations for new users. It gets support for the newest hardware at a bit of a delay, so if you wanted to follow suit with your new gaming PC, it might not be as great of a choice for that for now, but for your laptop, that’s what I’d recommend, if you’re not looking to experiment.

What distro did you use before?

This is a very mild violation, but I like to play these puzzles: https://www.chiark.greenend.org.uk/~sgtatham/puzzles/
…except that I create a custom difficulty level which is quite a step below the easiest difficulty and then I almost rather speedrun the puzzles.

The Rectangles puzzle at 5x5 size has been my crack for the past months and I’m at about 13 seconds now (using my phone as input).

I mean, it’s very casual speedrunning. No one cares about my time, so I actually never timed myself before just now. But yeah, I just like the different challenge of thinking fast rather than complex.

Personal pet theory that may also play into it: Trans people are also often in information security roles. Potentially, because when you have to hide your real identity, you start to get good at it.
And Rust also has various security benefits, especially when compared to C, but also when compared to garbage-collected languages (race conditions are largely prevented).

No…

Yeah, I doubt WebAssembly when executed in a browser will become multi-threaded anytime soon, since JavaScript is single-threaded just as well. If you need multiple threads, you need to use web workers. Haven’t done anything with those yet, but I’d assume them to be usable from WebAssembly as well, since the whole JavaScript API seems to be accessible.

Well, and in Rust, I’m pretty sure the runtime that’s typically used for async stuff (tokio) will produce a compile error, if you try to enable the “multi-thread” feature flag on the WebAssembly target.
But yeah, might be more of a problem with other languages.

LibreOffice has a way to switch to a sidebar UI. I always preferred that, because of what you describe…

Well, part of the problem is that web apps themselves are kind of alien on the web. The web is generally document-based. Web apps take the document format and try to turn it into something it’s not.
There’s a way to not do the JavaScript, but it doesn’t fix things being document-based and it can be argued that it makes other things worse in some respects.

I’m talking about WebAssembly. Basically, you can write your web app in HTML+CSS+Rust and then the Rust part is compiled to WebAssembly, which then takes the role that JavaScript would normally take. It does not have to be Rust, lots of languages can be compiled to WebAssembly, but Rust has the most mature ecosystem for that, as far as I’m aware.

In principle, it is also possible to use WebAssembly to render directly to a pixel buffer, but that’s really rather heavyweight and not terribly responsive, so not generally done, unless you implement a game¹ or similar.
Alright, so back to the document mangling approach. There’s various frameworks available for Rust. I’ve used Leptos so far. There’s also Dioxus and Yew and probably others.

Advantages:

• Don’t have to write JS.
• Can write Rust. Rust has some concepts that mesh really well with frontend dev, like the Result and Option types for error handling, which you can pass directly to your rendering stack and it can show either the data or the error (or nothing).
• Can use the same language in backend and frontend and therefore also get compile-time checks that the two work together.

Disadvantages:

• The ecosystem is young. You will find barely a fraction of the component libraries as you can find for JS.
• Rust also has concepts which don’t mesh well with frontend dev, like the whole memory management concept. Those frameworks bypass that or make use of it in clever ways, but things can be a bit peculiar or overly complex at times.
• WebAssembly is sent to the browser in one big blob, because it’s a compiled program. This means you get somewhat of a loading time when first loading the web app. There’s ways to mitigate that with “hydration” strategies, but yeah, still a thing.
• While JS is often minimized/uglified and therefore not readable anyways, WebAssembly makes that even more of a reality, because it is essentially assembly code that’s sent to the browser. It does still call the same APIs under the hood as JS does, so content blocking shouldn’t be affected, but yeah, can’t try to understand the code itself. This can also make debugging during development somewhat more painful.
• Well, and it’s also yet another web standard that browsers have to support. It doesn’t make browsers simpler in the sense that suckless would like.

I’ve listed a lot of disadvantages, so just to point out that, yes, to me, the advantages are absolutely worth it. But I can totally understand, if others see that differently.

¹) See, for example, Bevy and this UI example in particular.

Ah yes, intentionally misunderstanding someone’s comment. We’ve all seen them.

I mean, what the heck is this passive-aggressive comment? If you disagree with me, then come at me.

It’s a programming language, which is particularly relevant for Linux, because it doesn’t require a runtime (separate program that runs the code). This allows it to be used in the kernel.

But it also means that it’s very good for building libraries. With a small bit of extra work, virtually any other programming language can call libraries implemented in Rust (like you can with libraries implemented in C).
Add to that, that Rust allows for performance similar to C and makes lots of typical C bugs impossible, and suddenly you’ve got folks rewriting all kinds of C libraries and applications in Rust, which is something you might have also heard about.

Yeah, as I understand, in the terms of language design theory, it is technically still “manual memory management”. But since you don’t end up writing malloc() and free(), many refer to it as “semi-automatic” instead, which certainly feels more accurate.

Damn, seems you’re right. For folks reading along: That’s not how that word usually works in German, but I guess, it is how it works in German legalese…