Procedural programming is a programming paradigm based upon the concept of the modularity and scope of program code (i.e., the data viewing range of an executable code statement). A main procedural program is composed of one or more modules (also called packages or units ), either coded by the same programmer or pre-coded by someone else and provided in a code library.

Each module is composed of one or more subprograms (which may consist of procedures, functions, subroutines or methods, depending on programming language). It is possible for a procedural program to have multiple levels or scopes, with subprograms defined inside other subprograms. Each scope can contain names which cannot be seen in outer scopes.

Procedural programming offers many benefits over simple sequential programming since procedural code:

• is easier to read and more maintainable
• is more flexible
• facilitates the practice of good program design

Procedural programming languages facilitate the programmer's task in following a procedural programming approach.

The canonical example of a procedural programming language is ALGOL. Others include Fortran, PL/I, Modula-2, and Ada.

Procedural programming and imperative programming are interchangeable terms. An alternative view is that a non-imperative yet procedural language is the Logo programming language, which specifies sequences of steps to perform, but does not have an internal state (imperative languages would be defined as procedural languages having an internal state). However the position of the turtle in Logo is the program state, and it can be argued that whether this is held internally or somewhere on the floor is immaterial to the program. Hence Logo too is a stateful language, and procedural programming and imperative programming are synonyms.

See also

• Functional programming (contrast)
• Imperative programming ((nearly) synonymous)
• Programming paradigms
• Programming language

External link

• Procedural programming languages