Steelman On-Line

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.

Steelman's contents

You may view:

You can also see some comments on changes since then.

Steelman Table of Contents

  1. General Design Criteria
  2. General Syntax
  3. Types
  4. Expressions
  5. Constants, Variables, and Scopes
  6. Classical Control Structures
  7. Functions and Procedures
  8. Input-Output, Formating and Configuration Control
  9. Parallel Processing
  10. Exception Handling
  11. Representation and Other Translation Time Facilities
  12. Translation and Library Facilities.
  13. Support for the Language

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.

Ada, C, C++, and Java vs. The Steelman

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.

History of Steelman

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:

  1. Strawman: HOLWG, DoD, April 1975. This was the original draft. Strawman (for Ada) is available online. Arthur Evans Jr reports that there was a draft requirements document earlier than the "Strawman" document of mid-1975 but it got no responses. He said about Strawman: "Anyone even moderately competent at language design recognized that the requirements were self-contradictory and, given the then state of the art, vastly over ambitious; I said so. Later, I learned that Strawman had been deliberately written that way in order to elicit responses from people (like me) who were perfectly happy to point out how DoD didn't understand the problem, but who probably wouldn't otherwise have bothered replying. (Clever! I think Dave Fisher gets credit for that idea)."
  2. Woodenman: HOLWG, DoD, 1975 "Woodenman Set of Criteria and Needed Characteristics for a Common DoD High Order Programming Language", David A. Fisher, Institute for Defense Analyses (IDA) Working Paper, August 13, 1975. Woodenman (for Ada) is available online.
  3. Tinman: HOLWG, DoD, Jan 1976 This can be acquired as David A. Fisher, "A Common Programming Language for the Department of Defense - Background and Technical Requirements", Institute for Defense Analyses, Paper P-1191, AD-A028297, IDA Log Number HQ 76-18215, June 1976. Fisher's paper has not just the requirements but a great deal of background material and rationale, so Fisher's paper is 158 pages long. After Tinman came out, there was a conference at Cornell at which position papers were presented on it, published in: "Design and Implementation of Programming Languages", DoD Sponsored Workshop, Ithaca 1976, Lecture Notes in Computer Science #54, Springer-Verlag. Tinman (for Ada) is available online.
  4. Ironman: Ironman was issued in January 1977. Its requirements were substantially the same as Tinman but with a different format. An official reference for this document is: High Order Language Working Group, "Department of Defense Requirements for High Order Computer Programming Languages - IRONMAN", January 14, 1977. A reference which you can actually order is: David A. Fisher, "A Common Programming Language for the Department of Defense - Background, History and Technical Requirements", Institute for Defense Analyses, Paper P-1263, IDA Log Number HQ 77-19124, May 1977.
  5. Revised Ironman: Revised Ironman was issued in July 1977. An official reference for this document is: High Order Language Working Group, "Department of Defense Requirements for High Order Computer Programming Languages - Revised IRONMAN", July 1977. A more accessible version is "Department of Defense Requirements for High Order Computer Programming Languages", SIGPLAN Notices 12(12):39-54 (Dec 1977). Fisher did some work regarding numeric computation, and an appendix to that report includes the basic requirements of revised ironman. So a reference which you can actually order which has the requirements is: David A. Fisher and Philip R. Wetherall, "Rationale for Fixed-Point and Floating-Point Computational Requirements for a Common Programming Language" Institute for Defense Analyses, Paper P-1305, IDA Log Number HQ 77-19836, January 1978. Revised Ironman (for Ada) is available online.

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.

Early Ada documents including copies of Strawman, Woodenman, Tinman, Ironman, Steelman, and versions of the "Red" language are available from Mary S. Van Deusen.

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:

Credit and Legal Notices

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.

Version Information

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.