> The concepts it introduces are not such a departure from the concepts familiar to many programmers that a huge amount of learning is required.

More specifically, I would say that it lands in the Goldilocks range: It's not so alien as to make it inaccessible, while being alien enough that you'll learn something from it.

> it makes safe "systems programming" possible, which no production ready language previously provided.

I think you have just made Ada and several other languages disappear from the history.

Yeah, "production ready" was the wrong phrase. It's more a combination of availability of language compiler, tooling, training, and interest from developers.

If you start a new project using Rust there is a reasonable chance you'll be able to find libraries for common tasks and developers willing to work on it. You can make a case for it and not lose your job. With Ada, outside of a few niches that isn't going to be the case IMO.

It's been a long time since I looked at Ada, but I believe it's memory mgmt is more inline with modern C++ than Rust. So perhaps it's not truly comparable.

The thing that Ada and its peers lack that Rust has already tackled is finding a strong foothold in OSS. Doubtless there are more lines of Ada than Rust in the wild, but in 30 years of use the only OSS Ada project I can name is GNAT itself, whereas anyone using e.g. Firefox or VSCode is using Rust despite it being ten times younger. Given that most new developers these days seem to learn to program via OSS, and given that HN is largely OSS-focused, it's no surprise that Rust gets mentioned more.

> The thing that Ada and its peers lack that Rust has already tackled is finding a strong foothold in OSS.

Which is irrelevant to the claim that no previous language provided safe environment for systems programming.

You're missing the qualifier of "production ready". While I'd argue that Ada was indeed "production ready" language wise, I'd say that it's not with respect to libraries, of which, OSS contributes a whole bunch.

For some people, a good library selection is essential to being "production ready".

We must think about quite different things behind "systems programming" if you need libraries for it. For me system implements and provides interface, not uses it. Like in operating system.

And then, Ada had a selection of libraries for a long time. You just conveniently forget about the paid ones, so you can call Ada "not production ready".

I wouldn't even say conveniently forgot, I'd say it didn't even cross my mind. It is perhaps also representative of why people don't consider Ada when picking out a language.

That said, I agree that it'd be moving the goal posts to omit paid libraries.

--

I do think we have slightly different ideas of "Systems Programming", or at least what production ready means for that type of language. I think it boils down to the fact that people do a lot more in "Systems Programming" languages than just OS or implementing and providing interfaces. Specifically, people do it for performance and control, which I don't necessarily excludes the use of libraries.

I think the contention here is that people are thinking of production ready for these types of languages in terms of general use, not just the niche you describe. In retrospect, I do think it was a poor way to word it.

I guess I'd probably amend the original comment to say something like "Rust is the first production ready systems programming language that can comfortably (after a learning curve) be used at higher levels".

Sure, but that's irrelevant to my comment, which is answering the original question "Why is Rust so popular on HN?" in the specific context of Ada.

It's not irrelevant. Ada provided safe, production ready language for systems programming long before Rust, so this part of explaination is simply false.

I wouldn't say it's simply false, just that it requires a bit more explanation. Ada is a safe systems language, but is more restricted in what can safely be expressed.

While you are right, it would also be good to learn the history of computing in a proper way, instead of re-writing it based on urban myths and perceptions.

Ada doesn't have the same memory management safety without a garbage collector that Rust does.

Ada has memory management safety, even though it is not the same paradigm as Rust. Affine typed pointers might be a tad more powerful than Ada's scoped pointers and limited types, but they're still not powerful enough to express everything useful - cyclic structures in general are a very big hole in Rust's type system in that regard.

And then in both language, you can use unsafe when you need more power. So Rust might (and I say might, because I have no clear proof of that yet) be a tad more powerful in the safe subset, but it's not in a different class.

Indeed Ada has different memory management model, though equally safe.

I've coded in Ada. Storage pools are not as safe as Rust's affine type system. For one it's a lot easier to leak memory with Ada, since they're mainly built off of reference counting.

Pedantic: memory leaks are memory-safe, despite generally being undesirable.

You're totally right, but yeah, I tend to roll it in to the same category since I consider the denial of service associated with memory leaks to be as bad as stricter memory unsafety. (And to be very pedantic I said 'memory management safety', not just 'memory safety').

Ada uses a garbage collector for the free store (or just uses unsafe code if it's disabled). Ada's memory management model is not really different from any other typical language.

This is the first time I've ever heard of Ada being garbage collected. Neither ARM, Barnes' nor Ben-Ari's books, nor GNAT manual say that there is supposed to be a garbage collector (quite the contrary, the books say that GC is allowed, but usually not present).

Where did you get your information from?