Oh Ada. In college (six years ago), it was the language solely responsible for dragging down my grade right before graduation. I very much disliked the prof who taught it, which probably clouded my perception of the language, but I found it a lot harder to solve problems in the extreme type safety of ADA than C++ (our "core language"). Not sure why, just vividly remember being dead set against never seeing it again :)
I do remember the professor going on and on about why the safety was necessary for his beloved Military and Avionics software (he worked at an avionics software company in his "off" hours). It makes a lot more sense now, and oddly enough with my interest peaking in Rust and Go, it might be worth looking at again... or maybe I'll just stick with languages that don't invoke bad memories.
It's interesting to me that when people boost Ada's type safety, they always compare it to other Foogols, like C and Java.
OK, how about Ada vs Haskell?
Does Ada have anything like Haskell typeclasses or am I going to have to write a different sort function for every single data type which can be sorted?
Does Ada have a numeric tower, or will I have to accept truncation and re-write basic numeric functions?
Haskell has strong static typing without forcing me to specify irrelevant details up front. How about Ada?
Haskell makes it extraordinarily hard to write memory safe, performance critical code that doesn't use a garbage collector. Just consider Ada's support for arrays versus that of Haskell for example. Haskell is nice for certain problem domains, but for those that Ada is used for you would be borderline insane to consider it.
> Does Ada have anything like Haskell typeclasses or am I going to have to write a different sort function for every single data type which can be sorted?
Generics and interfaces.
> Does Ada have a numeric tower, or will I have to accept truncation and re-write basic numeric functions?
Subtypes and ranges.
> Haskell has strong static typing without forcing me to specify irrelevant details up front. How about Ada?
If you mean type inference. No in Ada everything has to explicit.
Now you are comparing Apples and Oranges here, as Ada is a systems programming language.
So it allows for memory safe systems programming, with all the direct hardware access and memory allocation control that such use cases require.
Whereas Haskell, currently, still requires language extensions like on HalVM and House OS implementations.
Besides Ada, Algol 68, Mesa/Cedar, Modula-2, Modula-3, Oberon derivatives are also worth a mention in the list of languages that allow low level systems programming without the usual C minefields.
The licensing for the Ada ecosystem is confusing to me. It seems that the major vendors are Adacore, Green Hills, and Atego. Am I correct that for commercial products, there are no free toolchains available?
the FSF version of gnat is robust, mature, and reasonably up to date. It's licensed LGPL so you can use it pretty much like anything else.
Adacore also puts out a slightly more state of the art version of gnat but it's GPL so in theory everything you make with it needs to be gpl as well (though of course that's fairly irrelevent for many classes of software)
Perhaps it has to do with the runtime being GPL'd? Regardless, the Adacore FAQ specifically councels that the GPL version is suitable for free software only.[0] Admittedly, I find the licensing situation confusing and could be completely in the wrong here.
