[Antibabelic]

Ada and SPARK fulfilled the promise of a safe systems language decades ago without making most of the mistakes Rust does. Rust has its strong sides, sure, but it's far from the only shop in town. The GCC happens to include an Ada compiler as well.

[dvtkrlbs]

The problem is they forgot about making the language approachable so it lives in its bubble for safety criticial usage (which Rust kinda starting to eat its lunch from with the certified Rust fork)

[Xylakant]

If you’re referring to Ferrocene with the certified Rust fork, then I’d like to make the minor correction that we don’t consider Ferrocene a true fork, but rather a downstream distribution of the Rust projects compiler. There are very little changes to the compiler itself. Most relevant changes are documentation, build process and different test coverage - we do test architectures that upstream does not.

[dvtkrlbs]

Yeah fork is a bad word for it. Sorry about that.

[Antibabelic]

What do you find unapproachable about Ada?

[dvtkrlbs]

For starter it looks completely alien my real introduction to Ada was with this article comparing it to Rust on solving advent of code [1] but it gives me that feeling when I try to read Haskell code (not that extreme). I did not actually give it a real chance though but its user base even more niche than Rust so idk. It has really cool properties (being able to define n bit datatypes is nice) but it is also leans to more on the imperative side so that also does not interest me.

[1] https://github.com/johnperry-math/AoC2023/blob/master/More_D...

[Antibabelic]

I wouldn't call it alien. If you've ever written even a little bit of Pascal, you should feel right at home in Ada.

[dvtkrlbs]

I never wrote a line of Pascal :/

[solidsnack9000]

What are those mistakes?

It seems like Ada more or less has to have memory safety bolted on -- that is what SPARK does -- and it's not clear that Ada's bias towards OO is better than Rust's bias towards functional programming.

Are you talking about features like type inference (so the Rust code could be less clear, since types are not always written out)?

[pjmlp]

And just recently Modula-2.