Imperative Programming - Brief version by
Stan Seibert
Also known as Procedural Programming
Imperative programming is a
programming style that describes computation in terms of a program state and statements that change the program state. In much the same way as the imperative mood in
natural languages expresses commands to take action, imperative programs are a sequence of commands for the computer to perform. The hardware implementation of almost all computers is imperative; nearly all computer hardware is designed to execute
machine code, which is native to the computer, written in the imperative style. From this low-level perspective, the program state is defined by the contents of memory, and the statements are instructions in the native machine language of the computer. Higher-level imperative languages use
variables and more complex statements, but still follow the same
paradigm. Recipes and process checklists, while not computer programs, are also familiar concepts that are similar in style to imperative programming; each step is an
instruction, and the physical world holds the state. Since the basic ideas of imperative programming are both conceptually familiar and directly embodied in the hardware, most computer languages are in the imperative style.
Most high-level languages support four basic types of statements: assignment,
looping,
conditional branching, and
unconditional branching. Assignment statements, in general, perform an operation on information located in memory and store the results in memory for later use. High-level imperative languages, in addition, permit the evaluation of complex
expressions, which may consist of a combination of arithmetic operations and function evaluations, and the assignment of the resulting value to memory. Looping statements allow a sequence of statements to be executed multiple times. Loops can either execute the statements they contain a predefined number of times, or they can execute them repeatedly until some condition changes. Conditional branching statements allow a block of statements to be executed only if some condition is met. Otherwise, the statements are skipped and the execution sequence continues from the statement following the block. Unconditional branching statements allow the execution sequence to be transferred to some other part of the program. These include the jump, called "
goto" in many languages, and the subprogram, or procedure, call.
The earliest imperative languages were the machine languages of the
original computers. In these languages, instructions were very simple, which made hardware implementation easier, but hindered the creation of complex programs.
FORTRAN, developed by
John Backus at
IBM starting in 1954, was the first major programming language to remove the obstacles presented by machine code in the creation of complex programs. FORTRAN was a compiled language that allowed named variables, complex expressions,
subprograms, and many other features now common in imperative languages. The next two decades saw the development of a number of other major high-level imperative programming languages. In the late 1950s and 1960s,
ALGOL was developed in order to allow mathematical algorithms to be more easily expressed.
COBOL (1960) and
BASIC (1964) were both attempts to make
programming syntax look more like English. In the 1970s,
Pascal was developed by
Niklaus Wirth, and
C was created by
Dennis Ritchie while he was working at
Bell Laboratories. Wirth went on to design
Modula-2, Modula-3, and
Oberon. The United States
Department of Defense began designing
Ada in 1974, but did not complete the specification until 1983.
The 1980s saw a rapid growth in interest in
object-oriented programming. These languages were imperative in style, but added features to support objects. The last two decades of the twentieth century saw the development of a considerable number of such programming languages.
Smalltalk-80, originally conceived by
Alan Kay in 1969, was released in 1980 by the
Xerox Palo Alto Research Center. Drawing from
Smalltalk's concepts,
Bjarne Stroustrup designed an object-oriented extension of the C language called
C++, which was first implemented in 1985. In the late 1980s and 1990s, the notable imperative languages drawing on object-oriented concepts were
Perl, released by
Larry Wall in 1987;
Python, released by
Guido van Rossum in 1990; and
Java, first released by
Sun Microsystems in 1996.
Imperative programming languages stand in contrast to other types of languages, such as functional and logical programming languages.
Functional programming languages, such as
Haskell, are not a sequence of statements and have no global state like imperative languages do.
Logical programming languages, like
Prolog, are often thought of as defining "what" is to be computed, rather than "how" the computation is to take place, as an imperative programming language does.
For Further Reading
Pratt, Terrence W. and Marvin V. Zelkowitz. Programming Languages: Design and Implementation. 3rd ed. Englewood Cliffs, N.J.: Prentice Hall, 1996.
Sebesta, Robert W. Concepts of Programming Languages. 3rd ed. Reading, Mass.: Addison-Wesley Publishing Company, 1996.
Posted 2001-08-22; reviewed and approved by the Computers group; editor, Michael Witbrock; lead reviewer, Nancy Tinkham; lead copyeditors, Ruth Ifcher and Hillary Brown.
For citation purposes, please use the following (stable) URL: www.nupedia.com/article/681/
The above text is a part of Nupedia and is covered by the GNU Free Documentation License. This node has been brought to you by the Nupedia Assimilation Project.