Hundreds of programming languages have been designed in the last sixty years, and many of which are still widely used. There is a consensus that constructing nontrivial pieces of software is a very complex endeavor: it involves problem analysis, documentation issues, program design, software implementation, and testing. In addition, in software development processes there is no substitute for experience, simplicity preference, programming expertise, intelligence, and, most of all, the expressive power of the programming language that supports each implementation process. It is also widely accepted that the most effective way of taming programming complexity is through a divide- and-conquer approach, which requires adequate programming notation to represent the software components that naturally arise from this process, which, in general, requires the definition of mappings from real-world entities to program objects. Moreover, in order to simplify the needed programming code, since the early times, each programming language in use reveals a portion of the continuous effort to shorten the semantic gap between the real-world and the programming environment. In particular, most languages have been designed to adequately address specific advances in implementation methodologies and associated development practice.

This talk intends to highlight the most relevant advances in the design of programming language constructs and their associated attempts to model important software development demands. Chronologically, since the creation of Fortran to modern times, it also positions, in a line time, the linguistic responses that have been devised to cope with each methodological demand. The goal of this discussion is to exhibit and explain how some currently available system programming environments were constructed and set up the basis for envisioning and anticipating the next steps in the language design process to meet recent methodological advances.