Hmm, sounds like it doesn’t repaint the browser contents then. Could be something to do with your graphics driver.
Could also be that a profile refresh happens to fix it: https://support.mozilla.org/en-US/kb/troubleshoot-and-diagnose-firefox-problems#w_5-refresh-firefox

Fine, sure, but to pretend that a language from half a century ago is the be-all and end-all of human wisdom, is ridiculous. The field is progressing, so on average newer languages improve compared to old ones.

What the hell? Is this the new “Microsoft ❤️ Cancer Open-Source” ?

I gave it an extended look a few years ago, and I don’t remember much of the details, but I found the workflow not terribly intuitive, it had some unusual defaults and was relatively limited in features.

If I remember correctly, it did save in the ODF formats, so for just writing out a letter, it’s definitely fine.
There’s just not really a reason to use it over LibreOffice, except for it being somewhat more lightweight.

Well, what they were trying to say, is that Firefox’s extension API is essentially a superset of the Chrome extension API. If an extension works with Chrome’s limited API, then it should be almost trivial to port it to Firefox.

But yes, this is not a guarantee that the same extensions are available.
Some extension devs might not care to support both browsers, just because it may require more work for testing and releasing.
In particular, Mozilla also does not allow extensions to make web requests, unless this is part of the core functionality, so if extensions finance themselves via ads or tracking, they likely won’t make more money from releasing to Firefox.

Well, because I’m of a very different opinion about its readability. If you know the format, then sure, you can mostly read it as expected. But our logs are often something that customers or sysadmins will want to read. If it says Retrying in PT5S... in there, they’ll think that’s a bug, rather than a duration.

And yeah, I almost figured it was for de-/serialization. I guess, that’s something where I disagree with the designers of Java.
In my opinion, you don’t ever want to rely on the implicit behavior of the language for your serialization needs, but rather want to explicitly write down how you’re serializing. You want to make a conscious decision and document that it’s the ISO 8601 format, so that if you need to hook up another language, you have a chance to use the same format. Or, if you need to change the format, so that you can change the one serialization function, rather than having to find all the places where a .toString() happens.

Admittedly, the Java devs were between a rock and a hard place, due to them having to implement .toString() and the meaning of .toString() being kind of undefined, i.e. it’s never stated whether this is a format for serialization, for debugging or for displaying to the user. And then I guess, because it didn’t explicitly say “for debugging” on there, they felt it was important to go with a standard format.

I find that question difficult.

I’d say the best modding experience is when there’s a documented API. You kind of don’t want to look at the code behind that documented API, because you don’t want to rely on behaviour that can change at any point.
So, if there is a modding API and it has all the features that you need for the mod you’re looking to create, then I’d say it doesn’t make a difference.

If there is no modding API, then as others already explained, you can fork said open-source project, i.e. you don’t even need to glue a mod at the side of it, you just change the game itself to work like you want it. In this scenario, open-source makes it significantly easier to modify a game.

It’s laggy for you? In what way?

Have you tried another instance than lemmy.world? A lot of users culminated there for no good reason, which could contribute to whatever lag you’re experiencing…

I mean, as someone who hasn’t encountered these same issues as you, I found btrfs really useful for home use. The snapshotting functionality is what gives me a safe feeling that I’ll be able to boot my system. On ext4, any OS update could break your system and you’d have to resort to backups or a reinstall to fix it.

But yeah, it’s quite possible that my hard drives were never old/bad enough that I ran into major issues…

My standard position is that GNOME is good, if you want to just use an existing workflow, whereas KDE is good, if you’re looking to create your own workflow or you’re fine with a mediocre, familiar (Windows-like) workflow.

But unfortunately, GNOME is really disappointing in some ways. Every so often, we have someone at work accidentally using it, because it’s the default, and they always run into the same nonsense, like not being able to type a file path into the file manager, or not being able to give a name to the file they’re trying to save. These are pretty bad problems that normal users are quick to encounter. It’s a mystery to me, why these can’t be fixed, but ultimately I just tell people to install KDE and they’ve all been happy about it.

I’ve certainly had the feeling that things aren’t improving as quickly anymore. I guess, it’s a matter of the IT field not being as young anymore.

We’ve hit some boundaries of diminishing returns, for example:

• A phone from 5 years ago is still easily powerful enough to run the apps of today. We have to pretend that progress is still happening, by plastering yet another camera lens on the back, and removing yet another micrometer of bezel.
• Resolutions beyond HD are not nearly as noticeable of an upgrade. It often feels like we’re just doing 2K and 4K resolutions, because bigger number = better.
• Games went from looking hyperrealistic to looking hyperrealistic with a few more shrubs in the background.

Many markets are now saturated. Most people have a phone, they don’t need a second one. Heck, the youngest generation often only has a phone, and no PC/laptop. As a result, investors are less willing to bring in money.
I feel like that’s why the IT industry is so horny for market changes, like VR, blockchain, COVID, LLMs etc… As soon as a new opportunity arises, there’s potential for an unsaturated market. What if everyone rushes to buy a new “AI PC”, whatever the fuck that even means…?

Well, and finally, because everyone and their mum now spends a large chunk of their lives online, this isn’t the World Wide West anymore. Suddenly, you’ve got to fulfill regulations, like the GDPR, and you have to be equipped against security attacks. Well, unless you find one of those new markets, of course, then you can rob everyone blind of their copyright and later claim you didn’t think regulations would apply.

It’s been a hot minute, since I’ve been to the GTK side of town, but I’m aware of Geany and GNOME Builder (I believe, the latter is focused on developing GNOME apps, but not sure to what degree).

Well, and I guess, there’s also gVim and Emacs, if you’re into very keyboard-driven editors…

Implementation of the add() function is here: https://github.com/raldone01/python_lessons_py/blob/main/lib.py

Apparently, less also has a feature built-in to filter out lines based on keywords:

https://raymii.org/s/snippets/Exclude_lines_in_less_or_journalctl.html#%3A~%3Atext=Once+your%2Cterm (skip the first paragraph, past those three links)

Well, just a monitoring stack, like for example Grafana, would probably be more suitable for this specific task (if we’re doing central hosting/collection).

Kind of my main recommendation is to use something with OpenTelemetry. It’s pretty much the standard protocol for transferring logs, traces and metrics, so if you set everything up with that, then you can swap out the visualization software with less pain.
Here’s a guide for Grafana + OpenTelemetry Collector: https://grafana.com/docs/loki/latest/send-data/otel/

You might already know about it, but PyO3 could come in very handy for creating that Python library. You can use it to generate a small Python library which calls your Rust library, so you don’t need to implement it a second time.

In Rust, as far as I understand anyway, traits define shared behavior.

They’re certainly the concept closest to e.g. C#/Java interfaces. But you can also define shared behaviour with enums, as Rust’s enums are on steroids.

Basically, let’s say you’ve got two existing types TypeA and TypeB for which you want to define shared behaviour.

Then you can define an enum like so:

enum SharedBehaviour {
    A(TypeA),
    B(TypeB),
}

And then you can define the shared behavior with an impl block on the enum:

impl SharedBehaviour {
    pub fn greet(&self) {
        match self {
            SharedBehaviour::A(type_a) => println!("Hi there, {}!", type_a.name),
            SharedBehaviour::B(type_b) => println!("Hello, {}!", type_b.metadata.forename),
        }
    }
}

On the flipside, Rust doesn’t have superclasses/inheritance for defining shared behaviour.

I feel like this has somewhat shifted in recent years. Due to type-aware IDEs/editors being pretty much universal now, having types speeds you up in that initial phase, too. And type inference eliminates much of the inertia, too.

For me, the biggest red flag is that they decided to create their own protocol when the Fediverse is well on its way with the ActivityPub protocol. They claimed, they decided against ActivityPub, because they expect to be able to come up with something technologically better.

I don’t doubt for a second that some of their techies might have wet dreams about that, but it wouldn’t get financed, if their management and investors didn’t see an angle for making money off of it.

Which is ultimately what this is. Yet another venture-capital-backed company trying to get enough users on board, to the point where network effects prevent the users from leaving, and then the investors will want their money back manifold.

If they open up the protocol too much, the network isn’t under their exclusive control anymore and they lose the ability to squeeze users for money, so I cannot see them following through with their promises of actually making it decentralized.

There’s a slider to apply a global scale multiplier in the System Settings under “Display & Monitor”. So, if you set it to 200%, everything will be twice as big.

As for making a distro gaming-ready, honestly I think that’s a bit overpronounced on the webpages of Bazzite and Garuda. It’s one of their distinguishing features, so that’s what they’ll talk about, but I’d be surprised if we’re talking 5 FPS more compared to a general purpose distro.
They generally use the same software and both of them are tuned for performance, with only a slightly different focus when they’ll perform the most optimal.

Yeah, I don’t know what concrete difference zstd makes. The Arch Wiki (great resource, generally applicable independent of distro) tells me that compression may speed up some workloads while slowing down others: https://wiki.archlinux.org/title/Btrfs#Compression
Maybe Garuda found out that it mostly helps with gaming when openSUSE decided to not make use of it, because openSUSE is more general-purpose.

But yeah, I don’t know, if you’re feeling Garuda, then go for it. At this point, you could tell me that you merely like the theme of Garuda better and I’d support that decision, because what I’ve read about it does sound reasonable, and it sounds like you’ll be fine either way.

And on linux, i should be able to edit custom shortcuts, macros and stuff, right?

Not entirely sure what you mean by macros, but: Yes.
The whole OS is built from the ground up to be scriptable and configurable. It’s very likely better than you can imagine.