“Even worse”? Are you saying Rust is bad?

Programming: not even once!

It’s so rare for these people to admit they have brain worms!

I’d say you’re misinformed, but it requires some real idiocy to be that badly misinformed and that deliberately insulting to a whole programming language community.

Ooooh, luddism is so edgy!

And no, Rust is not primarily used to generate web apps, shitty or otherwise. You’re thinking of JavaScript.

I think what’s more important then canon is something like an analog of continuity from calculus. A function can be continuous everywhere, which is analogous to having perfect adherence to a canon. It can also have major discontinuities (like 1/x at x=0), which I think of as like a reboot. There are even single-point “removable” discontinuities (like x²/x at x=0), which can be fixed by adding a single point to a function, are more analogous a tiny detail being wrong that doesn’t affect anything else and can probably be fixed with a simple retcon if anyone even cares.

You can do all kinds of calculations that depend on continuity of a function as long as they’re restricted to parts of the function with only removable discontinuities. Similarly, you can tell perfectly good stories in a broken canon as long as the story doesn’t focus on things in the canon that are broken. Each individual story needs to maintain its own continuity (or else we say it has plot holes), but discontinuities between stories don’t matter as long as stories feel like Star Trek to the audience.

Of course, feeling like Star Trek is very subjective, and feeling like a bunch of connected stories share the same continuity can be very satisfying, but overall, I agree with Nimoy that fans should just relax and not let discontinuities ruin their enjoyment of a good story.

I switched jobs from one using a mostly C++ stack to one using a Typescript/JavaScript stack for a large application. I was absolutely shocked at how slow and generally shitty the tooling for JavaScript is, and coming from C++ land the bar was already very low.

It’s not intentionally obfuscated or minified. Generally it just strips out types and comments, but depending on how it’s configured, it will rewrite certain things to work in ES5. At my work our build process uses a separate minification and bundling step, which also serves to a obfuscate our proprietary code.

Historically Python has done no semantic analysis at all, and as far as I know CPython still ignores type annotations except for checking their syntax and (I think) checking that type expressions can be evaluated as regular expressions. It’s also one if the slowest languages around, and it used to be much worse in the 1.x days. The only actual declarations are global and nonlocal, unless they’ve added something else recently. Everything else that looks like a declaration is actually a statement executed for its side effects. The super function used to only be callable with two arguments, because automatically supplying self and the lexically enclosing class was considered too magical.

If you’re looking for something like Java or C#, Python isn’t for you. It was designed for use cases like fancy scripts and small applications that aren’t CPU bound. It’s about as dynamic as a language can be, meaning it’s possible to break almost any analysis you might do with a call to eval, and a lot of what you’d expect to be core language primitives, like accessing a field of an object, can execute arbitrary code.

There’s no need to shout cis.

Yeah, I didn’t think of that case, because any time I use ref counting, cyclic references are at the from of my mind.

I agree Rust makes it virtually impossible to leak memory by accident. The difference I wanted to point out is that leaking memory is explicitly not considered unsafe, and types like Box have a safe “leak” method. Most “naughty” things you can do in Rust require using the “unsafe” keyword, but leaking memory does not.

I disagree about comparing languages by speed. Just because you can make Go programs as fast as Rust programs, it’s not going to be as straightforward as doing it in Rust. I’d much rather spend slightly more effort up front to write idiomatic Rust code that’s fast by construction than try to make Go code faster by applying a bunch of arcane tweaks to it.

You can leak memory in Rust if you want to (and it’s occasionally desirable). What the type system prevents is mainly accessing memory that has been deallocated. The prevention of memory leaks uses RAII just like C++. The main difference related to allocation is that there’s no “new” operator; you can pretty much only allocate memory through the initialization of a smart pointer type.

I’m pretty sure this is precisely the kind of thinking OP is trying to break you out of. If you make it far enough in your career, dealing with people who talk like that will become part of your job. We’d all like to just spend our time coding, but you can’t just ignore the people who write your paycheck.

I’m not a fan of Go, but calling its type system comparable to C is unfair. C has nothing like Go’s interfaces, and Go has generics now. Plus having strings and maps as built-in types is a huge win for convenience. Go’s slices are also superior to how arrays are usually done in C (but still a lot less ergonomic than a C++ vector or Rust Vec).

Person who has never used a popular language mistakes its users for a cult! Film at 11.

I think you mean not San Francisco.

I’ve never made a native mobile app. I’ve made a couple of web apps designed for mobile devices, and for those I used HTML+JS when it was really simple and React with Typescript for anything more complex. I choose those options mostly because they’re what I’m already familiar with from work.

People who are about memory safety are children? Bruh.