Programming languages' milestones: An overview from 1960 - present (Part 1)

Introduction

We are living in a world where computers and electronic devices play a pivotal part of our life. No one can alter the fact that wherever we go, whatever we do in this modern life, it is not hard to witness the appearance of them. Tiny handheld devices, sparkling traffic lights, even remotes we use regularly, etc. nowadays are the achievements of continuously developing information technology in many years. Back to twentieth century, one of the most remarkable technology events had been taken place, when the whole world was recovering from the wounds of the second World War, the first general-purpose computer became public with the name ENIAC (Electronic Numerical Intergrator and Computer). Although it was developed under wartime pressure, it has been of value not only in producing results but in pointing the way toward improvements for future designs (Brainerd and Sharpless, 1948) because general-purpose computers have the amazing property that a single piece of hardware can do any computation imaginable (Grant, Palmer and Smith, 2017). Before general-purpose computers were born, there had been special-purpose computers for arithmetic calculations, which had to be manually reconfigured to carry out different calculations such as Abacus – The earliest known device for calculation (Gujarat Education Department, n.d.).

In fact, to make computers and electronic devices as successful as today, the development of programming languages is the most important precondition. This part is going to be described briefly about several milestones during the great history of general-purpose programming languages and about a brief introduction of domain-specific languages.

General-purpose programming languages’ milestones

1. From early twentieth century to 1960

For general-purpose programming development, it predates the development of computers. In the early 20th century, logicians created their own programming languages originally springing from the concept of a proof system (Grant, Palmer and Smith, 2017). To illustrate this spirit, λ-calculus – an officially abstract language of functions in 1932 designed and implemented by Frege, Church and Curry was born. The λ-calculus provides a simple semantics for computations. One of the clearest example for this point of view is treating every function “anonymously”. After λ-calculus released, there is no reliable material pointing out the first general-purpose programming language, yet the most worth-noting programming language at that time was FORTRAN in 1956 because it was the first programming language equipped with a complete compiler (Backus 1956). Before FORTRAN, almost all programs were done in machine language or assembly language (Wexelblat, 2014). At that time, programmers considered their works as a complicated and creative art that required human inventiveness to produce an efficient program, therefore, FORTRAN was born to solve these problems with the support of index registers, built-in floating point operations, a wide range of instruction sets and primitive input – output arrangements. Since 1956, FORTRAN was developed with lots of variants, namely: FORTRAN II (1958), FORTRAN III (1958), FORTRAN IV (1962), FORTRAN 66 (1966), FORTRAN 77 (1977), Fortran 90 (1991, since this version, FORTRAN was renamed to be in lower-case form), Fortran 95 (1995), Fortran 2003 (2003), Fortran 2008 (2008). However, 2008 was not the last destination for the development of Fortran. According to Intel, Fortran 2015 will be released on July 2018 with up-to-date features, most of them extends the C interoperability features that first appeared in Fortran 2003. Several following years after the release of Fortran, in 1958, a miraculous product that was inspired and influenced by this programming language had been public – ALGOL 58 (Wexelblat, 2014). Basically, ALGOL 58 was developed by a father of Fortran – John Backus with the specific Backus normal form method of describing programming languages. Later, it was revised and expanded by Peter Naur for ALGOL 60, and at Donald Knuth's suggestion renamed Backus–Naur form (Knuth, 1964). Since ALGOL 60’s release, many other general-purpose programming languages were published and followed its spirit and paradigm such as Pascal, C (although C differs from most of ALGOL-like languages in some significant ways), etc. (Mitchell, 2003). As the code snippet illustrated, the most distinctive feature that differed ALGOL60 and Fortran was block-oriented control structures (i.e.: procedure, comment, begin, end) and variable scoping. Last but not least, during this period, the use of computers for business applications began. “Special computers were developed for this purpose, along with special languages. The first successful high-level language for business was COBOL” (Sebesta, 2012). This general-purpose programming language was designed for business applications programming, therefore, its domain primarily applied in business, finance, and administrative systems for companies and governments. According to Mitchell, COBOL is still widely used in legacy applications deployed on mainframe computers, such as large-scale batch and transaction processing jobs. Actually, most programming in COBOL is now purely to maintain existing applications (2006). According to Yatsko and Suslow, the 1950s – 1960s are known as a period of exploiting machine power (2015). Never before has humanity seen a such powerful and innovative revolution of programming languages. Among these brilliant programming languages, as mentioned above, three first and most significant general-purpose programming languages that affect mostly to later generations of languages are FORTRAN, ALGOL and COBOL. In spite of the fact that, each of them was designed to be used in a particular business domain, they were still considered general-purpose languages. A scientific application can still be written in COBOL or a business application with FORTRAN (Dearle, 2015).

2. From 1960 to 1970

According to Wegner, the period from 1960 to 1970 was a period of elaboration of programming languages developed in the 1950’s and of analysis for the purpose of constructing models and theories of programming languages (1976). Among all programming languages that were released during this time (such as PL/I, Simula 67, ALGOL 68 and Snobol 4), PL/I was the most remarkable programming language. Discussing about PL/I, Wegner added: “An attempt to combine the good features of FORTRAN, ALGOL, COBOL and other programming languages created in 1950’s”. In fact, Pugh, Johnson and Palmer have pointed out some major goals for PL/I at that time:

  • Competitiveness with COBOL's record handling and report writing capabilities was needed.
  • The "scope of usefulness" of the language grew to include system programming and event-driven programming.
  • Competitiveness with FORTRAN in performance of compiled code.
  • Be extensible for new hardware and application areas (However, this goal was not achieved later then).
  • Improve the productivity and time scales of the programming process, transferring effort from the programmer to the compiler.
  • Be machine-independent and operate effectively across the main hardware and operating system ranges. (To be continued...)

References

  1. Backus, W., J. (1956). The Fortran Automatic Coding System for the IBM 704 EDPM.
  2. Brainerd, G. J., Sharpless, T. K. (1948). The ENIAC.
  3. Grant, M., Palmer Z., Smith S. (2017). Principle of Programming Languages.
  4. History and Evolution of Computers (n.d.). Government of Gujarat – Education Department. Retrieved April 4, 2017 from http://gujarat-education.gov.in/textbook/Images/std9_sem_1/computer_studies9/chap2.pdf
  5. Knuth, E., D. (1964). Backus normal form vs. Backus Naur form.
  6. Mitchell, C., J. (2003). Concepts in Programming Languages.
  7. Mitchell, L., R. (2006). Cobol: Not Dead Yet. Retried April 10, 2017 from http://www.computerworld.com/article/2554103/app-development/cobol--not-dead-yet.html
  8. Pugh, W., E. & Johnson, R., L. & Palmer, H., J. (1991). IBM's 360 and Early 370 Systems.
  9. Sebesta, W., R. (2012). Concepts of Programming Languages (10th ed).
  10. Wegner, P. (1976). Programming Languages – The first 25 years.
  11. Wexelblat, L., R. (2014). History of Programming Languages.
  12. Yatsko, A. & Suslow, W. (2015). Insight into Theoretical and Applied Informatics: Introduction to Information Technologies and Computer Science.