Imperative Programming - Wikipedia

Imperative programming - Wikipedia https://en.wikipedia.
org/wiki/Imperative_programming
Imperative programming
In computer science, imperative programming is a programming paradigm of soware that uses
statements that change a program's state. In much the same way that the imperative mood in natural
languages expresses commands, an imperative program consists of commands for the computer to
perform. Imperative programming focuses on describing how a program operates step by step,[1] rather
than on high-level descriptions of its expected results.
e term is oen used in contrast to declarative programming, which focuses on what the program
should accomplish without specifying all the details of how the program should achieve the result.[2]
Procedural programming
Procedural programming is a type of imperative programming in which the program is built from one
or more procedures (also termed subroutines or functions). e terms are oen used as synonyms, but
the use of procedures has a dramatic effect on how imperative programs appear and how they are
constructed. Heavy procedural programming, in which state changes are localized to procedures or
restricted to explicit arguments and returns from procedures, is a form of structured programming.
Since the 1960s, structured programming and modular programming in general have been promoted as
techniques to improve the maintainability and overall quality of imperative programs. e concepts
behind object-oriented programming aempt to extend this approach.
Procedural programming could be considered a step toward declarative programming. A programmer

can oen tell, simply by looking at the names, arguments, and return types of procedures (and related
comments), what a particular procedure is supposed to do, without necessarily looking at the details of
how it achieves its result. At the same time, a complete program is still imperative since it fixes the
statements to be executed and their order of execution to a large extent.
Rationale and foundations of imperative programming

e programming paradigm used to build programs for almost all computers typically follows an
imperative model.[note 1] Digital computer hardware is designed to execute machine code, which is
native to the computer and is usually wrien in the imperative style, although low-level compilers and
interpreters using other paradigms exist for some architectures such as lisp machines.
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.
Assignment statements, in imperative paradigm, 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
1 of 11 5/9/24, 21:15
Imperative programming - Wikipedia https://en.wikipedia.org/wiki/Imperative_programming
operations and function evaluations, and the assignment of the resulting value to memory. Looping
statements (as in while loops, do while loops, and for loops) 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 is met. Conditional branching
statements allow a sequence 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 them.
Unconditional branching statements allow an execution sequence to be transferred to another part of a
program. ese include the jump (called goto in many languages), switch, and the subprogram,
subroutine, or procedure call (which usually returns to the next statement aer the call).
Early in the development of high-level programming languages, the introduction of the block enabled
the construction of programs in which a group of statements and declarations could be treated as if
they were one statement. is, alongside the introduction of subroutines, enabled complex structures to
be expressed by hierarchical decomposition into simpler procedural structures.
Many imperative programming languages (such as Fortran, BASIC, and C) are abstractions of assembly
language.[3]
History of imperative and object-oriented languages

e 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 International Business
Machines (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. e next two decades saw the development of many 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 and even served as the operating
system's target language for some computers. MUMPS (1966) carried the imperative paradigm to a
logical extreme, by not having any statements at all, relying purely on commands, even to the extent of
making the IF and ELSE commands independent of each other, connected only by an intrinsic variable
named $TEST. COBOL (1960) and BASIC (1964) were both aempts 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 and Oberon. For
the needs of the United States Department of Defense, Jean Ichbiah and a team at Honeywell began
designing Ada in 1978, aer a 4-year project to define the requirements for the language. e
specification was first published in 1983, with revisions in 1995, 2005, and 2012.
e 1980s saw a rapid growth in interest in object-oriented programming. ese languages were
imperative in style, but added features to support objects. e last two decades of the 20th century saw
the development of many such languages. Smalltalk-80, originally conceived by Alan Kay in 1969, was
released in 1980, by the Xerox Palo Alto Research Center (PARC). Drawing from concepts in another
object-oriented language—Simula (which is considered the world's first object-oriented programming
language, developed in the 1960s)—Bjarne Stroustrup designed C++, an object-oriented language based
on C. Design of C++ began in 1979 and the first implementation was completed in 1983. 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; Visual Basic and Visual
C++ (which included Microso Foundation Class Library (MFC) 2.0), released by Microso in 1991 and
2 of 11 5/9/24, 21:15
1993 respectively; PHP, released by Rasmus Lerdorf in 1994; Java, by James Gosling (Sun Microsystems)
in 1995, JavaScript, by Brendan Eich (Netscape), and Ruby, by Yukihiro "Matz" Matsumoto, both
released in 1995. Microso's .NET Framework (2002) is imperative at its core, as are its main target
languages, VB.NET and C# that run on it; however Microso's F#, a functional language, also runs on
it.
Examples
Fortran
FORTRAN (1958) was unveiled as "e IBM Mathematical FORmula TRANslating system." It was
designed for scientific calculations, without string handling facilities. Along with declarations,
expressions, and statements, it supported:
▪ arrays
▪ subroutines
▪ "do" loops
It succeeded because:
▪ programming and debugging costs were below computer running costs

▪ it was supported by IBM
▪ applications at the time were scientific.[4]
However, non IBM vendors also wrote Fortran compilers, but with a syntax that would likely fail IBM's
compiler.[4] e American National Standards Institute (ANSI) developed the first Fortran standard in
1966. In 1978, Fortran 77 became the standard until 1991. Fortran 90 supports:
▪ records
▪ pointers to arrays
COBOL
COBOL (1959) stands for "COmmon Business Oriented Language." Fortran manipulated symbols. It was
soon realized that symbols did not need to be numbers, so strings were introduced.[5] e US
Department of Defense influenced COBOL's development, with Grace Hopper being a major
contributor. e statements were English-like and verbose. e goal was to design a language so
managers could read the programs. However, the lack of structured statements hindered this goal.[6]
COBOL's development was tightly controlled, so dialects did not emerge to require ANSI standards. As
a consequence, it was not changed for 15 years until 1974. e 1990s version did make consequential
changes, like object-oriented programming.[6]
Algol
ALGOL (1960) stands for "ALGOrithmic Language." It had a profound influence on programming
language design.[7] Emerging from a commiee of European and American programming language
experts, it used standard mathematical notation and had a readable structured design. Algol was first to
3 of 11 5/9/24, 21:15
define its syntax using the Backus–Naur form.[7] is led to syntax-directed compilers. It added
features like:
▪ block structure, where variables were local to their block

▪ arrays with variable bounds
▪ "for" loops
▪ functions
▪ recursion[7]
Algol's direct descendants include Pascal, Modula-2, Ada, Delphi and Oberon on one branch. On
another branch there's C, C++ and Java.[7]
Basic
BASIC (1964) stands for "Beginner's All Purpose Symbolic Instruction Code." It was developed at
Dartmouth College for all of their students to learn.[8] If a student did not go on to a more powerful
language, the student would still remember Basic.[8] A Basic interpreter was installed in the
microcomputers manufactured in the late 1970s. As the microcomputer industry grew, so did the
language.[8]
Basic pioneered the interactive session.[8] It offered operating system commands within its
environment:
▪ The 'new' command created an empty slate

▪ Statements evaluated immediately
▪ Statements could be programmed by preceding them with a line number
▪ The 'list' command displayed the program
▪ The 'run' command executed the program
However, the Basic syntax was too simple for large programs.[8] Recent dialects added structure and
object-oriented extensions. Microso's Visual Basic is still widely used and produces a graphical user
interface.[9]
C
C programming language (1973) got its name because the language BCPL was replaced with B, and
AT&T Bell Labs called the next version "C." Its purpose was to write the UNIX operating system.[10] C
is a relatively small language -- making it easy to write compilers. Its growth mirrored the hardware
growth in the 1980s.[10] Its growth also was because it has the facilities of assembly language, but uses
a high-level syntax. It added advanced features like:
▪ inline assembler
▪ arithmetic on pointers
▪ pointers to functions
▪ bit operations
▪ freely combining complex operators[10]
4 of 11 5/9/24, 21:15
C allows the programmer to control in which region of memory

data is to be stored. Global variables and static variables require
the fewest clock cycles to store. e stack is automatically used
for the standard variable declarations. Heap memory is returned
to a pointer variable from the malloc() function.
▪ The global and static data region is located just above

the program region. (The program region is
technically called the text region. It's where machine
instructions are stored.)
▪ The global and static data region is technically

two regions.[11] One region is called the
initialized data segment, where variables
declared with default values are stored. The
other region is called the block started by
segment, where variables declared without
default values are stored.
▪ Variables stored in the global and static data Computer memory map
region have their addresses set at compile-time.
They retain their values throughout the life of
the process.
▪ The global and static region stores the global variables that are declared on top of
(outside) the main() function.[12] Global variables are visible to main() and
every other function in the source code.
On the other hand, variable declarations inside of main(), other functions, or within
{ } block delimiters are local variables. Local variables also include formal parameter
variables. Parameter variables are enclosed within the parenthesis of function
definitions.[13] They provide an interface to the function.
▪ Local variables declared using the static prefix are also stored in the global and
static data region.[11] Unlike global variables, static variables are only visible
within the function or block. Static variables always retain their value. An example
usage would be the function int increment_counter(){ static int
counter = 0; counter++; return counter;}
▪ The stack region is a contiguous block of memory located near the top memory
address.[14] Variables placed in the stack are populated from top to bottom.[14] A stack
pointer is a special-purpose register that keeps track of the last memory address
populated.[14] Variables are placed into the stack via the assembly language PUSH
instruction. Therefore, the addresses of these variables are set during runtime. The
method for stack variables to lose their scope is via the POP instruction.
▪ Local variables declared without the static prefix, including formal parameter
5 of 11 5/9/24, 21:15
variables,[15] are called automatic variables[12] and are stored in the stack.[11] They
are visible inside the function or block and lose their scope upon exiting the
function or block.
▪ The heap region is located below the stack.[11] It is populated from the bottom to the
top. The operating system manages the heap using a heap pointer and a list of
allocated memory blocks.[16] Like the stack, the addresses of heap variables are set
during runtime. An out of memory error occurs when the heap pointer and the stack
pointer meet.
▪ C provides the malloc() library function to allocate heap memory.[17] Populating

the heap with data is an additional copy function. Variables stored in the heap are
economically passed to functions using pointers. Without pointers, the entire
block of data would have to be passed to the function via the stack.
C++
In the 1970s, soware engineers needed language support to break large projects down into
modules.[18] One obvious feature was to decompose large projects physically into separate files. A less
obvious feature was to decompose large projects logically into abstract datatypes.[18] At the time,
languages supported concrete (scalar) datatypes like integer numbers, floating-point numbers, and
strings of characters. Concrete datatypes have their representation as part of their name.[19] Abstract
datatypes are structures of concrete datatypes — with a new name assigned. For example, a list of
integers could be called integer_list.
In object-oriented jargon, abstract datatypes are called classes. However, a class is only a definition; no
memory is allocated. When memory is allocated to a class, it's called an object.[20]
Object-oriented imperative languages developed by combining the need for classes and the need for safe
functional programming.[21] A function, in an object-oriented language, is assigned to a class. An
assigned function is then referred to as a method, member function, or operation. Object-oriented
programming is executing operations on objects.[22]
Object-oriented languages support a syntax to model subset/superset relationships. In set theory, an

element of a subset inherits all the aributes contained in the superset. For example, a student is a
person. erefore, the set of students is a subset of the set of persons. As a result, students inherit all
the aributes common to all persons. Additionally, students have unique aributes that other persons
don't have. Object-oriented languages model subset/superset relationships using inheritance.[23] Object-
oriented programming became the dominant language paradigm by the late 1990s.[18]
C++ (1985) was originally called "C with Classes."[24] It was designed to expand C's capabilities by
adding the object-oriented facilities of the language Simula.[25]
An object-oriented module is composed of two files. e definitions file is called the header file. Here is
a C++ header file for the GRADE class in a simple school application:
// grade.h
// -------
6 of 11 5/9/24, 21:15
// Used to allow multiple source files to include

// this header file without duplication errors.
// See: https://en.wikipedia.org/wiki/Include_guard
// ----------------------------------------------
#ifndef GRADE_H
#define GRADE_H
class GRADE {
public:
// This is the constructor operation.
// ----------------------------------
GRADE ( const char letter );
// This is a class variable.

// -------------------------
char letter;
// This is a member operation.

// ---------------------------
int grade_numeric( const char letter );
// This is a class variable.

// -------------------------
int numeric;
};
#endif
A constructor operation is a function with the same name as the class name.[26] It is executed when the
calling operation executes the new statement.
A module's other file is the source file. Here is a C++ source file for the GRADE class in a simple school
application:
// grade.cpp
// ---------
#include "grade.h"
GRADE::GRADE( const char letter )

{
// Reference the object using the keyword 'this'.
// ----------------------------------------------
this->letter = letter;
// This is Temporal Cohesion

// -------------------------
this->numeric = grade_numeric( letter );
}
int GRADE::grade_numeric( const char letter )

{
if ( ( letter == 'A' || letter == 'a' ) )
return 4;
else
if ( ( letter == 'B' || letter == 'b' ) )
return 3;
else
if ( ( letter == 'C' || letter == 'c' ) )
return 2;
else
if ( ( letter == 'D' || letter == 'd' ) )
return 1;
else
if ( ( letter == 'F' || letter == 'f' ) )
return 0;
else
return -1;
}
Here is a C++ header file for the PERSON class in a simple school application:
7 of 11 5/9/24, 21:15
// person.h
// --------
#ifndef PERSON_H
#define PERSON_H
class PERSON {
public:
PERSON ( const char *name );
const char *name;
};
#endif
Here is a C++ source file for the PERSON class in a simple school application:
// person.cpp
// ----------
#include "person.h"
PERSON::PERSON ( const char *name )

{
this->name = name;
}
Here is a C++ header file for the STUDENT class in a simple school application:
// student.h
// ---------
#ifndef STUDENT_H
#define STUDENT_H
#include "person.h"
#include "grade.h"
// A STUDENT is a subset of PERSON.

// --------------------------------
class STUDENT : public PERSON{
public:
STUDENT ( const char *name );
~STUDENT();
GRADE *grade;
};
#endif
Here is a C++ source file for the STUDENT class in a simple school application:
// student.cpp
// -----------
#include "student.h"
#include "person.h"
STUDENT::STUDENT ( const char *name ):

// Execute the constructor of the PERSON superclass.
// -------------------------------------------------
PERSON( name )
{
// Nothing else to do.
// -------------------
}
STUDENT::~STUDENT()
{
// deallocate grade's memory
// to avoid memory leaks.
// -------------------------------------------------
delete this->grade;
}
8 of 11 5/9/24, 21:15
Here is a driver program for demonstration:
// student_dvr.cpp
// ---------------
#include <iostream>
#include "student.h"
int main( void )

{
STUDENT *student = new STUDENT( "The Student" );
student->grade = new GRADE( 'a' );
std::cout
// Notice student inherits PERSON's name
<< student->name
<< ": Numeric grade = "
<< student->grade->numeric
<< "\n";
// deallocate student's memory

// to avoid memory leaks.
// -------------------------------------------------
delete student;
return 0;
}
Here is a makefile to compile everything:
# makefile
# --------
all: student_dvr
clean:
rm student_dvr *.o
student_dvr: student_dvr.cpp grade.o student.o person.o

c++ student_dvr.cpp grade.o student.o person.o -o student_dvr
grade.o: grade.cpp grade.h

c++ -c grade.cpp
student.o: student.cpp student.h

c++ -c student.cpp
person.o: person.cpp person.h

c++ -c person.cpp
See also
▪ Functional programming
▪ Comparison of programming paradigms
▪ Reactive programming
▪ History of programming languages
▪ List of imperative programming languages
Notes
1. Reconfigurable computing is a notable exception.
9 of 11 5/9/24, 21:15
References
1. Jain, Anisha (2022-12-10). "Javascript Promises— Is There a Better Approach?" (https://
medium.datadriveninvestor.com/javascript-promises-is-there-a-better-approach-dd6a0
a329131). Medium. Retrieved 2022-12-20.
2. "Imperative programming: Overview of the oldest programming paradigm" (https://w
ww.ionos.com/digitalguide/websites/web-development/imperative-programming/).
IONOS Digitalguide. 21 May 2021. Retrieved 2022-05-03.
3. Bruce Eckel (2006). Thinking in Java (https://books.google.com/books?id=bQVvAQAAQB
AJ&q=imperative&pg=PA24). Pearson Education. p. 24. ISBN 978-0-13-187248-6.
4. Wilson, Leslie B. (2001). Comparative Programming Languages, Third Edition. Addison-
Wesley. p. 16. ISBN 0-201-71012-9.
Wesley. p. 24. ISBN 0-201-71012-9.
Wesley. p. 25. ISBN 0-201-71012-9.
Wesley. p. 19. ISBN 0-201-71012-9.
Wesley. p. 30. ISBN 0-201-71012-9.
Wesley. p. 31. ISBN 0-201-71012-9.
Wesley. p. 37. ISBN 0-201-71012-9.
11. "Memory Layout of C Programs" (https://www.geeksforgeeks.org/memory-layout-of-c-
program/). 12 September 2011.
12. Kernighan, Brian W.; Ritchie, Dennis M. (1988). The C Programming Language Second
Edition. Prentice Hall. p. 31. ISBN 0-13-110362-8.
Wesley. p. 128. ISBN 0-201-71012-9.
14. Kerrisk, Michael (2010). The Linux Programming Interface. No Starch Press. p. 121.
ISBN 978-1-59327-220-3.
15. Kerrisk, Michael (2010). The Linux Programming Interface. No Starch Press. p. 122.
ISBN 978-1-59327-220-3.
Wesley. p. 38. ISBN 0-201-71012-9.
19. Stroustrup, Bjarne (2013). The C++ Programming Language, Fourth Edition. Addison-
Wesley. p. 65. ISBN 978-0-321-56384-2.
Wesley. p. 193. ISBN 0-201-71012-9.
Wesley. p. 39. ISBN 0-201-71012-9.
Wesley. p. 35. ISBN 0-201-71012-9.
10 of 11 5/9/24, 21:15
Wesley. p. 192. ISBN 0-201-71012-9.
Wesley. p. 22. ISBN 978-0-321-56384-2.
Wesley. p. 21. ISBN 978-0-321-56384-2.
Wesley. p. 49. ISBN 978-0-321-56384-2.
▪ 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.
Originally based on the article 'Imperative programming' by Stan Seibert, from Nupedia,
licensed under the GNU Free Documentation License.
Retrieved from "https://en.wikipedia.org/w/index.php?title=Imperative_programming&oldid=1215741788"
11 of 11 5/9/24, 21:15

Imperative Programming - Wikipedia

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Imperative Programming - Wikipedia

Uploaded by

Copyright:

Available Formats

Imperative programming - Wikipedia https://en.wikipedia.

Procedural programming could be considered a step toward declarative programming. A programmer

Rationale and foundations of imperative programming

Assignment statements, in imperative paradigm, perform an operation on information located in

History of imperative and object-oriented languages

▪ programming and debugging costs were below computer running costs

▪ block structure, where variables were local to their block

▪ The 'new' command created an empty slate

C allows the programmer to control in which region of memory

▪ The global and static data region is located just above

▪ The global and static data region is technically

▪ C provides the malloc() library function to allocate heap memory.[17] Populating

Object-oriented languages support a syntax to model subset/superset relationships. In set theory, an

// Used to allow multiple source files to include

// This is a class variable.

// This is a member operation.

// This is a class variable.

GRADE::GRADE( const char letter )

// This is Temporal Cohesion

int GRADE::grade_numeric( const char letter )

PERSON::PERSON ( const char *name )

// A STUDENT is a subset of PERSON.

STUDENT::STUDENT ( const char *name ):

Here is a driver program for demonstration:

int main( void )

// deallocate student's memory

Here is a makeﬁle to compile everything:

student_dvr: student_dvr.cpp grade.o student.o person.o

grade.o: grade.cpp grade.h

student.o: student.cpp student.h

person.o: person.cpp person.h

▪ Pratt, Terrence W. and Marvin V. Zelkowitz. Programming Languages: Design and

Retrieved from "https://en.wikipedia.org/w/index.php?title=Imperative_programming&oldid=1215741788"

You might also like