[t8sr]

I've taught programming to some people who had no previous experience with it, and I can tell you that the list of concepts you have to learn at once is basically as long for Python, the quintessential "beginner" language.

The author's argument feels intellectually dishonest for that reason. Especially glaring is the comparison to JavaScript. The latter has an insane amount of concepts to deal with to do anything, including some truly bizarre ones, like prototypes.

Rust is hard to learn, IMO, for precisely two reasons:

1) The borrow checker is in an uncomfortable place, where it's dumb enough that it rejects perfectly valid code, but smart enough that it's hard to understand how it works.

2) As the author points out, there are a lot of levers available for low-level control, precise allocation, etc.

With respect to the second point, the author describes a language he'd like to see: green threads, compiler deciding on allocation, fewer choices and easy thread safety.

This language already exists (minus algebraic types). It's called Go. It's perfectly fine, well-designed and good for beginners. Some people don't like its aesthetics, but that's not reason enough to invent it again, only with Rust-inspired syntax.

[diarrhea]

Go is not thread safe. It even allows data races in its own runtime. Go 1.25 fixed a nil-checking error that has been sitting in the runtime for two years.

Generally, Go will let you compile just about anything when it comes to channels, mutexes (or not..), WaitGroups, atomics, and so on. It usually compiles as there are no static checks, and then just fails at runtime.

[t8sr]

That’s a good point. I remember that in the earlier days of Go, there was a lot more optimism about the compiler’s future ability to statically decide more about the program than it currently does. It’s unfortunate that the language never got there.

Sadly, given Google’s new culture and all the people who have left, it seems unlikely it’ll ever get there.

[J_Shelby_J]

> the list of concepts you have to learn at once is basically as long for Python, the quintessential "beginner" language

IMO, Python is great. But deploying Python is more work than learning Rust, oh and the tooling is something that requires continual education: I hear UV is what all the serious python teams are using now. Better learn it or be left behind!

Meanwhile, vanilla Rust has everything you need. I'm glad I understood sunk cost fallacy and got out of Python after many months of coming up to speed with it.

[the__alchemist]

I just watched an experienced programmer on twitch struggle for an hour trying to install a Python-written program using UV! The churn is real, and distributing python programs is still a mess.

[baq]

that's very unfair towards the both uv (uv is great) and the absolutely atrocious state of Python tooling until basically 2025 (slow and brittle, if it was even installed - hello, debian derivatives). uv is the cargo of Python we've been waiting for and it is expected you won't need to learn anything else for a long time.

[jmull]

> intellectually dishonest

Your claim here is that the author's argument is intentionally misleading. That's an awfully strong accusation, and you don't support it in your comment.

You're also immediately undermining your own argument when you go on to list difficulties in rust that javascript doesn't have.

[TylerE]

The venue bigger issue with rust as that the compiler is so bitchy it is actively hostile to incremental add-a-line-at-a-time incremental development.

Especially unused variables being a hard compilation error, not a warning.

[estebank]

Unused variables are a warning:

https://play.rust-lang.org/?version=stable&mode=debug&editio...

[Ar-Curunir]

What? Unused variables are warnings in Rust. Are you thinking of Go?