A Brief History of Programming Languages: From Fortran to C++ | Lab Reports Computer Science

Lab4

For this lab, you will edit this lecture on the history of programming

languages. Don't worry, you are not going to be tested on this lecture, and the

homework assignment at the end of the document does not apply to you. You only

have to format this file by following the instructions listed in lab.

----------------------------------------------------------------------

History of Programming Languages

Brian McNamara

Today's lecture will be a quick history of programming languages. Since 1957

when the first Fortran was introduced for the IBM 704, literaly hundreds of new

programming languages have come and gone--well, some of them have gone, and

others--like Fortran, have managed to stay around. The sheer number of

languages makes it impossible to cover them all in any depth--indeed, even the

most important languages we will only have time to discuss in shallow detail

today. As a result, we talk about only the most important languages--those that

had historical significance either for their new ideas or their influences on

the languages that followed them.

Let me admit, up front, that I am not a history buff. So why, you might ask, do

we waste a day on a "history lecture" at all, then? Well, there are two major

reasons. First, this lecture will give you a brief introduction to the handful

of languages we'll talk about in this course. Thus the short exposure to these

languages you get today will serve as the scaffolding onto which we'll learn

about language constructs and the languages to which they belong. Second, I

hope that in this discussion, especially of early languages, you'll gain an

appreciation for the historical contexts in which languages have been developed.

Things we take for granted today--like interactive machines, standard keyboards

and characters sets, etc., were (of course) not always around, and it is

interesting to see how issues that no longer matter today played important roles

back then. By understanding the differences between the historical contexts in

which different languages were created, only then can we appreciate that we are,

today, right now, framed in a computing context that, when viewed from 20 or 30

years from now, will probably seem like we are focusing on issues of perhaps

trivial importance, and missing some big issues.

So, those goals in mind, let's talk about history. On page 39 of your book,

there's a beautiful picture showing a timeline of languages, with a dot for each

major language, and lines connecting languages that influenced other ones. Had

I made any overheads for today, this would have been the primary one. (As I

mentioned; I'm a little disorganized this week; by next I'll have some slides

prepared before lecture.) I'm going to talk about a few of these languages and

draw part of that diagram on the board; you needn't copy it as it's right from

your textbook.

Fortran

Computing in 1957 was largely scientific number crunching. Much hardware

supported either integer operations, which floating point could be simulated on,

or only floating point operations. IBM introduced its new IBM 704, which

supported both integer and floating point operations, and this is the language

on which the first successful programming language, Fortran, was built.

Partial preview of the text

Download A Brief History of Programming Languages: From Fortran to C++ and more Lab Reports Computer Science in PDF only on Docsity!

Lab For this lab, you will edit this lecture on the history of programming languages. Don't worry, you are not going to be tested on this lecture, and the homework assignment at the end of the document does not apply to you. You only have to format this file by following the instructions listed in lab.

History of Programming Languages Brian McNamara Today's lecture will be a quick history of programming languages. Since 1957 when the first Fortran was introduced for the IBM 704, literaly hundreds of new programming languages have come and gone--well, some of them have gone, and others--like Fortran, have managed to stay around. The sheer number of languages makes it impossible to cover them all in any depth--indeed, even the most important languages we will only have time to discuss in shallow detail today. As a result, we talk about only the most important languages--those that had historical significance either for their new ideas or their influences on the languages that followed them. Let me admit, up front, that I am not a history buff. So why, you might ask, do we waste a day on a "history lecture" at all, then? Well, there are two major reasons. First, this lecture will give you a brief introduction to the handful of languages we'll talk about in this course. Thus the short exposure to these languages you get today will serve as the scaffolding onto which we'll learn about language constructs and the languages to which they belong. Second, I hope that in this discussion, especially of early languages, you'll gain an appreciation for the historical contexts in which languages have been developed. Things we take for granted today--like interactive machines, standard keyboards and characters sets, etc., were (of course) not always around, and it is interesting to see how issues that no longer matter today played important roles back then. By understanding the differences between the historical contexts in which different languages were created, only then can we appreciate that we are, today, right now, framed in a computing context that, when viewed from 20 or 30 years from now, will probably seem like we are focusing on issues of perhaps trivial importance, and missing some big issues. So, those goals in mind, let's talk about history. On page 39 of your book, there's a beautiful picture showing a timeline of languages, with a dot for each major language, and lines connecting languages that influenced other ones. Had I made any overheads for today, this would have been the primary one. (As I mentioned; I'm a little disorganized this week; by next I'll have some slides prepared before lecture.) I'm going to talk about a few of these languages and draw part of that diagram on the board; you needn't copy it as it's right from your textbook. Fortran Computing in 1957 was largely scientific number crunching. Much hardware supported either integer operations, which floating point could be simulated on, or only floating point operations. IBM introduced its new IBM 704, which supported both integer and floating point operations, and this is the language on which the first successful programming language, Fortran, was built.

The idea for FORTRAN had been in the works for some time. The language compiler was advertised as one that would generate object code that was as efficient as hand-coded machine code, but the ease of the existing interpretive pseudo-code systems. Amazingly, FORTRAN did just that, and a new era of programming was born. What was the language like? FORTRAN could use variables whose names were up to six characters long. It had both integers and floating point variables (based on the name: I-N integers). It had formatted input and output statements, to read and write data. It had an arithmetic IF statement, which compares two numbers and then branches to one of three locations depending on less than, greater than, or equal to. And it had an iterative DO loop which would count from one number to another. All of the control statements in the language mapped directly into single instructions in the hardware of the IBM 704. Largely due to support from IBM, FORTRAN was the most used language in computing for the next 25 years or so. It was revised in 1977 and again in 1990, adding lots of modern features to the language (like type declarations and if-then- else). LISP A couple years later, on the complete other end of the spectrum came LISP. LISP was a dynamic, interpreted language. It features data stored in linked lists (that was garbage collected) and programs that were represented just as data--in lists. A list like (A B C) could be treated as data, or as a function call A(B,C). LISP was functional-there were no variables or destructive assignment. Scheme and Common LISP are the main dialects that survive today. Algol In the late fifties, the computing world was interested in creating a "universal language" for programming. FORTRAN was the only existing contender, but it was IBM property. The ACM in the US, and GAMM in Germany both decided to form committees to create a machine-independent, universal language. The committees got together in 1958 and drafted the first version of Algol. Two years later after some expirimentation and suggestions, another meeting was held, and Algol 60 was born. Algol 60 is arguably the most influential language of all time. Among the contributions of Algol to the computing world: variable := expression blocks (begin-end pairs which are modules and scopes) two different parameter passing mechanisms (value and name) stack-dynamic arrays type declarations if-then-else with compound statements (no labels) the FOR loop (without labels) context-free grammars as a method for describing a language Algol was never used as much as Fortran, but for about 25 years it was the language to communicate algorithms. Pick up Communications of the ACM (show magazine) in the 1960s and you'd see Algol everywhere. COBOL

Ada is the result of the largest language design ever. It was contracted by the US Department of Defense as a language which embedded systems could be reliably and efficiently programmed. A long series of requirements docs were made for Ada, and then four companies designed languages, and the best was chosen. The first Ada compiler took years to develop--it was written in Ada. Ada contributed packages as a way to encapsulate data objects and specify data types. Ada provides good exception handling facilities, for detecting and recovering from software and hardware exceptions. Ada has generics, which allow code to be reused with many different data types. Ada also provides a decent concurrency mechanism. Ada was heavily influenced by Pascal. A recent revision, Ada 95, has OO. C++ C++ was created as an extension to C to support OO. It was designed to be compatible with C and as efficient as it. It was also designed with the intent to provide a transition path for programmers moving from traditional structured programming to OO programming. C++ included public/private access, multiple inheritance, constructors and destructors, and operator overloading. Leveraging off the success of C, C++ became a popular commercial language. Eiffel Eiffel was designed as a language with expressivity and power equal to C++, but with much greater readability and writibility due to simplicity and single- minded design in the language. Eiffel also includes the idea of enforcing assertions via interface contracts. Commercial issues have prevented Eiffel from becoming a major success.

Homework

At some point you should read chapters 1 and 2 of the book, but this weekend, you should really read chapter 3, in order to make next week's lectures more understandable. Those of you who have either had 2430 very recently or have had 3156 will find next week's material familiar, as it talks about context-free grammar. Sometime after next Monday morning, but before next class, take ten minutes to examine the material on the class web page. There will be a short quiz Tuesday which I will use to verify that you visited the web page. Fortran (1957) | \ LISP (1959) |
| Algol (1960) COBOL (1960) \ | | \ / | | \ / ______| \ | /
| | PL/I (1964) ---------------- | | \ | | BASIC (1965) SIMULA (1967) | | / | \ | | / | \ Algol (1968) | / | \ |

Pascal (1972) / | \ C (1972) | / | _____ | | | | \ | | | Smalltalk (1980) \ | | | \ | Ada (1983) | \ | \ | \ | \ | C++ (1985) \ | Eiffel (1990)

A Brief History of Programming Languages: From Fortran to C++, Lab Reports of Computer Science

Related documents

Partial preview of the text

Download A Brief History of Programming Languages: From Fortran to C++ and more Lab Reports Computer Science in PDF only on Docsity!

Homework