Chapter 25
Programming Languages
is chapter touches on a number of inuential programming languages
and also discusses the characteristics of several categories of program-
ming paradigms. ese paradigms include imperative, declarative, func-
tional, logical, and object-oriented programming.
While certain languages are commonly known by a particular pro-
gramming paradigm—Fortran is known as an imperative language, LISP
as a functional language—it is oen the case that languages are hybrids to
a certain degree, combining aspects of several paradigms into their speci-
cations. As intricate detail is not the goal of this chapter, subtleties such
as these are not always addressed.
e rst programming languages implemented in the 1940s and early
1950s were slow, dicult to use, unfriendly, and error-prone, much like
the rst computers on which they ran. At the time these languages were
developed and used, they were known as pseudocodes, though the deni-
tion of the word has evolved signicantly since that time [1]. Pseudocodes
were not high-level languages, nor even assembly languages; they were
bare-bones machine languages. Programs were exceedingly dicult
to write, dicult to read, dicult to maintain, and incredibly fragile.
Numeric codes represented instructions, absolute addressing meant that
inserting a single line could invalidate every address call that followed,
and computer architectures were not capable of oating-point arithmetic
or indexing for arrays [1].
232 Computing
ese and other shortcomings inherent in machine language and in
simple computer architectures motivated the development of a more
advanced and abstracted programming tool: the assemblers and assembly
languages that evolved during the early 1950s [1]. Although assembly code
was a notable improvement from machine code, assembly languages did
not have much impact on the development of higher-level languages.
In the 1950s, several interpretive systems were developed that extended
machine code to allow for oating-point operations. John Backus
(19242007) developed one such system called the Speedcoding system for
the IBM 701. e interpreter was able to use the architecture to represent
a virtual three-address oating-point calculator. Instructions were devel-
oped to execute addition, subtraction, multiplication, division, square
root, sine, arc tangent, exponent, and logarithm functions. Speedcoding
also allowed for conditional and unconditional branches and I/O conver-
sions as part of its virtual architecture. Speedcoding even automatically
incremented the address registers when a new line of code was added
(though not until 1962). Problems that took days or even weeks to program
in machine code could be programmed in a few hours using Speedcoding.
However, the remaining usable memory aer loading the interpreter was
generally very small, and instructions took a signicant amount of time
to execute because simulating oating-point operations in soware was a
very time-consuming process [1].
Today’s high-level languages are abstract, exible, and portable; they are
able to be written, compiled, and run on virtually any modern computer.
In the early days of computing, the situation was quite dierent; program-
ming features were dependent on the architecture of the particular model
of machine targeted. So was the state of technology during the ground-
breaking development of the rst high-level language.
e IBM 704 was the rst mass-produced computer with oating-point
arithmetic hardware. Including in hardware what until then could only be
emulated by interpretive systems, it provided the foundation needed for
the next big step in computing. e 704 was released by IBM in 1954, and
marked the beginning of the end for the slow, memory-intensive inter-
pretive systems. Making good use of the advanced new hardware, the rst

Get Computing now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.