HISTORY OF COMPUTERS AND PROGRAMMING LANGUAGES

A web site with good information about the discussed topics is: http://en.wikipedia.org

Milestones in the 30’s

1936

Konard Zuse, German engineer, built the first computer called the Z1 using metals strips and pins.

This computer was programmable. The programs were stored on punched tapes. The tapes that were punched were discarded films. Key points of the Z1 were that it was binary, programmable and used floating point numbers. Zuse improved his design and created improved versions of it called the Z2, Z3 and Z4.

Zuse had to flee to Bavaria b/c of the war and his designs never became commercially implemented.

Milestones in the 40’s

1946

Conrad Zuse invented the first programming language called Plankalkul. This language had many features that are found in today’s high level programming languages. Examples of these are assignment statements, loops, conditionals, subroutines, and user defined types. His language allowed algorithms to be described that were completely independent of machine architecture.

(See Picture 1)

Zuse wrote a large number of algorithms in Plankalkul, from sorting to chess playing.

There was no way to implement the algorithms above as they were well beyond the capacity of the Z4 hardware.

Zuse’s work largely went unnoticed and unpublished. Other computer hardware designers and language creators used his ideas, but they just happened to create them independently after Zuse did.

(Interesting side note: Zuse died in 1995. In 1967 Zuse also suggested that the universe itself is running on a grid of computers (digital physics). His ideas are in a book called Calculating Space published in 1970. A web site with good information about Zuse is: http://en.wikipedia.org/wiki/Konrad_Zuse

1944

The first commercially viable computer the Harvard Mark I, developed by IBM, was built. Progammers ( at that time they were called “coders”) , typed their programs in using machine language. These programs were written in octal. These programs used absolute memory references. As a consequence, generic subroutines had to be rewritten every time the code was reused. This code was rewritten to reflect the absolute memory addresses that the application required.. A famous woman programmer,Grace Murray Hopper, was one of the “coders” for the Mark I (See Picture 2)

Milestones in the 50’s

Early 50’s

Assemblers were invented. Speeded up programming greatly. Mnemonics like ADD and MUL were substituted for octal codes, symbolic address(i.e. varaible names) were referenced instead of absolute addresses.

Grace Murray Hopper invented subroutine libraries (Named A-0 and A-2). With these libraries, an assembler programmer could call a subroutine in their code, and using macro expansion, the subroutine call would be replaced by the code in the library when it was translated into machine code. She also suggested that computers could also be used for data processing as well as mathematical calculations. She suggested that a language to do data processing be very English like so that non-mathematical people could program in the language. However, she found it difficult to convince others to explore this idea further.

People started to see the importance of saving coding time. Machines were getting faster, but the human “coders” were not. In response to that, John Backus invented speedcoding. With speedcoding, the programmer could write their code for a “virtual machine”. Such languages had more features than assembler language andn this allowed coding to go faster. However ,these languages were interpreted, and ran 5 to 10 times slower than their machine language counterparts.

Late 50’s

John Backus invents Fortran (Formula Translating System)(1955). This language had variable names, assignments, array subscripting, procedures, the Do while loop, and procedures that could be compiled seperatly (thus saving tons of compile time on a large program that had a change in only one procedure).The early versions of Fortran did not have recurssion, by reference parameter passing, arrays larger than three elements b/c of implementation difficulties.

(See Picture 3)

John Backus and his development group, not only created the language Fortran, but they created the methodlogies that are in use today to write compilers.

It was said that Plankalkul was designed and never implemented, and Fortran was implemented and not designed.

Some commands in the early versions of the Fortran language were very machine specific, thus producing many dialects of the language. Recent versions of Fortran, which are very much in use today, still have dialects to exploit features associated with specific machine architectures This exploitation results in even higher speed numerical computations.

Fortan was in heavy commercial use by the late 1950s.

(Interesting side note: John Backus also aided in the development of BNF notation, which is still used to describe language syntax.)

See http://en.wikipedia.org/wiki/Fortran#Sample_program for an example Fortran program.

In Darmouth, an organized workshop on artifical intelligence(1956) was conducted and many of the “heavy hitters” in the computing field attended that workshop. At the workshop, a noncommercial language was presented called IPL which could automatically prove theoroms of prepositional logic. This language supported the concept of a linked list, but was heavily tied to a specific machine architecture.

(See Picture 4)

This demonstration caught the eye of John McCarthy who used the linked list ideas from IPL,the conditional idea from Fortran, and his own version of recurrsion to create the first AI programming language Lisp.(1958).

Lisp still remains the most popular language for AI programming.

See: http://en.wikipedia.org/wiki/Lisp_programming_language#Example_programs

for examples of Lisp.

Grace Murray Hopper’s idea of using a computer for data processing took off and a language called FLOW-MATIC was invented by UNIVAC for their computers. At that time it was said that such a language would be “The electronic mechanization of accounting”.

In the late 50’s lots of programming languages were being invented both in America and in Europe. Europe came up with the idea of developing one universal international machine independent language for expressing scientific algorithms. A group in America followed suit right after that, and in 1958 the two groups came together to create the internationally developed Algol 58 (followed by Algol 60 and Algol 68).

Even though Algol is not in use today and did not catch on commercially, it was still not a wasted efforts. All languages created after 1958 seemed to use some of Algol’s features. Also, Algol was the universal language used to express algorithms in scholarly scientific journals for more than 20 years.

Some of the innovative features that Algol first presented were:

The use of keywords to bracket a statement: begin…end

Arrays whose size could be determined and modified at runtime

Format free syntax where there wasn’t rigid columns that held certain

parts of commands.

Static typing

The elimination of the GO TO to change flow of control. A huge controversy arose from this at the time. However, the GO TO lost. Nowadays it is not even debatable that a program is more structured and readable if it does not use a GO TO.

No arbitrary limits that amount to tons of special cases that a programmer has to remember. Algol is very orthogonal and allows every meaningful combination of primitive concepts.

IBM began an implementation of Algol 58 but abandoned it to concentrate on Fortran. . However, Algol was used as the basis for Jovial which was the scientific programming language for the airforce for many years.

The reasons why Algol did not catch on were many. One, it never obtained big corporate backing. Two, it was perhaps too new and strange to programmers who prefered to stick with a language they knew. Three, there were implementation difficulties (ie.verifying that the machine code produced by the compiler was indeed what the programmer had in mind.)

See: http://en.wikipedia.org/wiki/ALGOL for examples of Algol.

Milestones in the 60’s

Algol influenced the development of the Simula languages in the 60’s. Simula I and Simula 67. These languages were developed by Norwegians Kristen Nygaard and Ole-Johan Dahl. (See Picture 5)

Simula I was a language that was used to describe simulations (ex. Airplanes landing and taking off at an airport. Customers arriving and being served at a bank…etc…)

Simula I showed the beginings of an object orientation. (Example a simulated object like a customer could be created (instantiated) . A customer would have instance varaibles that would describe them, and methods that would service them)

Simula 67 became even more object oriented (introducing the terms class and object, and having an organized scheme for inheritance). Simula 67 also added constructs to make it a more general purpose language.

See: http://en.wikipedia.org/wiki/Simula for examples of Simula.

COBOL’s development was initiated by the DOD. It’s original name was CBL but then it was changed to COBOL ’60.

When COBOL was designed, it was designed to be very English-like and easy to use so that non-computer people could program in this language. The language design was done quickly to beat other companies that also recognized that computers could be use for data processing. Up until the 90’s, COBOL was hands-down the dominant language in the data processing field.

See: http://en.wikipedia.org/wiki/Cobol for examples of COBOL code.

BASIC was invented in the 60’s. It is the first language of many older programmers today. It was designed in Darmouth to teach liberal arts students how to program. Key feature was that it should be very easy to learn, and easy to debug (clear error messages, fast turnaround everytime a program was executed).

This was one of those languages that considered programmer’s time as valuable. People saw that computers were becoming faster, so they needed to start thinking about how they can make it faster for programmers to write code. The design of BASIC was influenced by Fortran and Algol.

See: http://en.wikipedia.org/wiki/BASIC_programming_language for examples of BASIC code.

LANGUAGE CLASSIFICATIONS and

IMPLEMENTATION METHODS

(See Handout for Language Classifications and Implementation Methods)

Language Classifications

Languages can be put into different families. However, some languages straddle families while others are so unique it is pointless to assign them to a family. The four major families that a language can be in are:

Imperative

Functional

Logical

Object Oriented

The language one chooses for an application determines the particular style of programming that one will use to solve a problem. For example, is one chooses an object oriented language to solve a problem, the programmers will make heavy use of the object concept when designing the solution. If one chooses a logic language, the application solution will be thought of in terms of searches.

A language will favor a particular programming style. However, it is possible to program in a style not favored by the language but it is not a good idea. For example you can use object oriented techniques in an imperative language, but they have to be simulated.

Imperative languages

Assignment

Iteration

Order of operations is critical

Functional Languages

Single values variables

Heavy use of recursion

Logic Languages

Program expressed as rules in formal logic

Object-Oriented Languages

Imperative Languages + more

Constructs to help programmers use “objects” – little bundles of data that

know how to so things to themselves.

Computer Architecture

Most languages have been designed around the VonNeuman architecture

The languages that run most efficiently on this architecture are imperative languages. Logic and functional languages do not run as efficiently.

Implementation Methods

Machine Language is the language that most hardware systems understand.

The operating system of a computer supplies higher primitive than those of machine language.

Compilation

When a language is compiled, the code produced will be machine language instructions plus calls to OS routines.

A compiler turns the computer into a “virtual computer”. This means the computer appears to understand the language being used. However, it is the compiler that creates this illusion.

The compiler produces machine code by going through the phases as described in the handout. However, once a program is compiled, it must go thorough the linker and the loader before it can be executed.

Once the machine code program is loaded into memory, it goes through the execution cycle: fetch decode execute.

Pure Interpretation

This is different than compilation. No machine code is produced. The interpreter program reads and deciphers each line of source code, then calls appropriate routines within the interpreter software to carry out the instruction. Programs that are interpreted run 10 to 100 times slower than compiled programs.

For example one could have an interpreter written in C++ that is interpreting instructions in a language will call X. The interpreter (i.e. the C++ code) will read a line of code in the language X, then the interpreter (i.e. C++ code ) will figure out what the line of X code means. After that, C++ code will execute to carry out the instruction in line X. If the instruction in line X is within a loop, that instruction must be “re-interpreted” (i.e. deciphered) every time the loop goes around. This creates slow execution times!!!!

Hybrid Implementation Systems

In a system like this, it starts out like a compiler. However. once it gets to the intermediate code stage, it stops there and machine code is not produced. This intermediate code is then interpreted. This results in programs running faster than in pure interpreted programs. This system independent generic “machine-like” code called intermediate code is named byte code in Java.

For example, one could have a hybrid implementation written in C++ that hybrid-interprets instructions in a language will call X. This interpreter (i.e. the C++ code) reads the lines of code in the language X and produces their equivalents in intermediate code. Once all the intermediate code has been produced, the hybrid-interpreter (i.e. the C++ code), then goes through each line of the intermediate code, figures out it’s meaning* ,then calls a C++ routine to execute the intermediate code instruction.

* A much simpler task than in a pure interpreted language b/c a line of intermediate code has only one action per line.