Computing

231

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.

25.1 MACHINE CODE

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.

25.2 INTERPRETATIVE CRUTCHES

In the 1950s, several interpretive systems were developed that extended

machine code to allow for oating-point operations. John Backus

(1924–2007) 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].

25.3 THE FIRST HIGH-LEVEL LANGUAGE: FORTRAN

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