Programming Languages and Software practice are always engaged in a game of leapfrog: a forward looking programming language introduces new ways of thinking about software development, and its constructs shape the way programmers think about their craft; creative programmers invent new idioms and patterns to tackle ever more complex programming tasks, and these idioms become incorporated in the next generation of programming languages.

The latest version of Ada, whose description we owe once again to the inimitable expository talents of John Barnes, has exemplified this dynamic repeatedly over the last 30 years.

• • Ada 83 showed programmers how programming in the large should be organized (packages, strong typing, privacy) and convinced them that indices out of range were not a common pitfall of programming but elementary errors that could be controlled with proper declarations and constraint checking. Ada 83 also put concurrent programming in a mainstream programming language.

• • Ada 95 benefited from a decade-long development in object-oriented programming techniques, and successfully grafted the ideas of polymorphism and dynamic dispatching onto a strongly-typed language with concurrency. It enhanced programming-in-the large capabilities with child units and their generic incarnations.

• • Ada 2005 showed how data-based synchronization (protected types) and concurrency (task types) could be unified through a novel use of interface inheritance, and adopted a conservative model of multiple inheritance of interfaces that has proved more robust than the more unrestricted models of MI. Ada 2005 also introduced into the language an extensive container library, following here the example of other established languages and many earlier experimental high-level languages that showed the usefulness of reasoning over data aggregates.

And now – Ada 2012, the latest version of the language whose description you are holding, reflects both aspects of this dialectic process: it introduces new ways of thinking about program construction, and it reflects developments in software practice that hark back to the earlier days of our profession but that have seldom, if ever, found their way into well-established programming languages.

The general rubric for these new/old ideas is Programming by Contract. The term became well-known through the pioneering work of Bertrand Meyer and the design of Eiffel, but it probably found more significant use in the SPARK community, in the design of critical software for applications that require a real measure of formal verification for their deployment.