I've heard that Ada's strong typing makes it painfully verbose to use, so it's only good for NASA and military contractors who want that level of security. How does it measure up to D?
Ada's strong typing only gets verbose if you end up doing a lot of casting, which usually means you designed your types wrong. In my experience, Ada's typing actually results in less code, since it allows the compiler to check things that other languages can't. For example:
subtype Little_Int is Integer range 1 .. 10;
Now the compiler knows the acceptable range for Little_Int, so you never need to verify that data of this type has a valid value. The compiler checks it for you, giving warnings if it detects violations at compile time, and raising exceptions at runtime for cases that can't be checked while compiling.
Ada does tend to be more verbose in some cases, just because it favors keywords over symbols. For example, declaring a type that inherits from some other type but adds nothing looks like this in C++:
class Derived : public Base {};While in Ada:
type Derived is new Base with null record;
Longer, but probably more understandable.
How does it measure up to D?
I don't know D, so I can't compare it to that. The best comparison I can make is with C++, which is the language it is closest too.
Ada supports procedural programming at least as well as C++, possibly better. Ada has neat things like nested functions, the ability to overload on return types, function renaming, positional as well as named parameters, and a very nice package system.
C++ has more advanced object-oriented features. Ada uses interfaces rather than true multiple inheritance, and Ada is the only language I've ever used that got interfaces right. Ada interfaces can have required overrides, optional overrides that simply do nothing if not overridden, and non-overridable methods that can actually have bodies. It also has the interesting notion of interfaces to threads, which I'm still exploring.
Ada has full language level support for threads, including inter-thread communication and simple thread-safe data structures. I have to emphasize that Ada threading is actually part of the language, not the standard library. Most languages sort of half-ass this, like how Java has the Thread class and Runnable interface in its library, but has the synchronized keyword in the language. Everything about threading is fully integrated into the Ada language itself, and I've never had an easier time doing concurrency.
I'm pretty sure that Ada invented generics as we know them today, 30 years ago. C++ templates were largely based on Ada generics. C++ templates are more powerful, but Ada's generics have a number of great conveniences, like true separate compilation, which Ada has had for three decades but most C++ compilers still can't come to terms with. Ada generics also have a full constraint system, and C++09's template concepts have taken this idea and done some great things with it.
How's performance? Also, is there a good free Ada compiler?
I don't have numbers to back this up, but I believe that Ada's performance is comparable to C++ in most cases. Ada has a lot of safety checks (array bounds checking, for example) but the interesting thing is that most of the checks can be done at compile time if you do your types correctly. Ada only does runtime checks for the things it can't verify at compile time, and if you're truly performance paranoid, you can compile with all checking disabled for the final product.
GCC compiles Ada, version 4.3 has the complete Ada 2005 implementation.
Developer
