Ada

Description

Ada is a modular, statically typed, structured object oriented and procedural language in the Algol family that was introduced in the early 80's by Groupe Bull and was largely modelled on Niklaus Wirth's Pascal and Modula-2 but added more safety features and stronger support for concurrency, with later versions of the standard adding object orientation.

Initially there were a number of implementations for OS/2, all of them validated and most sold rather briskly so got fairly routinely updated. This changed with the appearance of GNAT, its development had been paid for by the USA DoD and so was its validation and the OS/2 version as the initial 32 bit port for 386 microprocessors got a lot of attention from the developers and was all in all a fairly solid release especially for the first few years, even though still as slow and bloated as on the Unix workstations it originally came from not the least since it used the GCC as a code generator. Despite speed advantages and superior development environments in general from the commercial offerings the market for paid alternatives mostly vanished overnight even though the OS/2 market was still growing at the time, the Windows and DOS markets however escaped better since the DOS version of GNAT newer worked as expected and a fully usable Windows version did not show up for a number of years.

The problematic feature of Ada is not the language itself, but the size of the combined language and standardised libraries and bindings, this does not affect the performance of outputted code, programs written in Ada should in that respect reach the same speed as other languages in the Algol family like C++ or Oberon if similarly implemented, it is just that the development and verification of the full system takes a lot of time and this has lead to companies shipping language sub-sets, delivering compilers late, often by years and stifled open source development since it is not a tool that a small group of enthusiasts can take on in the free time easily. There are only two free tools out there, one was financed entirely by the USA Department of Defence and the other the result of 15 years of work by an individual. In addition compilers used for certain markets are supposed to be officially certified which is a costly project that deters both small firms and open source projects.

A list of OS/2 implementations of Ada

• Alsys Ada - Predecessor to Thomson - Discontinued.
• Artek Ada/Lattice Ada - Announced but probably never shipped
• GNAT - Open Source - Discontinued
• IntegrAda/386 - Discontinued - Rebranded Janus/Ada compiler with some AETECH bundled tools
• Intermetrics Ada - Announced, possibly never released.
• Janus/Ada 83 - Discontinued
• Janus/Ada 95 - Discontinued
• OC Systems Ada - Announced for OS/2 PowerPC edition but probably never released.
• Thomson Software Products Ada - Discontinued

Libraries and bindings

• PM Bindings for GNAT
• Ada (GNAT) bindings to the OS/2 API
• Ada Class Library

Editors with Ada support

• Boxer
• FTE
• jEdit - Java editor

A list of DOS implementations of Ada

• ADA+SQL - Hybrid of a Win95 IDE and a DOS compiler, took over from AVLAda9x
• ADA/ED - Open Source - Discontinued - Interpreted predecessor to GNAT.
• Alsys Ada - Discontinued - Used VCPI so incompatible with OS/2 and Windows
• Aonix Ada - Commercial - Discontinued
• Artek Ada - Commercial - Discontinued.
• AVLAda9x - Takes over from SMALLAda, adds some Ada95 constructs. - Discontinued - Freeware
• GW-Ada/Ed for DOS
• Janus/Ada 83 - Current
• Janus/Ada 95 - Current
• Meridian Open Ada
• SMALLAda - Discontinued - Ada Subset - Freeware.

Publications

• Henry Baker's Archive of Research Papers - Primarily Lisp related but a few Ada related papers in-between.

Local articles

• Nonformal introduction to ADA-95 - by Leonid Dulman

Tutorials and other learning material

• Ada Programming/Coding standards - From Wikibooks

Standards

• The Ada standards specification was initially developed by the USA DoD and later ratified by ANSI, they are now governed by the international standards clearinghouse ISO.
• Ada 83 - Initial standard - ISO-8652:1987

Ada 95 - ISO-8652:1995

• Mostly upwards compatible, adds object-oriented extensions.
• Ada information clearinghouse has most of the documentation that relates to the standard available for download.
• Ada Semantic Interface Specification is an add-on to the Ada 95 standard

Ada 2005 - ISO/IEC 8652:1995/Amd 1:2007

• Referred to as both "Ada 2005" and Ada 95 Amendment 1, depending on whom you talk to. - Primarily clarifications.

Ada 2012 - ISO/IEC 8652:2012

• Latest standard, changes are mostly to the environment (Unicode 32bit, Special needs etc), but some syntaxical and expression changes as well alongside a slight strengthening of the object orientation.

Ada history

Ada is usually described as having been developed at the behest of the USA Department of Defence, but that is not correct. French company Bull started work on a toolset for embedded "safe computing" in 1977 (or possibly slightly earlier) based around a Pascal derivative called LIS (Language d'Implementation de Systèmes) that Bull had used in-house as a system language. "Safe computing" was a buzzword in the 1970's when people came to realise that most tool chains relied on code quality and debugging rather than standards, structures and safety features. This was not a huge issue on the relatively small programs and the business, scientific and military environments that that early computers were used in, but when programs started to get more complex and toolchains longer, and computers increasingly started to take control of machinery, be it industrial robots, medical equipment or transportation infrastructure and vehicles, what did increasingly start to happen were accidents that could not be attributed to direct failures in hardware or by operators, but to errors in the controlling software, and not just the code that was written for the task but often the errors originated in the tools used to build the code in question, or even the tools used to build the tools.

These kinds of accidents started to cost not just money, but lives and that lead to the interest in adding safety-critical features to computer development tools. In the case of Bull, designer Jean David Ichbiah started to modify not just the tools used but the programming language itself, adding stronger structural types and later a module system lifted from Wirth's Modula-2 but also more explicit safety features and more emphasis on standardisation of the environment (libraries, bindings and such) than the minimalistic Pascal and Modula had, this allowed the conformance testing of not just the the compiler itself but all the tools used to develop the end product which was vital in regards to the safety features. Wirth and Dijkstra et. al. focused squarely on the language and ignored the libraries and modules, regarding these as add-ons or implementation specific features but in the real world these all affected the performance of the language as far as safety was concerned and therefore required as rigorous a testing as the compiler itself.

The USA Department of Defence had a very real world problem in the 1970's in that they wanted to cut down on the multitudes of languages used in the products they operated, but in the mid 70's they were estimated to be between 300 and 400 incompatible variants, this lead to numerous problems in regards to incompatibility and continuity, not only were companies not able to work on products delivered by companies no longer with us due to lack of expertise and or tools in a specific language variant, in many cases only one company could bid on some projects due to the same reason, meaning they could more or less dictate prices. This made the organisation keen to standardise on a single language that in addition had some Safe Computing features, the DoD had with some success managed to force companies to standardise on a language in the 1950's with COBOL but that language was really only suitable for generic application development, they tried in the early 1970's to standardise on a safe version of PL/I called SPL/I but project failed primarily to a lack of language flexibility.