lukewarm take (had this talk in private with @mia but I have to share this):
#Rust is the best thing to happen to #Ada and they should be used a lot more (especially Ada). Moreso, I believe that Rust is essentially FP Ada with C syntax.
Now let me cook (this will be a multi-toot series). Ada, like Rust, is extremely type safe and stringent (they reach memory safety through different paradigms, but they end up having equivalent levels of memory safety).
Ada is more procedural/OO while Rust is more functional, from that POV they fit together perfectly. They're both fast languages with a lot of checks.
Rust can benefit from what we Ada people have with #SPARK and actually be able to prove that your program does what it says without a shadow of a doubt (SPARK is so good that it overshadows #MISRA C which is the gold standard for critical software made in C).
Ada can use Rust's popularity in open source and community (ideally not a toxic one at times), Rust can use Ada's proven track record of handling mission-critical tasks with no compromises whatsoever.
Ada can use Rust's successful marketing (holy shit does #AdaCore need to get involved more), Rust can use the lessons that Ada learned in its 40+ years of existence and improve upon them.
Rust can definitely benefit from having 1. an actual specification and 2. getting rustc certified (which would mean LLVM by extension), but those are behemoths and it's extremely unlikely, impossible even to audit. Lack of advertising leads to misconceptions, and misconceptions lead to not using the language (I use Tcl and Perl, so I definitely know how it feels to use languages that have been osbourned for 2+ decades).
I found about 4 types of answers that I have seen Rust and Ada people give in regards to this #rust vs #ada subject:
hardcore Ada users will obviously say that Rust will die out like D did and isn't a good choice for safety-critical software
moderate Ada users (like myself) think for the most part that Ada really suffers from bad PR and Rust perfectly fits the void
moderate Rust users have told me that they secretly wanted Ada all along but the tooling doesn't do Ada justice
the Rust zealots have repeatedly told me that Rust has a very '83 feel to it, is too verbose and has no ownership semantics (which is obviously a crime against humanity!!!)
I feel like I sort of fit in all of these categories. Rust is overhyped, Ada has plenty of baggage, Rust doesn't have integer subtyping, Ada makes simple things complex to do (even if hard to do wrong in the end).
There has been no real competitor to Ada until Rust came along. We were vibing in our own niche part. Any competitor needs to be memory safe, real time capable and error avoiding by design. C only had real time capabilites, C++ became a little more error avoiding, Java became memory safe, but lost on the other two accounts, D never took off, Haskell beat everyone up in error avoidance but could never win in any race except up the ivory tower stairs, Swift is focused on iOS and Go... it's a long story. Only Rust fits all of those requirements, quite remarkably. Our forums began having questions like "Rust has X for Y, how is our Y-experience?" (not even "Rust has X, we want X". The tooling is much better now, I can confidently recommend ada-language-server + ada-mode or GNAT Studio. Ironically, AdaCore is also trying out Rust (https://www.adacore.com/gnatpro-rust)... imagine bidirectional Ada-Rust bindings, that will be a dream.
Ada and Rust programmers can and should coexist and cooperate so we have more memory safe code and less C code out there.
@a13cui Thank you for these interesting posts! Although there is at least one other dimension I think you missed, and that is language stability. Rust changed A LOT and is still changing a lot and that is a no go for any serious commercial application. Combined with serious issues in the Rust leadership, as a company I would never use this language, not even for free.
The only overlap between these two languages is their focus on memory safety, but that's about it (in my naïve, unfounded opinion).
The only reason why Rust might seem interesting is that companies have access to a bigger Rust developer workforce, which is very small in the Ada world.
I was on a party last week and met two guys. One was 80 years old and still working in a company as a #Fortran developer. The other one was 65 years and still working as a #Pascal (Delphi) developer. Both work on serious industrial applications. It was a real joy to talk with them about how important language stability and longevity is.
@louis from what they do from a language perspective, there's a lot of overlap, I believe what distinguishes them is, as you said, language stability and also the community for the reasons I mentioned in my posts. Also, I am not sure the workforce part is necessarily a win for Rust: it's much more probable to end up with a Rust job doing blockchain or whatever at a new VC-funded startup and same for getting a job in Ada maintaining mission-critical software (there are naturally few jobs for that market since you need to really know your shit and be good at what you're doing). Also, Rust has a more influencial OSS presence which Ada sadly lacks.
Impressive that they're still working in IT, that's nice to know. Change is good, but we have to back off and look in retrospective at things sometimes, which is why I don't believe that Rust is a mature language, because it's ever-evolving (not that that's a bad thing, this is why some people choose rolling vs stable release distros).
When I posted about my experience at the Tcl Monthly Meetup, I remember you posted a message similar to "how old are we talking about" and I told you they're all at least as old as my dad if not older. All of them. It felt like I was in a room full of elders and I was sitting next to them talking about their life lessons. I would definitely have the same feeling if I was talking to the two programmers you talked with. We should listen to old programmers more tbh, at least for the lessons they've learn along their careers (maybe not 60 years old, but people with 10+ years of exp in the field).
@louis@a13cui Rust has a stability guarantee that has been upheld since 1.0 was released (back in 2015), meaning the evolution you are seeing is opt-in (via editions, or lints that can be disabled)
@louis@a13cui there is important software written (at least partially) in Rust, some notable examples being Android, Firefox, AWS S3, Windows, Cloudflare infra, and (the lesser known) TiKV
@louis@a13cui I would not worry much about leadership, because the basics are in place, like releasing new versions every 6 weeks (without fail), running a reliable package registry, and handling security issues timeously
Add comment