A Brief History of Computing

Origins and Development of Computer Systems

Early Computing Machines

The early computing machines were primarily devices for performing arithmetic calculations such as addition and multiplication.

The first generation of electronic computers

In the 1940's the first electronic computers were designed and implemented. These machines would typically fill an entire room and were constructed using thousands of vacuum tubes.

The Second generation: Transistor-based computers

In the last 50's, the transistor was used to replace vacuum tubes and computers became smaller, faster, and more reliable. The 60's saw the development of Very Large Scale Integration (VLSI) chips which contained hundreds of thousands of transistors.

The Third generation: Integrated Circuits, Mainframes, Minicomputers, and Operating Systems

The Fourth Generation: Personal Computers and Workstations

During the 80's, the personal computer market developed and personal computers became one of the fastest growing markets for computers.

The Fifth Generation: Supercomputers, Parallel Computers, Meta-computers

In the 80's, the supercomputer model was challenged by the parallel computation model, and this trend has continued into the 90's. A parallel machine consists of several moderately fast computers that are connected in some manner that allows them to work cooperatively on a single problem. The most common model of parallel computer these days consists of off-the-shelf workstations connected by an extremely fast network.

The late 90's: Embedded Computing and the World Wide Web

In the late 90's we are seeing the spread of computers into almost all objects we interact with. These smart devices have the potential to dramatically change the way we interact with our environment, for better or worse. The 90's have also seen the rise of the world wide web and in the early 00's we are seeing the web extending to mobile devices such as cell phones as well as high speed links into the home.

Origins and Development of Programming Languages

Origins of Programming Languages

The very first programming languages were machine languages. These are the "native tongues" of the Central Processing Units (CPUs). The words of this language are called machine instructions and consist of one or more bytes which represent a coded form of some primitive operation that the CPU can carry out. The next programming languages were the so called "assembly languages." These languages allowed users to write programs using symbolic representations of the machine instructions and these assembly programs could then be translated into machine language (i.e. coded bytes) either by hand or, better yet, by a program. Each assembly instruction corresponded precisely to one particular operation in the CPU's repetoire. The next group of languages allowed the programmer to work at a more conceptual level. Programs written in these higher level languages could be mechanically translated (either by hand or by a program) into assembly language, which could then be translated into machine language. Many of the first high level languages are still around today (albeit in a much evolved state). A few of the most influential high level languages are listed below: There are currently over 2000 computer languages. (A searchable list is maintained at http://cuiwww.unige.ch/langlist. Another interesting list of languages (kept by an enthusiast) is "http://www.heuse.com/coding.htm"). In the next several weeks we will study a dialect of Scheme which can be used to write applets.

Compilers and Interpreters

All of these high level languages must first be either translated into machine language (by another program called a compiler), or interpreted (by a program appropriately called an interpreter). For example, Fortran, C, and C++ are usually compiled into assembly language. Scheme is usually interpreted (but is sometimes compiled), while Java is compiled into a simpler intermediate language (called Java byte code) which is then interpreted (by a Java virtual machine).

For example, lets see how to write, compile, and run a simple C program. The first step is to create a file, say "test.c" containing the following lines:

#include <stdio.h>

int main(void) {
  int i=100;
  while (i>0){
    printf("   HELLO WORLD!\n");
    i = i - 1;
Next, one compiles the file (in Linux or Unix) by giving the following command
  % cc test.c -o test
The C compiler is stored in the file named "cc" and it reads the file "test.c" and creates a new file "test" (as specified using the "-o test" flag). This file contains machine language. We can run the program by giving the command "test" to the Linux shell:
  % ./test
        HELLO WORLD!
        HELLO WORLD!
        HELLO WORLD!
This program writes HELLO WORLD! one hundred times and then stops. Lets look more closely at what is happening here. First of all, your command "test" is read by the shell. Recall that the shell is the part of the operating system that prints the percent sign prompt (%) and then reads and executes the commands you type in. When you type in a command it looks for a file that has that name and then it loads that file into the memory and gives it temporary control of the CPU and sets a timer to go off in a few milliseconds at which point control will be taken away from your program and given back to the operating system program. The operating system then lets another program run for a few milliseconds. When your program stops, the operating system takes it out of its process queue, which is the list of "programs waiting to run." Also, when every your program needs to write to the screen, it gives the data that needs to be displayed to the operating system which then takes control of the CPU and displays the data.

An interpreter takes a different approach. It is a program which reads your program, analyzes it, "simulates its execution," gets an answer, and displays that answer. In this class we will be writing Scheme programs which are run by a Scheme interpreter written in Java.

Compilers and interpreters are usually themselves written in a high level language. If there already exists one compiler for the language, then it is easy to write a second one in that language. Compiler writers often write a first compiler for a new language L (in some existing language say C). They then write their second and later compilers for L in L itself. This process is called bootstrapping.


  1. A Brief History of Computer Technology: Generations
    -- from the Computational Science Education Project
  2. A Chronology of Digital Computing Machines (to 1952)
  3. Computers: History and Development -- Jones Telec. and Multimedia Encycl.
  4. "Modern Operating Systems," Andrew S. Tanenbaum, Prentice Hall, 1992.

Related Sites

  1. The ENIAC website at UPenn
  2. Charles Babbage Institute Center for the History of Computing
  3. the Virtual Museum of Computing at Oxford University
  4. Computers: From the Past to the Present
    by Michelle A. Hoyle, CS Grad Student at U. of Sussex
  5. Computer Programming Languages
    --- in the WWW Virtual Library
  6. Apple history .. other Applet History links