Developed for the Department Of Defense of the USA, it was originally designed to support the construction of long-lived, highly reliable software systems and real-time embedded systems .

Its design:

• Emphasizes readability
• Avoids error-prone notation
• Encourages reuse and team coordination
• Is efficiently implementable

A significant advantage of Ada is its reduction of debugging time.

These designed features optimize Ada to be a Language for very large programs. For Long Lived programs and systems, that spend most of their life cycle in maintenance. For robust programs with correctness, security, and reliability. For embedded systems with low level hardware control, concurrent tasks, and real time. Then again, can't hammer this enough, in a safe environment.

Ada tries to catch as many errors as reasonably possible, as early as possible. Many errors are caught at compile-time by Ada that aren't caught or are caught much later by other computer languages. Ada programs also catch many errors at run-time if they can't be caught at compile-time (this checking can be turned off to improve performance if desired). In addition, Ada includes a problem (exceptions) handling mechanism so that these problems can be dealt with at run-time.

Ada's user base has expanded far beyond the U.S. DoD to many other areas such as large-scale information systems, distributed systems, and scientific computation. Major Ada niches include aerospace and safety-critical systems.

Ada compilers can generate code comparable to C, C++, and Pascal compilers. Because of the way Ada was designed, Ada compilers can sometimes generate better code because they have more information that can be used for code optimization. For example, in a large number of cases an Ada compiler can do better than a C or C++ compiler can while passing parameters, because an Ada compiler knows when aliasing is not possible.

It is true that Ada run-time error-checking capabilities require some time and space, but they can be selectively or completely turned off. Since Ada compilers can often detect and optimize these away, they often do not have as much of a performance hit as you might expect even when left in. Also, in a typical "pay for what you use" manner,