A Brief History of Programming Languages
September 1995 / 20th Anniversary / A Brief History of Programming Languages
We've come a long way from computers programmed with wires and punch cards. Maybe not as far as some would like, though. Here are the innovations in programming.
ca. 1946
Konrad Zuse , a German engineer working alone while hiding out in the Bavarian Alps, develops Plankalkul. He applies the language to, among other things, chess.
1949
Short Code , the first computer language actually used on an electronic computing device, appears. It is, however, a "hand-compiled" language.
1951
Grace Hopper , working for Remington Rand, begins design work on the first widely known compiler, named A-0. When the language is released by Rand in 1957, it is called MATH-MATIC.
1952
Alick E. Glennie , in his spare time at the University of Manchester, devises a programming system called AUTOCODE, a rudimentary compiler.
1957
FORTRAN --mathematical FORmula TRANslating system--appears. Heading the team is John Backus, who goes on to contribute to the development of ALGOL and the well-known syntax-specification system known as BNF.
1958
FORTRAN II appears, able to handle subroutines and links to assembly language. John McCarthy at M.I.T. begins work on LISP--LISt Processing.
The original specification for ALGOL appears. The specific ation does not describe how data will be input or output; that is left to the individual implementations.
1959
LISP 1.5 appears. COBOL is created by the Conference on Data Systems and Languages (CODASYL).
1960
ALGOL 60 , the first block-structured language, appears. This is the root of the family tree that will ultimately produce the likes of Pascal. ALGOL goes on to become the most popular language in Europe in the mid- to late-1960s.
Sometime in the early 1960s , Kenneth Iverson begins work on the language that will become APL--A Programming Language. It uses a specialized character set that, for proper use, requires APL-compatible I/O devices.
1962
APL is documented in Iverson's book, A Pro gramming Language .
FORTRAN IV appears.
Work begins on the sure-fire winner of the "clever acronym" award, SNOBOL--StriNg-Oriented symBOlic Language. It will spawn other clever acronyms: FASBOL, a SNOBOL compiler (in 1971), and SPITBOL--SPeedy ImplemenTation of snoBOL--also in 1971.
1963
ALGOL 60 is revised.
Work begins on PL/1.
1964
APL\360 is implemented.
At Dartmouth University , professors John G. Kemeny and Thomas E. Kurtz invent BASIC. The first implementation is a compiler. The first BASIC program runs at about 4:00 a.m. on May 1, 1964.
PL/1 is released.
1965
SNOBOL3 appears.
1966
FORTRAN 66 appears.
LISP 2 appears.
Work begins on LOGO at Bolt, Beranek, & Newman. The team is headed by Wally Fuerzeig and includes Seymour Papert. LOGO is best known for its "turtle graphics."
1967
SNOBOL4 , a much-enhanced SNOBOL, appears.
1968
ALGOL 68 , a monster compared to ALGOL 60, appears. Some members of the specifications committee--including C.A.R. Hoare and Niklaus Wirth--protest its approval. ALGOL 68 proves difficult to implement.
ALTRAN , a FORTRAN variant, appears.
COBOL is officially defined by ANSI.
Niklaus Wirth begins work on Pascal.
1969
500 people attend an APL conference at IBM's headquarters in Armonk, New York. The demands for APL's distribution are so great that the event is later referred to as "The March on Armonk."
1970
Sometime in the early 1970s , Charles Moore writes the first significant programs in his new language, Forth.
Work on Prolog begins about this time.
Also sometime in the early 1970s , work on Smalltalk begins at Xerox PARC, led by Alan Kay. Early versions will include Smalltalk-72, Smalltalk-74, and Smalltalk-76.
An implementation of Pascal appears on a CDC 6000-series computer.
Icon , a descendant of SNOBOL4, appears.
1972
The manuscript for Konrad Zuse's Plankalkul (see 1946) is finally published.
Denni s Ritchie produces C. The definitive reference manual for it will not appear until 1974.
The first implementation of Prolog -- by Alain Colmerauer and Phillip Roussel -- appears.
1974
Another ANSI specification for COBOL appears.
1975
Tiny BASIC by Bob Albrecht and Dennis Allison (implementation by Dick Whipple and John Arnold) runs on a microcomputer in 2 KB of RAM. A 4-KB machine is sizable, which left 2 KB available for the program.
Bill Gates and Paul Allen write a version of BASIC that they sell to MITS (Micro Instrumentation and Telemetry Systems) on a per-copy royalty basis. MITS is producing the Altair, an 8080-based microcomputer.
Scheme , a LISP dialect by G.L. Steele and G.J. Sussman, appears.
Pascal User Manual and Report , by Jensen and Wirth, is published. Still considered by many to be the definitive reference on Pascal.
B.W. Kerninghan describes RATFOR--RATional FORTRAN. It is a preprocessor that allows C-like control structures in FORTRAN. RATFOR is used in Kernighan and Plauger's "Software Tools," which appears in 1976.
1976
Design System Language , considered to be a forerunner of PostScript, appears.
1977
The ANSI standard for MUMPS -- Massachusetts General Hospital Utility Multi-Programming System -- appears. Used originally to handle medical records, MUMPS recognizes only a string data-type. Later renamed M.
The design competition that will produce Ada begins. Honeywell Bull's team, led by Jean Ichbiah, will win the competition.
Kim Harris and others set up FIG, the FORTH interest group. They develop FIG-FORTH, which they sell for around $20.
Sometime in the late 1970s , Kenneth Bowles produces UCSD Pascal, which makes Pascal available on PDP-11 and Z80-based computers.
Niklaus Wirth begins work on Modula, forerunner of Modula-2 and successor to Pascal.
1978
AWK -- a text-processing language named after the designers, Aho, Weinberger, and Kernighan -- appears.
The ANSI standard for FORTRAN 77 appears.
1980
Smalltalk-80 appears.
Modula-2 appears.
Franz LISP appears.
Bjarne Stroustrup develops a set of languages -- collectively referred to as "C With Classes" -- that serve as the breeding ground for C++.
1981
Effort begins on a common dialect of LISP, referred to as Common LISP.
Japan begins the Fifth Generation Computer System project. The primary language is Prolog.
1982
ISO Pascal appears.
PostScript appears.
1983
Smalltalk-80: The Language and Its Implementation by Goldberg et al is published.
Ada appears . Its name comes from Lady Augusta Ada Byron, Countess of Lovelace and daughter of the English poet Byron. She has been called the first computer programmer because of her work on Charles Babbage's analytical engine. In 1983, the Department of Defense directs that all new "mission-critical" applications be written in Ada.
In late 1983 and early 1984, Microsoft and Digital Research both release the first C compilers for microcomputers.
In July , the first implementation of C++ appears. The name is coined by Rick Mascitti.
In November , Borland's Turbo Pascal hits the scene like a nuclear blast, thanks to an advertisement in BYTE magazine.
1984
A reference manual for APL2 appears. APL2 is an extension of APL that permits nested arrays.
1985
Forthcontrols the submersible sled that locates the wreck of the Titanic.
Vanilla SNOBOL4 for microcomputers is released.
Methods , a line-oriented Smalltalk for PCs, is introduced.
1986
Smalltalk/V appears--the first widely av ailable version of Smalltalk for microcomputers.
Apple releases Object Pascal for the Mac.
Borland releases Turbo Prolog.
Charles Duff releases Actor, an object-oriented language for developing Microsoft Windows applications.
Eiffel , another object-oriented language, appears.
C++ appears.
1987
Turbo Pascal version 4.0 is released.
1988
The specification for CLOS -- Common LISP Object System -- is published.
Niklaus Wirth finishes Oberon, his follow-up to Modula-2.
1989
The ANSI C specification is published.
C++ 2.0 arrives in the form of a draft reference manu al. The 2.0 version adds features such as multiple inheritance and pointers to members.
1990
C++ 2.1 , detailed in Annotated C++ Reference Manual by B. Stroustrup et al, is published. This adds templates and exception-handling features.
FORTRAN 90 includes such new elements as case statements and derived types.
Kenneth Iverson and Roger Hui present J at the APL90 conference.
1991
Visual Basic wins BYTE's Best of Show award at Spring COMDEX.
1992
Dylan -- named for Dylan Thomas -- an object-oriented language resembling Scheme, is released by Apple.
1993
ANSI releases the X3J4.1 technical report -- the first-draft proposal for (gulp) object-oriented COBOL. The standard is expected to be finalized in 1997.
1994
Microsoft incorporates Visual Basic for Applications into Excel.
1995
In February , ISO accepts the 1995 revision of the Ada language. Called Ada 95, it includes OOP features and support for real-time systems.
1996
Anticipated release of first ANSI C++ standard .
Her HindSight and ForeSight Were Both 20/20
photo_link (36 Kbytes)
"It's better to ask forgiveness than it is to get permission."--The Late Rear Admiral Grace Hopper, who led the effort to create COBOL
The History of Programming Languages
For 50 years, computer programmers have been writing code. New technologies continue to emerge, develop, and mature at a rapid pace. Now there are more than 2,500 documented programming languages! O'Reilly has produced a poster called History of Programming Languages (PDF: 701K), which plots over 50 programming languages on a multi-layered, color-coded timeline.
How It Started
We first saw the "History of Programming Languages" diagram, created by Éric Lévénez, while visiting our French office. We were so taken with the level of detail and the visual impact of viewing 50 years of programming history that we wanted to come up with a way to share it more widely. We started big. We printed it out full-size, all 18 feet of it, on our plotter and ran it along a wall at our Mac OS X Conference last fall. So many people came by to make notations on the diagram that we knew there would be a lot more interest and discussion if we could only get it in a more manageable format. With Éric's permission, we collected comments from our authors, editors, and friends, and rebuilt the file so we could print it at its current dimensions, 39" x 17". Éric maintains a site with his original diagram, change logs, an explanation of how he creates his charts, and links to additional resources such as Bill Kinnersley's Language List of over 2,500 programming languages. Éric also has Windows and Unix historical diagrams that he makes available for non-commercial purposes, all at
Chapter5
Java and the Internet
by Dan Joshi
CONTENTS
- Java History
- Java's Place in the Object-Oriented Continuum
- Defining Java
- Java Applet Definition
- The Benefits of Java
- Java Is Object-Oriented
- Java Is Multithreaded
- Java Is Dynamic
- Java Is Compacted
- Java Is Marked and Swept
- Java Is Processor-Independent
- Java Is Verified
- Java Is a Multiplatform Environment
- The Negatives of Java
- Summary
This chapter gives a brief history of programming languages, from their earlier incarnations to today's modern languages, and provides a foundation of common understanding as to where Java fits in the scheme of things. This chapter is not just about the benefits of Java-it is about Java.
Java History
Structured programming was the 1960s' answer to the need for discipline in the computer programming industry, leaving spaghetti code for the history books. An excellent example of a structured programming language was Pascal, developed in 1971.
Object-oriented programming was invented to improve three things that structured programming languages lacked: the capability to "reduce, reuse, and recycle" code.
Since the birth of C++, object-oriented programming languages have become the standard by which modern programming languages are defined. Object-oriented (OO) programming languages such as C++ deal with user-defined types (UDT). UDTs are programmatic representations of objects. Programmers can reuse these objects throughout their program and in other programs.
The idea behind object-oriented programming is based on the logic of designing your code into objects and letting these objects communicate with each other through various object-based technologies. Before you can understand Java, you must understand objects; and before you can understand objects, you must understand the structured programming techniques upon which objects are founded. Object-oriented programming encompasses much more than described in this brief introduction. Many of these benefits won't be fully appreciated until you have had a chance to work with Java later in this book.
In real life we deal with objects every day. With objects we can have superobjects and subobjects. For example, a car is an object. A luxury sedan is a subobject to the object of a car, and a vehicle is a superobject to the object of a car. The concept that a car completely encapsulates the luxury sedan and that the vehicle completely encapsulates both of them helps to define what an object is. In another light, a car is a more specific representation than a vehicle, and a luxury sedan is a more specific object than a car. Thus, the car is a subobject to a vehicle and a luxury sedan is a subobject to the car. And if you can conclude that the luxury sedan is also a subobject to the vehicle, you would be correct. However, if the only vehicle you ever saw was a car, you would conclude that it would be redundant to add a subclass (that is, a more specific representation) of a car object because a car fully encompasses your definition of a vehicle.
This point brings out one of the most powerful and confusing attributes of object technology in the programming industry, which is that objects are defined. We must use our own perception of what is a subclass or superclass to another object. Even though this makes object-oriented programming difficult for most new people to understand, it is extremely powerful when you do understand it. In object-oriented programming, you get to make your own set of rules.
Before getting into more detail on the anatomy of objects, there is one other key feature of object-oriented programming to introduce. It is the capability of objects to contain both data and behavior that acts on that data. This grouping of both data (or attributes or properties) and behavior (which is represented in methods) helps to integrate your programs as opposed to conventional structured programming techniques, which separate the data-based code from the action-based code.
Objects usually contain properties. For example, the number of wheels a vehicle has is a property of the vehicle object. In order to better understand properties, let's design an acting model. The vehicle object, as defined in the preceding paragraph, is a superobject to the car object. The car object also can have properties; however, it would be inappropriate to give our car object the property of trunk size, for example, because not all cars have trunks (assuming your definition of a car includes hatchbacks). On the other hand, it would be appropriate to give the luxury sedan object a property of trunk size because all luxury sedans have some sort of trunk.
When you are assigning properties in your program, look for the highest class that would still be appropriate for the property. This follows the logic that the lower you go in a class hierarchy the more specific an object becomes. On the other hand, the higher you go in a class hierarchy the more abstract an object becomes.
Another important term used in object technology is method. Driving a car is an action; thus, driving could be considered, in "object jargon," a method to the car. A good way to understand a method is to think of it in terms of action. A method is always doing something. As mentioned earlier, methods can be appropriately and inappropriately placed depending on their location in the class hierarchy.
Object-oriented programming is simply another way of putting better logic into your program. Digressing into a more philosophical aspect of programming languages, here is a description of one of the most important components of the perfect programming language: Ideally, this language would be completely unrelated to computer science. The advantage of this is that anyone could sit down and use it without needing to know anything about computers and computer science. All a person would need to know to create a computer program would be his or her field of expertise. For example, an insurance broker would only need to know about his field to sit down in front of a computer and create a program that would make his job (hence his life) easier.
Unfortunately, such a language does not exist and probably won't be here any time soon. However, based on lessons learned in the history of programming languages discussed further in the next section, the object paradigm is probably one of the biggest steps toward this perfect language.
At its very core, object-oriented programming is simply a more powerful way to construct your code logically; using objects with properties and methods creates a more logical program.
Although most programming languages have many rules specific to each of them, the golden rule of all programming languages is this: Never write the same code twice. By having a more distributed program, you are more able to follow this golden rule of programming. Although most programmers would find it nearly impossible to reuse their code 100 percent of the time, object-oriented programming languages greatly improve the ability for anyone to reuse their code.
Now, imagine that you are a developer and you are writing a program called Alpha. You write this program in a structured programming language and compile it. Your program is successful, and your manager comes to you and says she wants an Alpha version 2.0.
At this point, you would usually need to modify the original program. Sometimes you can edit code that is already resident in the program. Other times you would need to write new code. Typically, you would need to do both: edit old code and write new code. However, it is also likely that, due to the nature of the changes for version 2.0, you will need to dissolve the old program and redesign it from the ground up.
Now imagine that you are an object-oriented programmer, and you are asked to write the same program called Alpha. You create the program by building objects. Your code is more logical, is easier to understand, and typically also might be smaller. Thus, you are reducing the amount of time and code you spend developing the application. Now, when your manager says she wants Alpha version 2.0, instead of going into the code of the original program, you can take your original Alpha classes and "inherit" them into new classes that have added functionality for use with version 2.0. This object technology is called inheritance.