Ephera

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

I believe, it’s this: https://en.wikipedia.org/wiki/Scrapbooking
So, kind of like a photo album but more freestyle…?

Man, with how things are going right now, I almost believed this was happening…

Oh yeah, I’m in favor of using type hints. People here are also saying that Pyright is more useful, which I haven’t used yet.

I was involved as the unlucky bastard supposed to sprinkle software engineering on top of a Python project 2+ years ago, and I just remember how much I understood right then and there why Python devs thought static typing was cumbersome. Felt like I had to write Java again, except it also didn’t work half the time.

Interesting. If it’s only in the type checker, can IDEs/editors correctly show the type information of inferred types then? Do they call the type checker themselves to retrieve that info?

Yeah, I only used Mypy so far. I thought it was inherent to the language spec, not the type checker.

I guess, some of your colleagues might have also just used Mypy so far, though…

In the case of Rust, you can also omit the type annotation in the vast majority of cases and the compiler will infer it.

It feels more solid to have a complex program covered by tests, yes, but how can this be confirmed in an objective way? And if it can, for which kind of software is this valid? Are the same methodologies adequate for web programming as for industrial embedded devices or a text editor?

Worth noting here that tests should primarily serve as a (self-checking) specification, i.e. documentation for what the code is supposed to do.
The more competent your type checking is and the better the abstractions are, the less you need to rely on tests to find bugs in the initial version of the code. You might be able to write code, fix the compiler errors and then just have working code (assuming your assumptions match reality). You don’t strictly need tests for that.

But you do need tests to document what the intended behaviour is and conversely which behaviours are merely accidental, so that you can still change the code after your initial working version.
In particular, tests also check the intended behaviour of all the code parts you might not have realized you’ve changed, so that you don’t need to understand the entire codebase every time you want to make a small change.

To be fair, Python doesn’t have type inference, so the type hints are quite obnoxious, and the type checkers for Python are also not as reliable as in languages with native static typing (even if that is often caused by libraries not providing type hints).

I could imagine that they didn’t want to do something called “Destiny 3”, because people would expect that to be better than Destiny 2, which is virtually impossible, if you’re gonna start over from scratch, with how many years of development have gone into Destiny 2 by now…

I think, that’s not a coral, but rather a dead tree next to a stream…

Yeah, the wording is confusing. A long time ago, there was no paid software, there was only software where you got the source code and other software where e.g. it was pre-installed on some hardware and the manufacturer didn’t want to give the source code.

In that time, a whole movement started fighting for software freedom, so they called their software “free”.

Sure, but that doesn’t actually happen in reality, that things just stop changing. Occasionally, you get rather isolated ecosystems where the changes go back and forth in a mostly self-contained manner and then adaptation might plateau for a bit, but at some point, a lightning or an earthquake or something will strike and then it’s back to adaptation.
Well, and those species which were the most adapted to this isolated ecosystem are also likely to die out then, rendering this temporary endpoint not exactly “ideal” either.

But it’s also not one singular endpoint either. Diversity is itself a strength, which helps species survive. This is particularly important where there is change, because external influences will affect different members of this species more or less strongly.
But even without change, splitting the work is beneficial. This can be as mundane as not everyone carrying around the equipment for bringing out the babies. But in particular with societal structures, it can also mean that the big muscle folks might do the muscly tasks and the big brain folks do the brainy tasks and those with claws for hands open up all the tin cans.
Evolution will not push past that to arrive at some hypothetical “ideal endpoint”, because that society with work splitting is fitter for survival than a monoculture would be.

Yeah, I hate that so much. Often times, it’s clearly just easier/cheaper to put makeup on a human actor, or at least for the aliens to be able to use the same equipment. But it’s so boring. If I want to see a humanoid with different skin color, I’ll visit my neighbor.

“Ideal endpoint of evolution” is itself a funny joke to those who participate in knowing things…

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))
};

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.

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

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