KDE Discover and GNOME Software can install from FlatHub (or other Flatpak repos, if you add those).

Yeah, so much of it is a mediocre/old joke overlayed on a generated image.

I’m guessing, there’s people out there, who genuinely just flood social media with these mediocre posts to try to grow accounts or similar…

Hmm, not sure, if I’ve heard of it. I’m guessing, we’re not talking about simply drawing a UML class diagram…? Is it for figuring out which object will have to clean up which other objects, in non-GCed languages?

The last one seems to be mostly like Brainfuck, just with different capitalizations of “moo”: https://esolangs.org/wiki/COW

Yeah, these become a lot less relevant with routine.

• Avoiding the main-thread panicking is mostly just a matter of not using .unwrap() and .expect().

• String vs. &str can mostly be solved by generally using owned datatypes (String) for storing in structs and using references (&str) for passing into function parameters. It does still happen that you forget the & at times, but that’s then trivial to solve (by just adding the &).

• “temporary value dropped while borrowed” can generally be avoided by not passing references outside of your scope/function. You want to pass the owned value outside. Clone, if you have to.

• “missing lifetime specifier” is also largely solved by not storing references in structs.

The thing with OOP, particularly how it’s used in GCed languages, is that it’s all about handing references out to wherever and then dealing with the complexity of not knowing who has access to your fields via getters & setters, or by cloning memory whenever it’s modified in asynchronous code.

Rust has quite the opposite mindset. It’s all about tracking where references go. It pushes your code to be very tree-shaped, i.e. references typically¹ only exist between a function and the functions it calls underneath. This is what allows asynchronous code to be safe in Rust, and I would also argue that the tree shape makes code easier to understand, too.

But yeah, some of the patterns you might know from OOP will not work in Rust for that reason. You will likely need to get into a different mindset over time.

Also just in case: We are talking OOP in the sense of the paradigm, i.e. object-oriented.
Just using objects, i.e. data with associated functions/methods, that works completely normal in Rust.

¹) If you genuinely need references that reach outside the tree shape, which is mostly going to be the case, if you work with multiple threads, then you can do so by wrapping your data structures in Arc<Mutex<_>> or similar. But yeah, when learning, you should try to solve your problems without these. Most programs don’t need them.

Yeah, we onboarded some folks into a Rust project last year and a few months in, they were genuinely surprised when I told them that unwrapping is pretty bad. Granted, they probably did read about it at some point and just forgot, but that isn’t helped by lots of code using .unwrap() either.

Can still use .is_positive(), though…

I was also surprised how well it works, but you genuinely just sploosh water with a mild bit of pressure at it and it comes off.

I’ve been using a hand-operated travel bidet, which is basically just a squeeze bottle with a nozzle, and that still gets me perfectly clean. Definitely much cleaner than with toilet paper.

Does cow milk bubble in some special way? Like, you can make bubbles rise even in water, but I’m guessing, that’s not what we’re talking about…

The thing is that many people who “like milk” don’t think of the taste of freshly milked dairy milk. I grew up with skimmed milk that got treated with ultra-high-temperature processing. The cow taste was hardly there and it wasn’t why I liked milk.

I liked milk, because it made cereal edible and because I could put chocolate powder into it. The cow taste rather even felt out of place.

By some definition of “further”, sure. Mainly the definition someone with no remorse would have.

Yeah, you understood my comment entirely the wrong way around. When I say “dotfiles”, I mean the non-Nix way of managing application configurations. Nix Home-Manager happens to write to these dotfiles, but that means I don’t have to deal with the dotfiles myself.

I feel like setting up a new machine is just the easiest to explain.

Personally, I find dotfiles messy, as you often just want to change one or two settings, but you always carry along the whole file with all kinds of irrelevant other settings. This also makes it impractical to diff two versions of those dotfiles, especially when programs write semi-permanent settings into there.

I guess, your mileage will vary depending on what programs or desktop environment you use.
For example, I love KDE, but they really don’t do a good job keeping the config files clean. Nix Plasma-Manager generally fixes that, and for example allows defining the contents of the panel in a readable form.

Personally, the stepping stone I needed to know about is Nix Home-Manager, which basically allows you to manage your dotfiles independent of the distro. From what I understand, if I do switch to NixOS, I’ll continue using this code with just some minor tweaks.

But yeah, I agree with the verdict in the post. I like it a lot, but I would not have made it past the initial learning curve, if I didn’t happen to be a software engineer. Sysadmins will probably be able to figure out how to put it to use, too. But it’s just not for non-technical Linux users.

After seeing how excited some folks got during COVID, that’s genuinely somewhat of a worry for me. Kind of like how lonely, young men can be sold on the idea of war, because they think they’ll finally be adored as a hero, you can just as well find preppers who think they’ll finally be adored, because they bought toilet paper before everyone else could.

In the case of COVID, it was thankfully a disappointment for the preppers, in that the best survival strategy was staying in your cushty home. That will be the case for the vast majority of infectious diseases. But I still bet someone out there had the intrusive thought that maybe they shouldn’t help reduce the spread of COVID, because you won’t be deemed a hero without a real crisis…

It looks like a guitar pick to me. 🙃

On KDE, I’d recommend getting a KWin Script for tiling. Krohnkite is what people use currently.

It’s not as buttery smooth as dedicated tiling window managers and it can be a bit glitchy at times, but it is better than one might expect and significantly easier (and likely less glitchy) than trying to get bspwm to work in Plasma.

It is similar to Bluesky, yes. They both got a lot of inspiration from Twitter (before Musk turned it to shit/X).

And I would say that the discussions are more shallow than on Lemmy. Even though Mastodon has a higher character limit than Twitter and many Mastodon instances effectively remove the character limit, it’s still fundamentally a platform for shortform interactions. Infodumping is rarely seen, because you need to create a silly number of chained messages.

On the flipside, though, you get to know people. I do appreciate the time I spent on Mastodon, because of that. It’s a very different perspective as not everything is about discussing cold hard facts, but rather also people’s hobbies and struggles and whatnot.

Ah, neat. My phone speakers are far too silent, so I’ll have to fiddle with this in the other direction.