When I made my Lemmy account (the day reddit put a paywall on the API) most posts didn’t even have comments (sorting by hot/popular). And it would be common to run out of new posts after a bit of scrolling. Now it looks about the same level of activity as reddit 10-something years ago.

As a Spaniard, France has witched it’s place with America in my head.

You know america fucked up when it can overcome the implicit hatred towards your neighbor.

Vs codium is a FOSS vs-code

This point is always stated about XML as if it were the most important part of choosing XML.

But jsonschema exists. It has the same capability.

I didn’t say that it’s not used. I say that you shouldn’t if you have the option.

If the entire X world uses Y technology. You have no choice other than using Y technology.

I don’t think anyone actually chooses XML. There’s no reason to use it over JSON unless you need to.

Considering that using a keyword to name anything results in compiler (or worse! Interpreter) errors, and that libraries are a thing. And also that copy-pasting code from the internet is a thing. I don’t think it would be a good idea to localize programming languages.

Until I read this comment I was 100% certain the post was about short Germans somehow preferring having their balconies occluded by taller-than-them solar panels.

Just ask your ISP for more upload speed (and pay for it). It’s a thing you can do.

Also, most importantly. Assembly.

JavaScript

Cat girls are not furries. And I’m willing to die on this hill.

Why would they ever force this?

The purpose of MFA is to:

Mitigate using the same password on multiple sites and one of them has a data breach.

Mitigate the impact of keyloggers/other kinds of malware.

Mitigate the bad security of bad passwords.

Mitigate the password manager’s own data breach.

If you have at least two braincells, you will chose a unique and secure password for your password manager. That’s the point of password managers, that you only have to remember 1 password so it can be unique and strong. Also, a password manager (specially open source) should have almost perfect security, so them being hacked should not be a concern.

The only thing MFA is doing on password managers is to mitigate malware. Which I don’t think is a good justification to force everyone the hassle of MFA.

Fine if the wanna give the option of MFA, but don’t force it on everyone.

It used to be a serious offense to stage a coup.

It cost them at least one lifelong customer.

If you need to use bash a lot just to learn 2 “keywords”, then it’s not a good language.

I have looked at bash scripts in the past, and even written some (small amount). I had to look up -z and -n every time. I’ve written a lot more python than bash, that’s for sure. But even if I don’t write python for a year, when needed I can just write an entire python script without minimal doc lookups. I just need to search if the function I want is part of syd, os or path.

The first time I want to do an else if my IDE will mark it red and I’ll write eliffrom then on, same thing if I try to use { }.

If a bash script requires at least one array and one if statement, I can write the entire thing in python faster than I can search how to do those 2 things in bash.

Well, to get a boolean out of a bit array you have to do some operations. So at first it doesn’t make it more performant. Compilers probably don’t automatically make them bitarrays because of that.

However, the memory savings means less cache used. And a cache miss is way more expensive than those bit operations. So they should be more performant. I’m sure someone out there has done the actual research and there’s a good reason why compilers don’t make all booleans bitarrays.

I hate both of them. The first one is very clunky with all the ". The second one is not self-docummenting at all, and it makes some enums impossible.

For example, you can’t represent:

enum A {
    B(u32)
    C(u32)
    D
}

It would be

A {
    | u32
    | u32
    | ()
}

Also, the pipe is very awkward to type, specially depending on keyboard layout. Since it’s a rare character. If you need to separate between enums and struts and really don’t want to use the enum and struct keywords, you can use different delimiters, like:

A [
 u32,
 u32
]

B {
 u32,
 u32
}

In my experience, this shows up if I mention an attached file somewhere in the email.

In my experience, nobody really knows what OOP is, everyone has a different definition.

Most of the “OOP” features are implemented in languages that are not OOP. The only one that is to me an OOP-exclusive feature is class-inheritance. So IMO OOP=class inheritance.

There is plenty of criticism about inheritance, specially among rust lovers. Since rust implements other features associated with classes, except class inheritance. Such as: methods (and self keyword), interfaces (traits), default interface method implementation.

Anti-OOPs usually argue that encapsulation and interface is a much better alternative to class inheritance.

Some things class inheritance is criticized for:

Diamond inheritance problem: If there is class A. B and C inherit from A and override its methods. D inherits B and C without overriding them. What implementation should D inherit? B or C? Same happens if only B or C overrides.

Encourages having multiple layers of abstraction: it’s not uncommon to see huge inheritance chains. MyCustomList -> OrderedVector -> OrderedList and Vector -> List -> Collection -> Iterator. Just by looking at MyCustomList, you don’t know the entire chain, you just see “OrderedVector”. You have to follow many nested links until you can know it all, and then you have to retain that knowledge along with tens of other inheritance chains.

Not ideal for performance: Inheritance encourages designs where the compiler will need to add a v-table to classes. These tables make implementation of OOP patterns much easier, but they require additional overhead when calling methods. Note that v-tables are not OOP specific, rust needs them also for trait objects. However, rust encourages designs with small amount of trait objects.

Not as intuitive as claimed: People are taught OOP with simple examples involving real-world objects like: car -> vehicle -> object. However, these situations are rare except in some specific cases like UIs, video games, simulations. In most other cases, you are dealing with concepts rather than objects. And even when you’re dealing with objects, it’s not a clear cut. Sometimes it might happen that bicycle -> car. Even though not intuitive, in some situations this may be a useful inheritance. But when bicycle inherits car, it no longer resembles the inheritance-chain of the real world, so that’s extra work for the brain.