A Brief History of Computing

Xmas Lecture

Prof. Dr. Jörg Schäfer

23 December, 2010

Prologue 3
Disclaimer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Famous (Computer) Scientists Quotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Famous (Computer) Engineers Quotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

A Brief History of Computers 7

Stonehenge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... . 8
Abacus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... . 9
Al-Chwarizmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 10
Leonardo da Vinci. . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 11
Pascaline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 12
Leibniz 01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 13
Charles Babbage’s Difference Engine . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 14
Charles Babbage’s Analytical Engine . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 15
The First Programmer . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 16
Inspiration for Cyberpunk . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 17
Inspiration for Steampunk . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 18
Power (Jacquard) Looms . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 19
IBM, formerly known as Hollerith . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 20
Konrad Zuse – Z1. . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 21
Alan Turing [Tur01] . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 22
John von Neumann [Neu45] . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 23
Von Neumann Architecture . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 24
Grace Hopper. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 25
The First Bug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 26
Analog Computers . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 27
Other Analog Computers . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 28
Moore’s Law . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 29
Unix [RT74]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 30
Macs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 31
PCs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 32
Ubiquitous Computers . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 33
Quantum Computing. . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . .. . .. . . .................... 34

A Brief History of Programming Languages 35

Why are Languages Important?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Languages as Tools for Thinking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Language Evolution. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1940s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1940s cont. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Machine Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
1950s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
1950s cont. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

1
 Assembly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 44
Fortran – I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 45
Fortran – II . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 46
Algol68 – I. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 47
Algol68 – II . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 48
Lisp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 49
1960s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 50
1960s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 51
Basic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 52
Cobol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 53
1970s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 54
1970s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 55
Hackers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 56
C................................ . . . . . . . . . . .. . . .. . .. . . .. . . ................ 57
Prolog. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 58
Smalltalk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 59
1980s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 60
1980s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 61
C++ – I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 62
C++ – II. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 63
Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 64
1990s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 65
1990s cont. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 66
1990s cont. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 67
Haskell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 68
Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 69
2000s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 70
MapReduce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 71
Summary: Programming Languages’ Paradigms . . . . . . . . . . .. . . .. . .. . . .. . . ................ 72
Interpretation of Paradigms . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 73
Shooting Yourself . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 74
Programming Languages as seen by Fans . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 75
Languages as Tools for Programming. . . . . . . . . . . . . . . . . . .. . . .. . .. . . .. . . ................ 76

A Brief History of Networks 77

The World is Connected . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
The Power of the Network . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

A Brief History of Applications 80

Important Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

A Brief History of Computer Scientists and Engineers 82

Famous Computer Scientists and Engineers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

A Brief History of Challenges 84

Different Disciplines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. 85
Speaking Different Languages – Example I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. 86
Speaking Different Languages – Example II . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. 87
What can we Compute?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. 88
How to deal with Complexity? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. 89

Outlook 90
The Future of Computing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

Appendix 92
References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Credits – I/III. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Credits – II/III . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Credits – III/III. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

2
 Content
Prologue
A Brief History of Computers
A Brief History of Programming Languages
A Brief History of Networks
A Brief History of Applications
A Brief History of Computer Scientists and Engineers
A Brief History of Challenges
Outlook
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 2 / 96

Prologue 3 / 96

Disclaimer

The following slides contain an entirely

subjective view of (computer) history!
Due to laziness, some notes contain Wikipedia as a “reference” – please consider this as an anti-pattern and
never use Wikipedia as a “reference” in any serious scientific report!
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 4 / 96

3
 Famous (Computer) Scientists Quotes
Computer science is no more about computers than astronomy is about telescopes.
Edsger Dijkstra
Computer science also differs from physics in that it is not actually a science. It does not study natural
objects. Neither is it, as you might think, mathematics; although it does use mathematical reasoning pretty
extensively. Rather, computer science is like engineering; it is all about getting something to do something,
rather than just dealing with abstractions, as in the pre-Smith geology.
Richard Feynman, Feynman Lectures on Computation, 1970
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 5 / 96

Famous (Computer) Engineers Quotes

I think there is a world market for maybe five computers.
Thomas Watson, Chairman of IBM, 1943
There is no reason anyone in the right state of mind will want a computer in their home.
Ken Olson, President of Digital Equipment Corp, 1977
640k is enough for anyone, and by the way, what’s a network?
William Gates III, President of Microsoft Corporation, 1984
The most profound technologies are those that disappear: they weave themselves into fabric of everyday life
until are indistinguishable from it.
Mark Weiser, The Computer for the 21st Century, Scientific American, 1991
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 6 / 96

4
A Brief History of Computers 7 / 96

Stonehenge

←Stonehenge

−100 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 8 / 96

Stonehenge is a prehistoric monument located in the English county of Wiltshire,

about 3.2 kilometres (2.0 mi) west of Amesbury and 13 kilometres (8.1 mi) north of
Salisbury. Archaeologists had believed that the iconic stone monument was erected
around 2500 BC. (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 8

5
 Abacus

Used in many cultures including Egypt, Persia, Greek, Roman, Chinese, India, Japan, Native American, . . .
Abacus

−100 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 9 / 96

The abacus, also called a counting frame, is a calculating tool used primarily in parts
of Asia for performing arithmetic processes. The use of the word abacus dates before
1387 AD, when a Middle English work borrowed the word from Latin to describe
a sandboard abacus. The period 2700–2300 BC saw the first appearance of the
Sumerian abacus, a table of successive columns which delimited the successive orders
of magnitude of their sexagesimal number system. The use of the abacus in Ancient
Egypt is mentioned by the Greek historian Herodotus. During the Achaemenid
Persian Empire, around 600 BC, Iranians first began to use the abacus. The earliest
archaeological evidence for the use of the Greek abacus dates to the 5th century BC.
The normal method of calculation in ancient Rome, as in Greece, was by moving
counters on a smooth table. The earliest known written documentation of the
Chinese abacus dates to the 2nd century BC. Some sources mention the use of
an abacus called a nepohualtzintzin in ancient Mayan culture. This Mesoamerican
abacus used a 5-digit base-20 system. (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 9

6
 Al-Chwarizmi

Algorithms

−100 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 10 / 96

Abu Abdallah Muhammad ibn Musa al-Khwarizmi (c. 780 – c. 850) was a Persian
mathematician, astronomer and geographer, a scholar in the House of Wisdom in
Baghdad. Al-Khwarizmi’s contributions to mathematics, geography, astronomy, and
cartography established the basis for innovation in algebra and trigonometry. His
systematic approach to solving linear and quadratic equations led to algebra, a word
derived from the title of his 830 book on the subject, “The Compendious Book on
Calculation by Completion and Balancing”. On the Calculation with Hindu Numerals
written about 825, was principally responsible for spreading the Indian system of
numeration throughout the Middle East and Europe. It was translated into Latin
as Algoritmi de numero Indorum. Al-Khwarizmi, rendered as (Latin) Algoritmi, led
to the term “algorithm”. Some of his work was based on Persian and Babylonian
astronomy, Indian numbers, and Greek mathematics. When, in the 12th century,
his works spread to Europe through Latin translations, it had a profound impact on
the advance of mathematics in Europe. He introduced Arabic numerals into the
Latin West, based on a place-value decimal system developed from Indian sources.
(Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 10

7
 Leonardo da Vinci

Calculator

−100 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 11 / 96

Device for Calculation: An early version of today’s complicated calculator,

Leonardo’s mechanism maintains a constant ratio of ten to one in each of its 13
digit-registering wheels. For each complete revolution of the first handle, the unit
wheel is turned slightly to register a new digit ranging from zero to nine. Consistent
with the ten to one ratio, the tenth revolution of the first handle causes the unit
wheel to complete its first revolution and register zero, which in turn drives the dec-
imal wheel from zero to one. Each additional wheel marking hundreds, thousands,
etc., operates on the same ratio. Slight refinements were made on Leonardo’s orig-
inal sketch to give the viewer a clearer picture of how each of the 13 wheels can be
independently operated and yet maintain the ten to one ratio. Leonardo’s sketch
shows weights to demonstrate the equability of the machine. (Source: IBM)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 11

8
 Pascaline
In 1642 Blaise Pascal, at age 19, invented the Pascaline.

Pascaline

−100 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 12 / 96

The Pascaline, invented by Blaise Pascal in France in 1642, was a mechanical calcu-
lator that could add and subtract directly. Its introduction launched the development
of mechanical calculators in Europe first and then all over the world, development
which culminated three centuries later by the invention of the microprocessor devel-
oped for a Busicom calculator in 1971. Pascal spent three years and went through
50 prototypes before presenting his first machine to the public in 1645. He dedicated
it to Pierre Séguier, the chancellor of France at the time. He built around twenty
more machines during the next decade, often improving on his original design. Nine
machines have survived the centuries, most of them being on display in European
museums. In 1649 a royal privilege, signed by Louis XIV of France, gave him the
exclusivity of the design and manufacturing of calculating machines in France. The
mechanical calculator industry owes a lot of its key machines and inventions to the
pascaline. First Gottfried Leibniz invented his Leibniz wheels after 1671 while try-
ing to add an automatic multiplication and division feature to the pascaline, then
Thomas de Colmar drew his inspiration from Pascal and Leibniz when he designed
his arithmometer in 1820, and finally Dorr E. Felt substituted the input wheels of
the pascaline by columns of keys to invent his comptometer around 1887. The pas-
caline was also constantly improved upon, especially with the machines of Dr. Roth
around 1840, and then with some portable machines until the creation of the first
electronic calculators. (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 12

9
 Leibniz 01

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 13 / 96

Gottfried Wilhelm Leibniz (July 1, 1646 – November 14, 1716) was a German
mathematician and philosopher. Leibniz invented the binary number system and
showed the connection with logic (De progressione Dyadica, 1679; oder Explication
de l’Arithmetique Binaire, 1703).
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 13

10
 Charles Babbage’s Difference Engine

Calculator

−100 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 14 / 96

Charles Babbage (26 December 1791 – 18 October 1871) was an English mathemati-
cian, philosopher, inventor, and mechanical engineer who originated the concept of
a programmable computer. He invented the Difference Engine, an automatic, me-
chanical calculator designed to tabulate polynomial functions. The Difference Engine
is not a general purpose computer rather a calculator. Later, he designed the Ana-
lytical Engine – a mechanical general purpose computer. The input (programs and
data) was to be provided to the machine via punched cards, a method being used
at the time to direct mechanical looms such as the Jacquard loom. Both machines
were never built during Babbage’s life time. (Source: Wikipedia and other sources)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 14

11
 Charles Babbage’s Analytical Engine

Computer

−100 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 15 / 96

The analytical engine, an important step in the history of computers, was the design
of a mechanical general-purpose computer by English mathematician Charles Bab-
bage. In its logical design the machine was essentially modern, anticipating the first
completed general-purpose computers by about 100 years. It was first described in
1837. Babbage continued to refine the design until his death in 1871. Because of
the complexity of the machine, the lack of project management science, the expense
of its construction, and the difficulty of assessing its value by Parliament relative
to other projects being lobbied for, the engine was never built. (Source: Wikipedia
and other sources)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 15

12
 The First Programmer

Augusta Ada King Byron, Countess of Lovelace

Program

−100 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 16 / 96

Ada Lovelace
! was the only legitimate child of the poet Lord Byron
! wrote programs for computers that did not (yet) exist such as the Analytical
Engine (e.g. computing Bernoulli numbers)
! is considered the first programmer in history

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 16

13
 Inspiration for Cyberpunk

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 17 / 96

Inspiration for Steampunk

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 18 / 96

14
 Power (Jacquard) Looms

We may say most aptly, that the Analytical Engine weaves algebraical patterns just as the Jacquard-loom weaves flowers
and leaves. (Lady Ada Lovelace)

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 19 / 96

The Jacquard loom is a mechanical loom, invented by Joseph Marie Jacquard in

1801, that simplifies the process of manufacturing textiles with complex patterns
such as brocade, damask, and matelasse. The loom is controlled by punched cards
with punched holes, each row of which corresponds to one row of the design. Mul-
tiple rows of holes are punched on each card and the many cards that compose
the design of the textile are strung together in order. Each position in the card
corresponds to a “Bolus” hook, which can either be raised or stopped dependant on
whether the hole is punched out of the card or the card is solid. The hook raises or
lowers the harness, which carries and guides the warp thread so that the weft will
either lie above or below it. The sequence of raised and lowered threads is what
creates the pattern. Each hook can be connected via the harness to a number of
threads, allowing more than one repeat of a pattern. A loom with a 400-hook head
might have four threads connected to each hook, resulting in a fabric that is 1600
warp ends wide with four repeats of the weave going across. The Jacquard loom
was the first machine to use punched cards to control a sequence of operations.
Although it did no computation based on them, it is considered an important step
in the history of computing hardware. The ability to change the pattern of the
loom’s weave by simply changing cards was an important conceptual precursor to
the development of computer programming. Specifically, Charles Babbage planned
to use cards to store programs in his Analytical engine. (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 19

15
 IBM, formerly known as Hollerith

Punchcards

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 20 / 96

Herman Hollerith (February 29, 1860 – November 17, 1929) was an American statis-
tician who developed a mechanical tabulator based on punched cards to rapidly tab-
ulate statistics from millions of pieces of data. He was the founder of the company
that became IBM. Punched card (or punch card or Hollerith card or IBM card) is a
piece of stiff paper that contains digital information represented by the presence or
absence of holes in predefined positions. Now almost an obsolete recording medium,
punched cards were widely used throughout the 19th century for controlling textile
looms and in the late 19th and early 20th century for operating fairground organs
and related instruments. They were used through the 20th century in unit record
machines for input, processing, and data storage. Early digital computers used
punched cards, often prepared using keypunch machines, as the primary medium for
input of both computer programs and data. Some voting machines use punched
cards. (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 20

16
 Konrad Zuse – Z1

Z1

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 21 / 96

Konrad Zuse (22 June 1910 Berlin – 18 December 1995 Hünfeld near Fulda) was a
German engineer and computer pioneer. His greatest achievement was the world’s
first functional program-controlled Turing-complete computer, the Z3, in May 1941
(the program was stored on a perforated 35mm film). (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 21

17
 Alan Turing [Tur01]

Enigma

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 22 / 96

18
 Alan Mathison Turing (born 23 June 1912 at 2 Warrington Crescent, London W9,
died 7 June 1954 at his home in Wilmslow, Cheshire) contributed to mathematics,
cryptanalysis, logic, philosophy, biology, and formatively to computer science, cogni-
tive science, Artificial Intelligence and Artificial Life. Turing and the American logi-
cian Alonzo Church argued that every effective mathematical method can be carried
out by the universal Turing machine, a proposition now known as the Church-Turing
thesis. Working independently, Turing and Church had both shown that – contrary
to mathematical opinion of the day – there are well-defined mathematical problems
that cannot be solved by effective methods; each published this result in 1936. This,
in conjunction with the work of the Austrian logician Kurt Godel, put paid to the
Hilbert programme in mathematics. In the summer of 1938 Turing returned to his
Fellowship at King’s. At the outbreak of hostilities with Germany in September 1939
he left Cambridge for the wartime headquarters of the Government Code and Cypher
School (GC&CS) at Bletchley Park, Buckinghamshire. Building on earlier work by
Polish cryptanalysts, Turing contributed crucially to the design of electro-mechanical
machines (’bombes’) used to decipher Enigma, the code by means of which the
German armed forces sought to protect their radio communications. Thanks to the
bombes, by early 1942 GC&CS was decoding about 39,000 intercepted messages
each month, rising subsequently to over 84,000 messages a month – approximately
two every minute. Turing’s work on the version of Enigma used by the German navy
was vital to the battle for supremacy in the North Atlantic. He also contributed to
the attack on the cyphers known as ’Fish’. Based on binary teleprinter code, Fish
was used during the latter part of the war in preference to morse-based Enigma for
the encryption of high-level signals, for example messages from Hitler and members
of the German High Command. It is estimated that the work of GC&CS shortened
the war in Europe by at least two years. Turing received the Order of the British
Empire for the part he played. (Source: http://www.alanturing.net/)
Turing Machine: A Turing machine – described by Alan Turing in 1937 – is a the-
oretical device that manipulates symbols on a strip of tape according to a table of
rules.
Despite his contributions to win the war, Turing was prosecuted by the British Au-
thorities for being homosexual and forced into hormone “treatment”. This eventually
led to depressions and suicide.
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 22

19
 John von Neumann [Neu45]

EDVAC

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 23 / 96

John von Neumann (December 28, 1903 – February 8, 1957) was a Hungarian-born
American mathematician who made major contributions to a vast range of fields,
including set theory, functional analysis, quantum mechanics, ergodic theory, contin-
uous geometry, economics and game theory, computer science, numerical analysis,
hydrodynamics (of explosions), and statistics, as well as many other mathematical
fields. He is generally regarded as one of the greatest mathematicians in modern
history. While consulting for the Moore School of Electrical Engineering at the Uni-
versity of Pennsylvania on the EDVAC project, von Neumann wrote an incomplete
First Draft of a Report on the EDVAC. The paper, which was widely distributed, de-
scribed a computer architecture in which the data and the program are both stored
in the computer’s memory in the same address space. This architecture is to this day
the basis of modern computer design, unlike the earliest computers that were ’pro-
grammed’ by altering the electronic circuitry. Although the single-memory, stored
program architecture is commonly called von Neumann architecture as a result of
von Neumann’s paper, the architecture’s description was based on the work of J.
Presper Eckert and John William Mauchly, inventors of the ENIAC at the University
of Pennsylvania. (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 23

20
 Von Neumann Architecture

Architecture

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 24 / 96

Grace Hopper
Grace Murray Hopper was an American computer sci-
entist and United States Naval officer. One of the first
programmers of the Harvard Mark I computer. She de-
veloped the first compiler for a computer programming
language.

Compiler

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 25 / 96

21
 Rear Admiral Grace Murray Hopper (December 9, 1906 – January 1, 1992) was
an American computer scientist and United States Naval officer. A pioneer in the
field, she was one of the first programmers of the Harvard Mark I computer, and
she developed the first compiler for a computer programming language. She con-
ceptualized the idea of machine-independent programming languages, which led to
the development of COBOL, one of the first modern programming languages. She
is also credited with popularizing the term “debugging” for fixing computer glitches
(motivated by an actual moth removed from the computer). Because of the breadth
of her accomplishments and her naval rank, she is sometimes referred to as “Amaz-
ing Grace”. The U.S. Navy destroyer USS Hopper was named for her. (Source:
Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 25

The First Bug

Debugging

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 26 / 96

22
 Analog Computers

Sliderule

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 27 / 96

Other Analog Computers

Apollo Lunar Module

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 28 / 96

23
 Analog computers were used mainly to solve differential equations, in particular for
weapons, missile control and space travel. Examples: Apollo Lunar Module.
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 28

Moore’s Law

Carver Mead

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 29 / 96

24
 Unix [RT74]

Unix

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 30 / 96

Unix is a computer operating system originally developed in 1969 by a group of

AT&T employees at Bell Labs, including Ken Thompson, Dennis Ritchie, Brian
Kernighan, Douglas McIlroy, and Joe Ossanna. Today’s Unix systems are split
into various branches, developed over time by AT&T as well as various commer-
cial vendors and non-profit organizations. The Open Group, an industry standards
consortium, owns the “Unix” trademark. (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 30

25
 Macs

MacIntosh

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 31 / 96

PCs

IBM PC

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 32 / 96

26
 Ubiquitous Computers

Android

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 33 / 96

Quantum Computing
Quantum Computing:

Shor’s-Algorithm [Sho97]:
q−1 !
! q−1
q −1 e2πiac/q |c!|xa mod n!
a=0 c=0
Shor’s-Algorithm

1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 34 / 96

27
 Quantum Computers make use of Quantum Effects and use Q-Bits. They can
compute some computations much faster than classical computers. For instance, the
Shor algorithm, named after mathematician Peter Shor, is a quantum algorithm for
integer factorization discovered in 1994. It solves the problem of integer factorization
in O(log3 n).
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 34

A Brief History of Programming Languages 35 / 96

Why are Languages Important?

Human language appears to be a unique phenomenon, without significant analogue in the animal
world.
Noam Chomsky

Language is a process of free creation; its laws and principles are fixed, but the manner in which the
principles of generation are used is free and infinitely varied. Even the interpretation and use of
words involves a process of free creation.
Noam Chomsky

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 36 / 96

28
 Languages as Tools for Thinking
Die Grenzen meiner Sprache bedeuten die Grenzen meiner Welt.
Ludwig Wittgenstein [Wit22]

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 37 / 96

Language Evolution
1957 1960 1965 1970 1975 1980 1985 1990
PostScript PostScript level 2
1982 1992
OO Forth
FIG-Forth Forth-83 ANS Forth 1987
Forth
1968 1978 1983 1986

Logo Object Logo Tcl Tcl/Tk

1968 1986 mid 1988 end 1988
RTRAN II FORTRAN III FORTRAN IV FORTRAN IV FORTRAN V Fortran 90 ISO
1957 end-1958 1962 (Fortran 66 ANS) (Fortran 77 ANSI) 1991
1966 april 1978 A A+
Prolog Prolog II Prolog III 1988 1992
1970 october 1982 1984
J
Sharp APL 1990
JOSS TELCOMP MUMPS MUMPS (ANSI) MUMPS (FIPS) MUMPS ISO
1964 1965 1966 september 15, 1977 1986 1992
Modula 3
1988
APL APL 2
1960 august 1984 ABC
B
1981 1987
Python
Borland 1991
Object Pascal
1985 Turbo Pascal
B-O Flow-Matic COBOL COBOL 61 COBOL 61 COBOL COBOL 68 ANS COBOL 74 ANSI COBOL 85 ISO/ANSI
1957 1958 1959 1961 Extended 1965 1968 1974 1985
1962 Rex 1.00 Rex 2.00 Rex 3.00 Rexx 3.20
may 1979 1980 1982 1984
Pascal Pascal AFNOR
1970 1983 Oberon Oberon-2
1987 1991
PL/M Modula Modula 2
1972 1975 1979
Ada Ada 83 ANSI Ada ISO
1979 january 1983 1987
PL/I PL/1 ANS NetRexx
1964 1976 1991
Concurrent C
1984 ANSI C ISO C
CPL BCPL B C C (K&R)
july 1967 1978 Classic C (C89) (C90)
1963 1969 1971 1989 december 15, 1990
JOVIAL JOVIAL I JOVIAL II JOVIAL 3 Objective-C
1959 1960 1961 1965 1983
Cmm
CORAL 64 CORAL 66 C with Classes ARM C++ 1992
1964 1966 C++
april 1980 july 1983 1989
CLU
Simula 67 1974
Simula I Oak
1964 1967 june 1991
ALGOL W Mesa
ALGOL 58 ALGOL 60 1966 ALGOL 68 1977
IAL Cedar
1958 1958 1960 december 1983
1968
GOGOL GOGOL III Smalltalk Smalltalk-72 Smalltalk-74 Smalltalk-76 Smalltalk-78 Smalltalk-80
1964 1967 1971 1972 1974 1976 1978 1980
sed Self
Sail 1973 Mainsail Eiffel Eiffel 2
1968 1975 1986 1988
ISWIM awk nawk
1966 1978 1985
KRC Sather 0.1
1981 june 1991
csh
SASL october 1978
Perl 1.000 Perl 2.000 Perl 3.000 Perl 4.000
1976 Miranda december 18, 1987 january 5, 1988 october 18, 1989 march 21, 1991
1982
sh
1969
BASIC MS Basic 2.0 Visual Basic 1.0 Visual Basic 2.0
may 1, 1964 july 1975 may 20, 1991 march 1992
Clos
Lisp 1.5 Common Lisp 1989
Lisp Lisp 1
1958 1959 1962 1984

Scheme Scheme MIT Scheme 84 Scheme IEEE

1975 1978 1984 1990
Haskell 1.0 Haskell 1.1 Haskell 1.2
1987 april 1, 1990 march 1992
ML SML SML ‘‘90
1973 1984 1990
SL5 Icon
SNOBOL SNOBOL 2 SNOBOL 3 SNOBOL 4 1976 1977 Caml 2-6.1
Caml
1962 april 1964 1965 1967 1987 1991

Messy!
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 38 / 96

29
 1940s

1940s: It is War. . .
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 39 / 96

1940s – Some Important Events:

! WW II
! A group of talented cryptographers breaks Enigma based on early work of the
Polish Cipher Bureau and Alan Turing’s ideas
! Computers play an important role in developing the first nuclear weapons at
Alamo

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 39

30
 1940s cont.
! No languages or
! Machine Language (i.e. no language)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 40 / 96

Machine Language

1100011110111010100101001001001010101110011010101001100000111100
1011010101111101010011111111111001011011000000001010010001001000
0110010101101100011011000110111100100000010101110110111101110010
0110110001100100001000010100001001101111011011111100011110111010
1001010010010010101011100110101010011000001111001011010101111101
0100111111111110010110110000000010100100010010000110010101101100
0110110001101111001000000101011101101111011100100110110001100100
0010000101000010011011110110111111000111101110101001010010010010
1010111001101010100110000011110010110101011111010100111111111110
0101101100000000101001000100100001100101011011000110110001101111
0010000001010111011011110111001001101100011001000010000101000010
0110111101101111110001111011101010010100100100101010111001101010
1001100000111100101101010111110101001111111111100101101100000000
1010010001001000011001010110110001101100011011110010000001010111
0110111101110010011011000110010011000111101110101001010010010010
1010111001101010100110000011110010110101011111010100111111111110
0101101100000000101001000100100001100101011011000110110001101111
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 41 / 96

31
 1950s

1950s: Innovation Big Bang!

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 42 / 96

1950s – Some Important Events:

! Cold war
! Cuban revolution
! Arab–Israeli conflict
! Sputnik shock
! Rock’n’ roll

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 42

32
 1950s cont.
! Assembly languages were first developed in the 1950s, when they were referred to as second generation
programming languages. For example, SOAP (Symbolic Optimal Assembly Program) was a 1957
assembly language for the IBM 650 computer.
! Fortran, invented by John W. Backus optimized for speed (similar to assembly), used for numerical
calculations in e.g. physics until today.
! Algol, the mother of procedural languages (such as Pascal)
! Lisp, the mother of functional languages

Fortran and Algol are imperative and procedural. Lisp is primarily functional.
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 43 / 96

Assembly
_partition :
LFB3 :
pus hq %r b p
LCFI0 :
movq %r s p , %r b p
LCFI1 :
pus hq %r b x
LCFI2 :
movl %edx , %r 1 0 d
m o v s l q %edx ,% r a x
leaq (% r d i ,% r a x , 4 ) , %r b x
movl (% r b x ) , %r 1 1 d
leal −1(% r s i ) , %r 9 d
cmpl %e s i , %edx
j l e L2
m o v s l q %e s i ,% r a x
leaq (% r d i ,% r a x , 4 ) , %r c x
. a l i g n 4 , 0 x90
L4 :
movl (% r c x ) , %r 8 d
cmpl %r 8d , %r 1 1 d
jl L5
incl %r 9 d
m o v s l q %r 9 d ,% r a x
leaq (% r d i ,% r a x , 4 ) , %r a x
movl (% r a x ) , %edx
movl %edx , (% r c x )
...

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 44 / 96

33
 Assembly ideas
! use mnemonics that symbolize processing steps (instructions), processor regis-
ters, memory locations, and other language features rather than 0s and 1s
! needs a simple compiler (assembler) – more or less isomorphic
! debugging aids added later
! one and two-pass assemblers Elements:
– Opcode mnemonics
– Data sections
– Assembly directives

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 44

Fortran – I

MODULE Qso rt_Mo dule

I M P L I C I T NONE

CONTAINS

RECURSIVE SUBROUTINE Q s o r t ( a )

INTEGER , INTENT ( I N OUT) :: a (:)

INTEGER : : s p l i t

I F ( s i z e ( a ) > 1 ) THEN
CALL P a r t i t i o n ( a , s p l i t )
CALL Q s o r t ( a ( : s p l i t −1))
CALL Q s o r t ( a ( s p l i t : ) )
END I F

END SUBROUTINE Q s o r t

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 45 / 96

34
 Fortran – II
SUBROUTINE P a r t i t i o n ( a , marker )

INTEGER , INTENT ( I N OUT) :: a (:)

INTEGER , INTENT (OUT) : : marker
INTEGER : : l e f t , r i g h t , p i v o t , temp

pi v ot = ( a (1) + a ( s i z e ( a ) ) ) / 2 ! A v e r a g e o f f i r s t and l a s t elements to pr ev e nt quadratic

left = 0 ! behavior with so rt ed or r e v e r s e s o r t e d data
right = size (a) + 1

DO WHILE ( l e f t < r i g h t )
right = right − 1
DO WHILE ( a ( r i g h t ) > p i v o t )
r i g h t = r i g h t −1
END DO
left = left + 1
DO WHILE ( a ( l e f t ) < p i v o t )
left = left + 1
END DO
I F ( l e f t < r i g h t ) THEN
temp = a ( l e f t )
a( le ft ) = a( right )
a ( r i g h t ) = temp
END I F
END DO

I F ( l e f t == r i g h t ) THEN
marker = l e f t + 1
ELSE
marker = l e f t
END I F

END SUBROUTINE P a r t i t i o n
END MODULE Qso rt_Mo dule

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 46 / 96

Fortran ([. . . ] derived from IBM Mathematical Formula Translating System) is a

general-purpose, procedural, imperative programming language that is especially
suited to numeric computation and scientific computing. Originally developed by
IBM at their campus in south San Jose, California in the 1950s for scientific and
engineering applications, Fortran came to dominate this area of programming early
on and has been in continual use for over half a century in computationally intensive
areas such as numerical weather prediction, finite element analysis, computational
fluid dynamics, computational physics and computational chemistry. It is one of
the most popular languages in the area of high-performance computing and is the
language used for programs that benchmark and rank the world’s fastest supercom-
puters. In late 1953, John W. Backus submitted a proposal to his superiors at IBM
to develop a more practical alternative to assembly language for programming their
IBM 704 mainframe computer. Backus’ historic FORTRAN team consisted of pro-
grammers Richard Goldberg, Sheldon F. Best, Harlan Herrick, Peter Sheridan, Roy
Nutt, Robert Nelson, Irving Ziller, Lois Haibt, and David Sayre. [. . . ] While the
community was skeptical that this new method could possibly out-perform hand-
coding, it reduced the number of programming statements necessary to operate a
machine by a factor of 20, and quickly gained acceptance. Said creator John Backus
during a 1979 interview with Think, the IBM employee magazine, “Much of my work
has come from being lazy. I didn’t like writing programs, and so, when I was working
on the IBM 701, writing programs for computing missile trajectories, I started work
on a programming system to make it easier to write programs.” (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 46

35
 Algol68 – I
PROC p a r t i t i o n =(REF [ ] DATA a r r a y , PROC ( REF DATA, REF DATA) BOOL cmp ) INT : (
INT b e g i n :=LWB a r r a y ;
INT end :=UPB a r r a y ;
WHILE b e g i n < end DO
WHILE b e g i n < end DO
I F cmp ( a r r a y [ b e g i n ] , a r r a y [ end ] ) THEN
DATA tmp=a r r a y [ b e g i n ] ;
a r r a y [ b e g i n ] : = a r r a y [ end ] ;
a r r a y [ end ] : = tmp ;
GO TO b r e a k w h i l e d e c r end
FI ;
end −:= 1
OD;
b r e a k w h i l e d e c r end : SKIP ;
WHILE b e g i n < end DO
I F cmp ( a r r a y [ b e g i n ] , a r r a y [ end ] ) THEN
DATA tmp=a r r a y [ b e g i n ] ;
a r r a y [ b e g i n ] : = a r r a y [ end ] ;
a r r a y [ end ] : = tmp ;
GO TO b r e a k w h i l e i n c r b e g i n
FI ;
b e g i n +:= 1
OD;
b r e a k w h i l e i n c r b e g i n : SKIP
OD;
begin
);

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 47 / 96

Algol68 – II
PROC q s o r t =(REF [ ] DATA a r r a y , PROC ( REF DATA, REF DATA) BOOL cmp ) VOID : (
I F LWB a r r a y < UPB a r r a y THEN
INT i := p a r t i t i o n ( a r r a y , cmp ) ;
PAR ( # r e m o v e PAR f o r s i n g l e t h r e a d e d s o r t #
q s o r t ( a r r a y [ : i − 1 ] , cmp ) ,
q s o r t ( a r r a y [ i + 1 : ] , cmp )
)
FI
);

MODE DATA = INT ;

PROC cmp=(REF DATA a , b )BOOL : a>b ;

main : (
[ ] DATA c o n s t l = ( 5 , 4 , 3 , 2 , 1 ) ;
[ UPB c o n s t l ]DATA l := c o n s t l ;
q s o r t ( l , cmp ) ;
p r i n t f ( ( $g ( 3 ) $ , l ) )
)

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 48 / 96

36
 ALGOL (short for ALGOrithmic Language) is a family of imperative computer pro-
gramming languages originally developed in the mid 1950s which greatly influenced
many other languages and became the de facto way algorithms were described in
textbooks and academic works for almost the next 30 years. It was designed to avoid
some of the perceived problems with FORTRAN and eventually gave rise to many
other programming languages, including BCPL, B, Pascal, Simula, C, and many
others. ALGOL introduced code blocks and the begin and end pairs for delimiting
them and it was also the first language implementing nested function definitions with
lexical scope. Fragments of ALGOL-like syntax are sometimes still used as pseu-
docode (notations used to describe algorithms for human readers). ALGOL was
developed jointly by a committee of European and American computer scientists
in a meeting in 1958 at ETH Zurich (cf. ALGOL 58). It specified three different
syntaxes: a reference syntax, a publication syntax, and an implementation syntax.
The different syntaxes permitted it to use different keyword names and conventions
for decimal points (commas vs periods) for different languages. ALGOL was used
mostly by research computer scientists in the United States and in Europe. Its use
in commercial applications was hindered by the absence of standard input/output
facilities in its description and the lack of interest in the language by large computer
vendors. (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 48

Lisp
( d e f u n qs ( l i s t )
( i f (<= ( l e n g t h l i s t ) 1 )
list
( le t (( pivot ( f i r s t l i s t )))
( append ( qs ( r e m o v e − if − no t # ’( lambda ( x ) (< x p i v o t ) ) l i s t ))
( r e m o v e − if − no t # ’( lambda ( x ) (= x p i v o t ) ) list )
( qs ( r e m o v e − if − no t # ’( lambda ( x ) (> x p i v o t ) ) l i s t ))))))

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 49 / 96

37
 In 1960, John McCarthy published a remarkable paper in which he did for program-
ming something like what Euclid did for geometry. He showed how, given a handful
of simple operators and a notation for functions, you can build a whole programming
language. He called this language Lisp, for “List Processing,” because one of his key
ideas was to use a simple data structure called a list for both code and data.
It’s worth understanding what McCarthy discovered, not just as a landmark in the
history of computers, but as a model for what programming is tending to become
in our own time. [. . . ] It seems to me that there have been two really clean,
consistent models of programming so far: the C model and the Lisp model. [. . . ]
Lisp wasn’t designed to fix the mistakes in Fortran; it came about more as the
byproduct of an attempt to axiomatize computation. (Source: Paul Graham, see
http://www.paulgraham.com)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 49

1960s

1960s: Swinging London (but not in IT)!

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 50 / 96

38
 1960s – Some Important Events:
! Cold war
! Cuba crisis
! Vietnam war
! Apollo programme
! Rock music
! Black civil rights movement
! Great Proletarian Cultural Revolution in China (death toll 20 to 30 million)
! Mass socialist or communist movement in most European countries (particularly
France and Italy)
! Student protest culture
! Computers becoming used outside science and military
! Gradual progress in programming language design

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 50

1960s
! Basic was developed by John George Kemeny and Thomas Eugene Kurtz at the Dartmouth College
! COBOL

Both are imperative and procedural.

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 51 / 96

39
 Basic
Procedure q S o r t ( A rr a y a ( 1 ) , f i r s t I n d e x , lastIndex )
Protected lo w , h i g h , p i v o t V a l u e

low = f i r s t I n d e x
high = l a s t In d e x
pivotValue = a (( f i r s t I n d e x + l a s t I n d e x ) / 2)

Repeat

W h i l e a ( low ) < p i v o t V a l u e
low + 1
Wend

While a ( high ) > pivotValue

high − 1
Wend

If l o w <= h i g h
Swap a ( l o w ) , a ( high )
low + 1
high − 1
EndIf

Until low > h i g h

If f i r s t I n d e x < high
qSort (a () , fi r st I n d ex , high )
EndIf

I f low < l a s t I n d e x
q S o r t ( a ( ) , lo w , l a s t I n d e x )
EndIf
EndProcedure

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 52 / 96

The original BASIC was designed in 1964 by John George Kemeny and Thomas
Eugene Kurtz at Dartmouth College in New Hampshire, USA to provide computer
access to non-science students. (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 52

40
 Cobol
Implementation is not shown, because
1. Cobol is too ugly
2. Originally, you could not implement recursion in Cobol at all (it is a language for business people, after all)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 53 / 96

The COBOL (Common Business Oriented Language) specification was created by

Grace Murray Hopper during the second half of 1959. COBOL defines its primary
domain in business, finance, and administrative systems for companies and govern-
ments.
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 53

41
 1970s

1970s: Revolution – New Frontiers!

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 54 / 96

1970s – Some Important Events:

! Cold war continues
! Vietnam war
! Apollo programme cancelled
! Pop music
! Hippie movement
! Student protest culture
! Computers becoming smaller and affordable (Moore’s Law)

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 54

42
 1970s
! C, developed in 1972 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating
system. The one and only systems language. Imperative and procedural, a better high level assembly.
! Prolog , invented by Alain Colmeraue, is a general purpose declarative logic programming language mainly
used for artificial intelligence and computational linguistics.
! Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Scott Wallace, and other created Smalltalk-80 at
Xerox PARC, the mother of all (good) object-oriented languages, based on Simula (from the 60s!)a
a So OO is indeed a very old technology.

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 55 / 96

Hackers

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 56 / 96

43
 C
void quick ( i n t ∗ l e f t , i n t ∗ r i g h t )
{
i f ( right > left ) {
i n t p i v o t = l e f t [ ( r i g h t −l e f t ) / 2 ] ;
int ∗r = right , ∗ l = l e f t ;
do {
w h i l e ( ∗ l < p i v o t ) l ++;
w h i l e ( ∗ r > p i v o t ) r −−;
i f ( l <= r ) {
int t = ∗ l ;
∗ l++ = ∗ r ;
∗ r−− = t ;
}
} w h i l e ( l <= r ) ;
quick ( l e f t , r ) ;
quick ( l , r i g h t ) ;
}
}

void s or t ( i n t ∗array , i n t length )

{
q u i c k ( a r r a y , a r r a y+l e n g t h − 1 ) ;
}

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 57 / 96

C is a general-purpose computer programming language developed in 1972 by Dennis

Ritchie at the Bell Telephone Laboratories for use with the Unix operating system.
Although C was designed for implementing system software, it is also widely used for
developing portable application software. C is one of the most popular programming
languages of all time and there are very few computer architectures for which a C
compiler does not exist. C has greatly influenced many other popular programming
languages, most notably C++, which began as an extension to C. C is an impera-
tive (procedural) systems implementation language. It was designed to be compiled
using a relatively straightforward compiler, to provide low-level access to memory,
to provide language constructs that map efficiently to machine instructions, and to
require minimal run-time support. C was therefore useful for many applications that
had formerly been coded in assembly language. Despite its low-level capabilities,
the language was designed to encourage cross-platform programming. A standards-
compliant and portably written C program can be compiled for a very wide variety
of computer platforms and operating systems with little or no change to its source
code. The language has become available on a very wide range of platforms, from
embedded microcontrollers to supercomputers.
Design goal minimalism: C’s design is tied to its intended use as a portable systems
implementation language. It provides simple, direct access to any addressable object
(for example, memory-mapped device control registers), and its source-code expres-
sions can be translated in a straightforward manner to primitive machine operations
in the executable code. (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 57

44
 Prolog
sort ( [] , [ ] ).
qsort ( [X] , [X] ) .
q s o r t ( [ H | U ] , S ) :− s p l i t B y (H, U , L , R ) , q s o r t ( L , SL ) , q s o r t ( R , SR ) ,
c om b in e (H, SL , SR , S ) .

% s p l i t B y ( H, U , LS , RS )
% True i f LS = { L i n U | L <= H } ; RS = { R i n U | R > H }
s p l i t B y ( H, [ ] , LS , RS ) .
s p l i t B y ( H, [ U | T ] , [ U | LS ] , RS ) :− U =< H, s p l i t B y (H , T , LS , RS ) .
s p l i t B y ( H, [ U | T ] , LS , [ U | RS ] ) :− U > H, s p l i t B y (H , T , LS , RS ) .

% c ombine ( H, L , R , S )
% True i f S i s L ++ [ H ] ++ R ( i n H a s k e l l n o t a t i o n )
c om bine ( H, L , R , S ) :− a ppe nd ( L , [ H | R ] , S ) .

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 58 / 96

Prolog is a general purpose logic programming language associated with artificial

intelligence and computational linguistics. Prolog has its roots in formal logic, and
unlike many other programming languages, Prolog is declarative: The program logic
is expressed in terms of relations, represented as facts and rules. A computation is
initiated by running a query over these relations. The language was first conceived
by a group around Alain Colmerauer in Marseille, France, in the early 1970s and
the first Prolog system was developed in 1972 by Colmerauer with Philippe Roussel.
Prolog was one of the first logic programming languages, and remains among the
most popular such languages today, with many free and commercial implementa-
tions available. While initially aimed at natural language processing, the language
has since then stretched far into other areas like theorem proving, expert systems,
games, automated answering systems, ontologies and sophisticated control systems.
(Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 58

45
 Smalltalk
" T h i s must be i n s e r t e d in to the c l a s s A r r a y a s an i n s t a n c e method "

q u i c k s o r t : l to : r
" s o r t s t h e a r r a y be tw e e n l and r a f t e r t h e q u i c k s o r t method
by M i c h a e l Neumann 1998
"
| m i l i r temp |
( r > l ) ifTrue : [
m ← s e l f a t : ( ( l + r ) // 2 ) .
il ← l .
ir ← r .
[
[ ( s e l f a t : i l ) < m] w h i l e T r u e : [ i l ← i l + 1 . ] .
[ ( s e l f a t : i r ) > m] w h i l e T r u e : [ i r ← i r − 1 . ] .
( i l < i r ) ifTrue : [
" swap "
temp ← s e l f a t : i l .
s e l f at : i l put : ( s e l f at : i r ) .
s e l f a t : i r p u t : temp .
].
] d o U n t i l : [ i l >= i r . ] .
s e l f q u i c k s o r t : l to : ( i l − 1 ) .
s e l f q u i c k s o r t : ( i l + 1) to : r .
].
↑self .

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 59 / 96

Smalltalk is an object-oriented, dynamically typed, reflective programming language.

Smalltalk was created as the language to underpin the “new world” of computing
exemplified by “human–computer symbiosis.” It was designed and created in part
for educational use, more so for constructionist learning, at the Learning Research
Group (LRG) of Xerox PARC by Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler,
Scott Wallace, and others during the 1970s. [. . . ] Smalltalk was the product of
researchers led by Alan Kay at Xerox Palo Alto Research Center (PARC); Alan Kay
designed most of the early Smalltalk versions, which Dan Ingalls implemented. The
first version, known as Smalltalk-71, was created by Ingalls in a few mornings on
a bet that a programming language based on the idea of message passing inspired
by Simula could be implemented in “a page of code.” A later variant actually used
for research work is now known as Smalltalk-72 and influenced the development of
the Actor model. Its syntax and execution model were very different from modern
Smalltalk variants. (Source: Wikipedia)
Smalltalk is pure OO – in Smalltalk everything is an object (including methods and
classes).
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 59

46
 1980s

1980s: OO is in the Air!

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 60 / 96

1980s – Some Important Events:

! Cold war ends
! End of communism (except North Korea, China and Cuba)
! Hip Hop
! PCs
! OO revolution

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 60

47
 1980s
! C++ was invented as a better (really?!) C by Bjarne Stroustrup. It is a multi-paradigm language
supporting procedural programming and OO concepts.
! Guido van Rossum created Python, a modern script language with functional and OO elements.
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 61 / 96

C++ – I
#i n c l u d e <i t e r a t o r >
# i n c l u d e <a l g o r i t h m > / / f o r s t d : : p a r t i t i o n
#i n c l u d e <f u n c t i o n a l > // f o r s t d : : l e s s

// h e l p e r f u n c t i o n f o r median of three
t e m p l a t e <t y p e n a m e T>
T m e d i a n (T t1 , T t2 , T t 3 )
{
i f ( t1 < t2 )
{
i f ( t2 < t3 )
r e t u r n t2 ;
e l s e i f ( t1 < t3 )
r e t u r n t3 ;
else
r e t u r n t1 ;
}
else
{
i f ( t1 < t3 )
r e t u r n t1 ;
e l s e i f ( t2 < t3 )
r e t u r n t3 ;
else
r e t u r n t2 ;
}
}

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 62 / 96

48
 C++ – II

/ / h e l p e r o b j e c t t o g e t <= f r o m <
t e m p l a t e <t y p e n a m e Order > s t r u c t n o n _ s t r i c t _ o p :
p u b l i c s t d : : b i n a r y _ f u n c t i o n <t y p e n a m e O r d e r : : s e c o n d _ a r g u m e n t _ t y p e ,
ty pe na me Order : : fir st_ar g um ent_ t yp e ,
bool>
{
n o n _str ic t_o p ( Order o ) : o r d e r ( o ) {}
b o o l o p e r a t o r ( ) ( t y pe na me Order : : second_argument_type arg1 ,
ty pe na me Order : : f i r s t _ a r g u m e n t _ t y p e ar g 2 ) c o n s t
{
r e t u r n ! o r d e r ( arg2 , arg 1 ) ;
}
private :
Order o r d e r ;
};

t e m p l a t e <t y p e n a m e Order > n o n _ s t r i c t _ o p<Order > n o n _ s t r i c t ( O r d e r o )

{
r e t u r n n o n _ s t r i c t _ o p<Order >(o ) ;
}

...

t e m p l a t e <t y p e n a m e R a n d o m A c c e s s I t e r a t o r >
v oid q u i c k s o r t ( RandomAccessIterator f i r s t , RandomAccessIterator last )
{
qui c k s o r t ( f i r s t , last ,
s t d : : l e s s <t y p e n a m e s t d : : i t e r a t o r _ t r a i t s <R a n d o m A c c e s s I t e r a t o r > : : v a l u e _ t y p e > ( ) ) ;
}

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 63 / 96

Python
def qsort ( l i s t ) :
i f no t l i s t :
return [ ]
else :
pivot = l i s t [0]
less = [ x for x in l i s t i f x < pivot ]
more = [ x f o r x i n l i s t [ 1 : ] i f x >= p i v o t ]
r e t u r n q s o r t ( l e s s ) + [ p i v o t ] + q s o r t ( more )

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 64 / 96

49
 1990s

1990s: Evolutionary Improvements!

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 65 / 96

1990s cont.

http://info.cern.ch/
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 66 / 96

50
 1990s cont.
! Haskell, named after logician Haskell Curry is a standardized, general-purpose purely functional
programming language, with non-strict semantics and strong static typing. “A proof is a program; the
formula it proves is a type for the program”. Designed by Simon Peyton Jones, Paul Hudak, Philip
Wadler, et al. Used in the research community.
! Java invented by SUN (James Gosling, Mike Sheridan, and Patrick Naughton), is a general purpose OO
language with C++ syntax.
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 67 / 96

1990s – Some Important Events:

! End of history announced
! Civil and irregular wars
! MTV
! OO becoming mainstream
! The Internet becomes mainstream

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 67

51
 Haskell
q s o r t : : Ord a => [ a ] −> [ a ]
qsort [ ] = [ ]
q s o r t ( p : x s ) = q s o r t l e s s e r ++ [ p ] ++ q s o r t greater
where
l e s s e r = f i l t e r (< p ) x s
g r e a t e r = f i l t e r (>= p ) x s

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 68 / 96

Haskell is a standardized, general-purpose purely functional programming language,

with non-strict semantics and strong static typing. It is named after logician Haskell
Curry. In Haskell, “a function is a first-class citizen” of the programming language.
As a functional programming language, the primary control construct is the func-
tion; the language is rooted in the observations of Haskell Curry and his intellectual
descendants, that “a proof is a program; the formula it proves is a type for the
program”.[. . . ] Following the release of Miranda by Research Software Ltd, in 1985,
interest in lazy functional languages grew: by 1987, more than a dozen non-strict,
purely functional programming languages existed. Of these, Miranda was the most
widely used, but was not in the public domain. At the conference on Functional
Programming Languages and Computer Architecture (FPCA ’87) in Portland, Ore-
gon, a meeting was held during which participants formed a strong consensus that
a committee should be formed to define an open standard for such languages. The
committee’s purpose was to consolidate the existing functional languages into a
common one that would serve as a basis for future research in functional-language
design. (Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 68

52
 Java
p u b l i c s t a t i c <E e x t e n d s C o m pa r a ble <? s u p e r E>> L i s t <E> q u i c k S o r t ( L i s t <E> a r r ) {
i f ( a r r . s i z e ( ) <= 1 )
return arr ;
E p i v o t = a r r . g e t F i r s t ( ) ; // T h i s p i v o t c a n c ha ng e t o g e t f a s t e r r e s u l t s

L i s t <E> l e s s = new L i n k e d L i s t <E > ( ) ;

L i s t <E> p i v o t L i s t = new L i n k e d L i s t <E > ( ) ;
L i s t <E> more = new L i n k e d L i s t <E > ( ) ;

// P a r t i t i o n
f o r (E i : a r r ) {
i f ( i . compareTo ( p i v o t ) < 0 )
l e s s . add ( i ) ;
e l s e i f ( i . compareTo ( p i v o t ) > 0 )
more . add ( i ) ;
else
p i v o t L i s t . add ( i ) ;
}

// R e c u r s i v e l y s o r t s u b l i s t s
l e s s = quickSort ( l e s s );
more = q u i c k S o r t ( more ) ;

// C o n c a t e n a t e r e s u l t s
l e s s . addAll ( p i v o t L is t );
l e s s . a d d A l l ( more ) ;
return less ;
}

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 69 / 96

53
 Java refers to a number of computer software products and specifications from Sun
Microsystems, a subsidiary of Oracle Corporation, that together provide a system
for developing application software and deploying it in a cross-platform environment.
Java is used in a wide variety of computing platforms from embedded devices and
mobile phones on the low end, to enterprise servers and supercomputers on the high
end. Java is used in mobile phones, Web servers and enterprise applications, and
while less common on desktop computers, Java applets are often used to provide
improved and secure functionalities while browsing the World Wide Web. Writing
in the Java programming language is the primary way to produce code that will
be deployed as Java bytecode, though there are bytecode compilers available for
other languages such as Ada, JavaScript, Python, and Ruby. Several new languages
have been designed to run natively on the Java Virtual Machine (JVM), such as
Scala, Clojure and Groovy. Java syntax borrows heavily from C and C++, but
object-oriented features are modeled after Smalltalk and Objective-C. Java elimi-
nates certain low-level constructs such as pointers and has a very simple memory
model where every object is allocated on the heap and all variables of object types are
references. Memory management is handled through integrated automatic garbage
collection performed by the JVM.
The Java platform and language began as an internal project at Sun Microsystems
in December 1990, providing an alternative to the C++/C programming languages.
Engineer Patrick Naughton had become increasingly frustrated with the state of
Sun’s C++ and C APIs (application programming interfaces) and tools. While con-
sidering moving to NeXT, Naughton was offered a chance to work on new technology
and thus the Stealth Project was started. The Stealth Project was soon renamed
to the Green Project with James Gosling and Mike Sheridan joining Naughton. To-
gether with other engineers, they began work in a small office on Sand Hill Road
in Menlo Park, California. They were attempting to develop a new technology for
programming next generation smart appliances, which Sun expected to be a major
new opportunity. The team originally considered using C++, but it was rejected
for several reasons. Because they were developing an embedded system with lim-
ited resources, they decided that C++ demanded too large a footprint and that
its complexity led to developer errors. The language’s lack of garbage collection
meant that programmers had to manually manage system memory, a challenging
and error-prone task. The team was also troubled by the language’s lack of portable
facilities for security, distributed programming, and threading. Finally, they wanted a
platform that could be easily ported to all types of devices. Bill Joy had envisioned
a new language combining Mesa and C. In a paper called Further, he proposed
to Sun that its engineers should produce an object-oriented environment based on
C++. Initially, Gosling attempted to modify and extend C++ (which he referred
to as “C++ ++ –”) but soon abandoned that in favor of creating an entirely new
language, which he called Oak, after the tree that stood just outside his office.
(Source: Wikipedia)
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 69

54
 2000s

2000s: Clouds. . .
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 70 / 96

2000s – Some Important Events:

! World Trade Center
! War on terrorism
! The Internet becomes indispensable
! Social Networks
! Cloud Computing

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – note 1 of slide 70

55
 MapReduce

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 71 / 96

Summary: Programming Languages’ Paradigms

! Imperative: Computation in terms of program state and statements that change the program state.
Specifies steps the program must take to reach the desired state. Examples: Assembly, C, C++, Java
! Declarative: Describes what rather than how. Examples: HTML, SQL, Prolog
! Procedural: A subset of imperative languages consisting of procedures (aka routines, subroutines,
methods, or functions), each containing a series of computational steps to be carried out. Examples: C,
C++, Java
! Functional: Computation is the evaluation of mathematical functions. Avoids state and mutable data.
Examples: Lisp, ML, Haskell
! Constraint: Relations between variables are stated in the form of constraints. Constraints do not specify a
sequence of steps to execute, but rather the properties of a solution to be found. Searches for a state of
the world in which a number of constraints are satisfied at the same time. Examples: Prolog
! Logic: Pattern-directed invocation of procedures from assertions and goals. When a set of predicates is
satisfied, an action is taken. Examples: Prolog
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 72 / 96

56
 Interpretation of Paradigms
record
Descriptive
declarative
The principal programming paradigms
programming
XML, "More is not better (or worse) than less, just different."
Data structures only S−expression
Turing equivalent + procedure v1.08 © 2008 by Peter Van Roy

First−order + cell (state)

Observable functional Imperative
nondeterminism? Yes No programming programming
Pascal, C
+ closure Imperative
Functional search
programming + search
programming
+ unification Scheme, ML + name SNOBOL, Icon, Prolog
(equality) (unforgeable constant)
Deterministic + continuation + cell
ADT + cell ADT + port
logic programming Continuation functional imperative (state) + closure
programming (channel)
programming programming Sequential
+ search Scheme, ML Event−loop object−oriented
Haskell, ML, E CLU, OCaml, Oz programming
Relational & logic + by−need + thread programming
programming synchron. + single assign. + nondeterministic + port E in one vat Stateful
Prolog, SQL Lazy Monotonic choice (channel) + thread functional
embeddings functional dataflow Nonmonotonic Multi−agent programming
Multi−agent
+ solver programming programming dataflow dataflow programming Java, OCaml
Constraint (logic) Haskell Declarative programming programming + thread
Message−passing
programming concurrent Concurrent logic Oz, Alice, AKL concurrent Concurrent
CLP, ILOG Solver programming programming programming object−oriented
+ thread Pipes, MapReduce Oz, Alice, Curry, Excel, Erlang, AKL programming
+ thread + by−need AKL, FGHC, FCP Shared−state
Concurrent + single assignment synchronization + local cell
constraint + synch. on partial termination concurrent
programming Lazy Functional reactive Active object programming
dataflow programming (FRP) programming Smalltalk, Oz,
LIFE, AKL programming
Weak synchronous Object−capability Java, Alice
+ by−need synchronization Lazy programming
programming + log
Lazy concurrent declarative
constraint concurrent FrTime, SL CSP, Occam, Software
programming programming + instantaneous computation E, Oz, Alice, transactional
publish/subscribe, memory (STM)
Oz, Alice, Curry Oz, Alice, Curry Strong synchronous tuple space (Linda)
programming SQL embeddings
Logic and Esterel, Lustre, Signal Dataflow and
constraints Functional message passing Message passing Shared state

Nondet. state
Unnamed state (seq. or conc.) Named state
More declarative Less declarative

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 73 / 96

Shooting Yourself
How to Shoot Yourself In the Foot Using Any Programming Language:
! C: You shoot yourself in the foot and then nobody else can figure out what you did.
! C++: You accidentally create a dozen clones of yourself and shoot them all in the foot. Emergency medical
assistance is impossible since you can’t tell which are bitwise copies and which are just pointing at others and
saying, “That’s me, over there.”
! Java: After importing java.awt.right.foot.* and java.awt.gun.right.hand.*, and writing the classes and methods of
those classes needed, you’ve forgotten what the hell you’re doing.
! Haskell: You shoot yourself in the foot very elegantly, and wonder why the whole world isn’t shooting itself this
way.
! Lisp: You shoot yourself in the appendage which holds the gun with which you shoot yourself in the appendage
which holds the gun with which you shoot yourself in the appendage which holds the gun with which you shoot. . .
! Smalltalk: You shoot yourself in the foot and your foot sends doesNotUnderstand: Pain to your brain.
! XML: You can’t actually shoot yourself in the foot; all you can do is describe the gun in painful detail.
(Sources: http://www.toodarkpark.org/computers/humor/shoot-self-in-foot.html and http://thealmightyguru.com/Humor/Docs/ShootYourselfInTheFoot.html)

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 74 / 96

57
 Programming Languages as seen by Fans

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 75 / 96

Languages as Tools for Programming

A language that doesn’t affect the way you think about programming, is not worth knowing.
Alan Perlis

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 76 / 96

58
A Brief History of Networks 77 / 96

The World is Connected

The network is the computer
Scott McNealy, co-founder of Sun Microsystems

Unfortunately, this is the topic for another lecture, please ask Prof. Hoffmann for next year’s Xmas lecture!
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 78 / 96

The Power of the Network

213.251.145.96
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 79 / 96

59
A Brief History of Applications 80 / 96

Important Applications
Warning: The following choice is ridiculously subjective!

Mathematica
MS BASIC gcc
Visual C++
WordStar Emacs Photoshop
Micro vi VisiCalc TEX Mosaic
DBMS Sendmail Apache RSS MapReduce

1960 1970 1980 1990 2000

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 81 / 96

A Brief History of Computer Scientists and Engineers 82 / 96

Famous Computer Scientists and Engineers

Gottfried Wilhelm Leibniz Charles Babbage Ada Lovelace John von

Neumann Alan Turing Kurt Gödel John Atanasoff Alonzo Church
Claude Shannon Konrad Zuse Vannevar Bush C. A. R. Hoare Stephen
Cole Kleene Edgar F. Codd John Backus Marvin Minsky Barbara
Liskov Ron Rivest Adi Shamir Leonard Adleman Dennis M. Ritchie
Alan Kay Bill Joy Peter Naur Ken Thompson Gordon E. Moore
Fred Brooks Niklaus Wirth Donald Knuth Linus Torvalds Andrew S.
Tanenbaum Eric S. Raymond Steve Jobs Richard M. Stallman William
Gates III Joseph Weizenbaum Tim Berners-Lee. . .
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 83 / 96

60
A Brief History of Challenges 84 / 96

Different Disciplines

Engineering Science
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 85 / 96

Speaking Different Languages – Example I

software engineer: Shall I use C++ or Lisp?
computer scientist: Does not matter!
software engineer: ?
computer scientist: Aren’t both Turing complete?
software engineer: ?
computer scientist: Sigh, I guess they both support loops or recursion, conditional statements and
the like?
software engineer: Well, yes, of course!
computer scientist: Then it does not matter!
software engineer: WTF?!
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 86 / 96

61
 Speaking Different Languages – Example II
software engineer: Haskell does not have side effects?
computer scientist: Haskell is a pure functional language!
software engineer: ?
computer scientist: Sigh, a pure functional language does not have any side effects, so it was
designed!
software engineer: So I cannot change state?
computer scientist: You do not understand - there is no state!
software engineer: So, please – how do I implement input/output?
computer scientist: You have to use monads!
software engineer: For goodness’ sake, what is a monad?
computer scientist: A monad is a monoid in the category of endofunctors, what’s the problem?
software engineer: WTF?!

We teach computer science, but the industry desperately needs (software) engineers [Par97]. The effect is
roughly the same as it would be if you assigned a physics Ph.D. to design electrical equipment!
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 87 / 96

What can we Compute?

Two important questions:
1. “What does it mean for a function from the natural numbers to themselves to be computable?”
2. “Can noncomputable functions be classified into a hierarchy based on their level of noncomputability?”
Related to the Church–Turing thesis, which states that any function that is computable by an algorithm is a
computable function.

Big open question:

P = NP?
Further aspects:
“Can (quantum) physics be (efficiently) simulated by (classical) computers?” Richard Feynman
(1981)
This led to theory of quantum computers.
c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 88 / 96

62
 How to deal with Complexity?
Politically correct answer:

Software Engineering!
The truth is:

We still have no clue!

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 89 / 96

Outlook 90 / 96

The Future of Computing

The best way to predict the future is to

invent it!
Alan Kay

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 91 / 96

63
Appendix 92 / 96

References
[Neu45] John von Neumann. First draft of a report on the edvac. IEEE Ann. Hist. Comput., 15(4):27–75, October 1945.
[Par97] David Lorge Parnas. Software engineering (extended abstract): an unconsummated marriage. In Proceedings of
the 6th European SOFTWARE ENGINEERING conference held jointly with the 5th ACM SIGSOFT
international symposium on Foundations of software engineering, ESEC ’97/FSE-5, pages 1–3, New York, NY,
USA, 1997. Springer-Verlag New York, Inc.
[RT74] D. M. Ritchie and K. Thompson. The unix time-sharing system. Communications of the ACM, 17:365–375,
1974.
[Sho97] Peter W. Shor. Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum
computer. SIAM J. Comput., 26:1484–1509, October 1997.
[Tur01] Alan M. Turing. Collected works of A. M. Turing. Mathematical logic. Elsevier, Amsterdam, The Netherlands,
2001. Edited by R. O. Gandy and C. E. M. Yates. Including prefaces by Solomon Feferman.
[Wit22] Ludwig Wittgenstein. Tractatus Logico-Philosophicus. Kegan Paul, Trench, Trubner & Co., 1922.

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 93 / 96

Credits – I/III
! c
Stonehenge: !2009 David Ball – www.davidball.net

! Abacus: public domain

! Al-Chwarizmi: John L. Esposito. The Oxford History of Islam. Oxford University Press, copyright expired

! c
Da Vinci: !IBM

! Pascaline: !
CC 2005 David Monniaux

! Leibniz: Page of the Article “Explication de l’Arithmétique Binaire”, 1703/1705, copyright expired

! Babbage Diff. Engine: !

CC 2005 Carsten Ullrich

! Babbage Ana. Engine: !

CC 2009 Bruno Barral

! Ada Lovelace: Margaret Carpenter (1793-1872), copyright expired

! c
Steampunk: !2007 Jake von Slatt

! c
Power (Jacquard) Looms: !2009 Lutz Marx

! IBM: public domain

! Zuse: !
CC ComputerGeek, public domain

! c
Alan Turing: !1951 National Portrait Gallery, London, http://www.npg.org.uk/

! Von Neumann: public domain

! Von Neumann Architektur: !

CC 2007 Lukas Grossar

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 94 / 96

64
 Credits – II/III
! Grace Hopper: public domain

! Bug: public domain

! Sliderule: !
CC Creative Commons Attribution-Share Alike 3.0 Unported

! Lunar Module: public domain

! Moore’s Law: !
CC Creative Commons Attribution-Share Alike 3.0 Unported

! Unix: !
CC Creative Commons Attribution-Share Alike 3.0 Unported

! MacIntosh: !
CC Creative Commons Attribution-Share Alike 2.5 Italy http://www.allaboutapple.com/

! PC: !
CC Creative Commons Attribution-Share Alike 3.0 Unported

! Android: !
CC Creative Commons Attribution-Share Alike 3.0

! Quantum Computing: !
CC Smite-Meister, Creative Commons Attribution-Share Alike 3.0 Unported

! c
Programming Languages !1999-2010 Éric Lévénez http://www.levenez.com/lang/

! Bletchley Park: !
CC Matt Crypto, public domain

! 1950s: !
CC 2006 Hans Weingartz http://www.pass-weingartz.de/hw.htm CC-by-sa 2.0/de

! Fortran and all further programming examples taken from http://rosettacode.org/wiki/Sorting_algorithms/Quicksort

! c
Twiggy: !2001-2005 www.twiggylawson.co.uk

! Apollo 11: public domain

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 95 / 96

Credits – III/III
! Thompson Ritchie: public domain

! Berlin Wall: !
CC Unknown photographer, Creative Commons-Lizenz Namensnennung-Weitergabe unter gleichen Bedingungen 3.0 Unported

! Bill Clinton, Yitzhak Rabin, Yasser Arafat at the White House: public domain

! c
Clouds: !2008 Jörg Schäfer

! Languages: Source http://i.imgur.com/1gF1j.jpg, copyright unknown

! c
MapReduce: !2004, Jeffrey Dean and Sanjay Ghemawat, Google Inc.

! c
Principles Programming Paradigms: !2007 Peter Van Roy http://www.info.ucl.ac.be/~pvr/paradigmsDIAGRAMeng.pdf

! Engineers: http://s882.photobucket.com/albums/ac30/Pvt_Hawkins/

! c
Einstein: !1921, Ferdinand Schmutzer, copyright expired

c
!Jörg Schäfer http://user.fh-frankfurt.de/~jschaefer/lectures/ A Brief History of Computing – 96 / 96

65