I certainly think that it has many eccentric design choices. It’s not going to be for everyone. Some parts of it, I also think just look bad, which I had to customize. Well, and openSUSE’s theming made a big difference, too: https://simotek.net/tech/projects/opensuse-e/enlightenment-on-opensuse-13-2/nggallery/thumbnails

“Retro” is also definitely a word I would use, though more positively connoted. It has *different* eye candy to the usual desktop designs, which is a big part of the charm. In a sea of flat designs and tiling window managers, it stands out as its own thing.

I tried it a few years ago. I was really impressed by how lightweight and gorgeous it is. In particular, I found it really cool and actually useful that you got a live view of your other workspaces on your panel. You could even fullscreen a video on your other workspace and then watch (a very small version of) it in your panel.

But yeah, even though I came back to it multiple times, I never ended up sticking around. It would crash regularly (not the worst thing, since recovery was generally seamless, but still meh), but in particular, it had some peculiar design decisions.

For example, if you double-click a window titlebar in virtually any window manager, it will maximize. In Enlightenment, I believe it got shaded (i.e. the contents of the window got hidden and only the titlebar was still visible).

Another prominent one was that its applet for connecting to WiFi and such didn’t support NetworkManager, but rather only ConnMan. If you’ve never heard of ConnMan, yeah, I only know it from Enlightenment, too. Similarly, my distro (openSUSE) didn’t package it either (and openSUSE was said to offer a relatively good Enlightenment experience). That’s something which should just work, because you can’t expect people to look up how they can connect to WiFi while they can’t reach the internet.

And yeah, these are just the big ones that stuck in my head. There were lots of smaller usability issues, too. Many things you could fix by changing the configuration, but we’re talking many in an absolute sense, too, i.e. you might spend an hour or more just tweaking things so that they behaved like you might expect.

I mean, to my knowledge, it’s still Rasterman keeping most of the development together. You don’t need a ton of adoption when one guy tirelessly works on it.

Although I’m guessing Samsung probably sponsors him, so that’s probably quite crucial for him to be able to put that much time into it.

Why not both?

For optimal performance, you should rewrite it in Rust:

inline_python::python! {
    print(js2py.eval_js("(number) => number % 2 ? 'odd' : 'even'")(number))
};

I’m guessing, this is what a drink carrier looks like, in case anyone else is wondering:

unsafe doesn’t deactivate memory safety. It only allows you to then create raw pointers and whatnot, which you could use to circumvent memory safety, but all the normal language constructs still do enforce it.

!unexpectedfactorial@sopuli.xyz

Linux Mint lists 11 people in their GitHub org. There’s likely additional outside contributors, but that’s the core team. In the Cinnamon repo, only 5 people have changed more than 1000 lines of code in the last two years.
I expect CentOS to have even less contributors, as they largely just repackage what Fedora does.

Mozilla has around 750 employees, most of which are fulltime devs.
Like, man, I don’t want to kill your optimism, but we’re talking an order of magnitude difference at least.

Firefox is one of the most complex pieces of software on the planet at around 30 million lines of code (comparable to Chrome, WebKit and the Linux kernel). Personally, I think, it’s a miracle they can maintain that with less than 700 devs. That’s more than 40k lines of code per dev, most of which they won’t have written themselves.

At $DAYJOB, we’ll write 40k lines of code maybe in two years, with a team of 5+ devs. And having to maintain 10k lines of code is what I consider rather challenging, i.e. I’ll likely start falling behind sooner or later, because the world around me moves faster than I can.

As in, you call main() recursively? Don’t think, I’ve ever tried that in any language…

You can make external tools available to the LLM and then provide it with instructions for when/how to use them.
So, for example, you’d describe to it that if someone asks it about math or chess, then it should generate JSON text according to a given schema and generate the command text to parametrize a script with it. The script can then e.g. make an API call to Wolfram Alpha or call into Stockfish or whatever.

This isn’t going to be 100% reliable. For example, there’s a decent chance of the LLM fucking up when generating the relatively big JSON you need for describing the entire state of the chessboard, especially with general-purpose LLMs which are configured to introduce some amount of randomness in their output.

But well, in particular, ChatGPT just won’t have the instructions built-in for calling a chess API/program, so for this particular case, it is likely as dumb as auto-complete. It will likely have a math API hooked up, though, so it should be able to calculate a logarithm through such an external tool. Of course, it might still not understand when to use a logarithm, for example.

The problem is that corporations are not holistic organizations. In theory¹, a company could not have any juniors and always just hire seniors from the outside. And if your boss has reason to believe that this is more cost-effective, then they have to strive for that, even if they’re well aware that it cannot work when all companies strive for that.

¹) In practice, I’ve actually found that juniors are important, too. If you staff a project team with only seniors, you quickly end up in a situation, where they don’t talk enough to each other. They know how to solve things technologically, so they don’t need to tell each other about their challenges and what solution they chose.
Similarly, you likely end up in a situation, where only big problems are being tackled, because everyone can tackle big problems and they’re just very visible, highly prioritized problems. But when you add up enough small problems, they become just as problematic.

If you run a build command on the CLI, it should tell you the full type names…

The conventional ternary is structured like a normal if-else. In fact, in many languages with functional influence, they’re the same thing.

For example, you can write this in Rust:

let vegetable = if 3 > 4 { "Potato" } else { "Tomato" };

“Dad Jokes” are a specific kind of joke, which typically make people groan, because they’re so terrible. See !dadjokes@lemmy.world, for example.

But his sentence could also mean that he tells jokes to his dad. She notices that and asks about it, therefore making a Dad Joke herself.
He doesn’t get the Dad Joke, which exposes him as perhaps not being very good at the whole Dad Joke thing.

Those also happen to be errors you’d typically run into, if you don’t yet really know Rust…

Coincidentally also the logo of !opensource@lemmy.ml.

According to the screenshot I took, it was a gargoyle berserker with an axe. I had some ridiculous luck with armor drops, so basically every resistance was either maxxed or close to it. I only really got into trouble down in Zot:5…

And hmm, I should do more with Lugonu. I never really have a reason to pick him, but that means I also don’t experiment with him, so I won’t really learn what reasons there are to pick the guy…

I actually do, yes. Hundreds, if not thousands, of hours played and I made it down there and back out exactly once. 🙃