Steelman is the original requirements document for the Ada 83 computer programming language. Steelman was released June 1978 by the High Order Language Working Group (HOLWG) of the US Department of Defense (DoD). Its formal title is "Steelman Requirements for High Order Programming Languages", AD-A059 444, US Dept of Defense, June 1978; it was also published in the December 1978 edition of SIGPLAN Notices. See the history section below for more about the related history of Steelman.
You may view:
You can also see some comments on changes since then.
Advanced users can jump to any specific requirement by appending a "#" and the requirement number to the Steelman URL. For example, a link to steelman.htm#3-2C brings up requirement 3-2C (which requires a Boolean type). You can start at specific chapters in the same way, for example, a link to steelman.htm#9 shows chapter 9 (which discusses parallel processing). A text file listing all requirement numbers and short names is also available.
The comparison paper "Ada, C, C++, and Java vs. The Steelman" by David A. Wheeler is also available. This paper compares each of these languages to each of the Steelman requirements. You can view the normal (long) version, or a shorter version with hyperlinks to the Steelman requirement text. This paper was published in the July/August 1997 issue of Ada Letters. You may also retrieve the postscript version.
Note that this document also has a number of internal hypertext link destinations; advanced users can use these links to jump to specific areas of the text. For example, a link to steeltab.htm#3-2C shows comments on how each of these languages implement Steelman requirement 3-2C (for a Boolean type). You can also jump straight to the conclusions by jumping to steeltab.htm#conclusions.
Note that things have changed since the publication of this paper. In particular, Java has added several important capabilities, including enumerations and generics. C++ implementations have matured, though there are still an amazing number of problems in compilers' implementation of C++ templates.
Of course, things have changed since the papers above. There was an Ada 2005, and then an Ada 2012, and both have extended Ada further.
In Ada 2005 and 2012 the assertion-related Steelman requirements 10B is better met, and Steelman requirement 10F changes Ada from "no" to "yes". Ada 2005 added a simple built-in assertion, which was enough to meet those requirements. Ada 2012 later added built-in support for preconditions, postconditions, invariants, and quantified expressions, which are far more powerful built-ins for program assertions.
In 2003 I gave a keynote at the SIGAda conference, noting things that needed to change in Ada. It took a while, Ada 2012 incorporated several of the issues I noted, including the need for a bigger standard libraries, some syntactic sugar to simplify some common constructs, and changes to simplify interaction with other systems. When I presented in 2003 I noted that "C functions often can't map to Ada functions", and I recommended that Ada allow functions to have "in out" parameters. This was considered heresy at the time, even though the Ada prohibition didn't actually achieve anything other than making interfaces hard to create (Ada functions could always manipulate global values). Ada 2012 now allows functions to have "in out" parameters, just as I had recommended at the time.
Of course, other languages have changed too. Java, for example, now has generics.
In the 1970s the US Department of Defense (DoD) noted that its costs for computing were skyrocketing. A summary of the costs of the time can be found in "Automatic Data Processing Costs in the Defense Department" by David A. Fisher, October 1974, Institute for Defense Analyses (IDA) Paper P-1046. Steelman development later began; here's how the process is explained in IDA document P-1191 from 1976:
"In January 1975, the Director, Defense Research and Engineering (DDR&E), in a memo to the Assistant Secretaries of the Military Departments for R&D, noted the multiple benefits of a single common language for military applications. He requested immediate formulation of a joint Service program to assure maximum useful software commonality in the DoD. A working group was formed from official representatives of the Military Departments and chaired by DDR&E. Representatives from OASD-I&L, OASD-Comptroller, and the Defense Communications Agency, and NASA also participated. The author [David Fischer] acted as technical advisor... This trial set of characteristics was widely distributed by the Military Departments with a request that the recipients submit their own set of language requirements in response. Outside contractors, contacted by the individual offices that deal with them, responded overwhelmingly. The responses were first sent to Working Group representatives of the individual Departments for coordination within their departments and on to IDA. IDA’s task was to analyze, interpret, and resolve the responses into a consistent and unambiguous set of needed characteristics. In many cases, this involved direct consultation with individual contributors. The result was an extensive document which explained some of the implications, noted the trade-offs which were considered, and, in general, provided the ra tionale behind the listed characteristics. The whole process was then repeated. The revised document was distributed by the Services and, again, many thoughtful and helpful responses were received, processed, analysed, and reconciled by IDA. A revised version of the characteristics was then prepared. This set of requirements involved few major changes..."
The previous versions of Steelman were named:
Steelman was the final requirements document for the language design, which then went to an international competition. There were four entrants, which were called Green (from Honeywell and Jean Ichbiah), Red (from Intermetrics), Blue (from Softech), and Yellow (from Wirth and Pascal crew). Green won, and was renamed as Ada. "Ada: Past, Present, and Future" by Robert Dewar has some comments about this competition.
Ada did not fare as well as it could have, primarily because it cost far too much to get and use an Ada compiler. They were often orders of magnitude more expensive to buy, and typical PCs couldn't run them (you needed nonstandard memory cards just to load one). There were reasons for this. A strategic decision made in the early version of the Ada language, which I believe was a terrible mistake, was its rule that there would be no subsets and no supersets. Allowing arbitrary subsetting and supersetting would have been a problem, but having no subsets or supersets was an overly-strict rule. I think if there had been at least a standard subset without tasking, and perhaps a few other capabilities, early Ada would have fared much better. You can create standards with standardized subsets and supersets (I did that with OpenDocument OpenFormula), and that would have made Ada far more practical for the computers at the time. A subtle related problem was that people thought that because Ada was ambitious, it had to be hard to implement - a self-fulfilling prophecy. Too many of its early implementers didn't focus on making the implementations easy. The result was that while early Ada compilers were capable, they were also slow, big, and very expensive... and that severely hampered where Ada could be used in practice. Cost matters - failing to ensure that Ada compilers were affordable turned out to be a disastrous mistake.
After the language was standardized as Ada 83 its history becomes much easier to track. The Wikipedia article on the Ada programming language has much about its evolution. One part of Ada's history that perhaps was not so clear was that after its original release, Robert Dewar determined how to implement key Ada requirements in a more conventional way, resulting in a far smaller, far faster, and far less expensive Ada compiler. Indeed, Ada has been part of the GCC compiler since the 1990s, making Ada far more available.
You can get more information about the history of the Ada programming language in:
Feel free to copy Steelman On-Line, but if you use one of these electronic versions please give David A. Wheeler credit for doing the conversions to electronic media.
Please note that the comparison paper is copyright (C) 1996 David A. Wheeler. This paper is not endorsed by, and does not necessarily represent the views of Mr. Wheeler's employer, the U.S. Department of Defense (DoD), or the U.S. Government. You may copy it freely as long as credit is given to the author.
You are viewing version 1.2. This version corrects several small errors in the Steelman document and adds the paper comparing Ada, C, C++, and Java to the Steelman requirements. This version was originally posted on "Ada Home" when David A. Wheeler didn't have his own web site.
Version 1.1 added an ASCII-only version of the document, and changed the background color to white to make it easier to read. Minor corrections have been made (e.g. an extra paragraph break in requirement 1E has been removed and extra quotes in some sections have been removed) and some hypertext links have been added. It also adds the hypertext link to the short list of requirements.
Steelman was converted to HTML and other electronic media by David A. Wheeler.