Procedural programming
This article needs additional citations for verification. (April 2008) |
Procedural programming is a programming paradigm, classified as imperative programming,[1] that involves implementing the behavior of a computer program as procedures (a.k.a. functions, subroutines) that call each other. The resulting program is a series of steps that forms a hierarchy of calls to its constituent procedures.
The first major procedural programming languages appeared c. 1957–1964, including Fortran, ALGOL, COBOL, PL/I and BASIC.[2] Pascal and C were published c. 1970–1972.
Development practices
Certain software development practices are often employed with procedural programming in order to enhance quality and lower development and maintenance costs.
Modularity and scoping
Minimizing the
A program lacking modularity or wide scoping tends to have procedures that consume many
Sharing
Since a procedure can specify a well-defined interface and be self-contained it supports code reuse -- in particular via the software library.
Comparison with other programming paradigms
Imperative programming
Procedural programming is classified as a imperative programming, because it involves direct command of execution.
Procedural is a sub-class of imperative since procedural includes block and scope concepts, whereas imperative describes a more general concept that does not require such features. Procedural languages generally use reserved words that define blocks, such as if
, while
, and for
, to implement control flow, whereas non-structured imperative languages (i.e. assembly language) use goto and branch tables for this purpose.
Object-oriented programming
Also classified as imperative,
Some OOP languages support the class concept which allows for creating an object based on a definition.
Nomenclature varies between the two, although they have similar semantics:
Procedural | Object-oriented |
---|---|
Procedure | Method
|
Record | Object |
Module | Class |
Procedure call | Message |
Functional programming
The principles of modularity and code reuse in functional languages are fundamentally the same as in procedural languages, since they both stem from structured programming. For example:
- Procedures correspond to functions. Both allow the reuse of the same code in various parts of the programs, and at various points of its execution.
- By the same token, procedure calls correspond to function application.
- Functions and their modularly separated from each other in the same manner, by the use of function arguments, return values and variable scopes.
The main difference between the styles is that functional programming languages remove or at least deemphasize the imperative elements of procedural programming. The feature set of functional languages is therefore designed to support writing programs as much as possible in terms of pure functions:
- Whereas procedural languages model execution of the program as a sequence of imperative commands that may implicitly alter shared state, functional programming languages model execution as the evaluation of complex expressions that only depend on each other in terms of arguments and return values. For this reason, functional programs can have a free order of code execution, and the languages may offer little control over the order in which various parts of the program are executed; for example, the arguments to a procedure invocation in Scheme are evaluated in an arbitrary order.
- Functional programming languages support (and heavily use) Algol 68.
- Functional programming languages tend to rely on tail call optimization and higher-order functionsinstead of imperative looping constructs.
Many functional languages, however, are in fact impurely functional and offer imperative/procedural constructs that allow the programmer to write programs in procedural style, or in a combination of both styles. It is common for input/output code in functional languages to be written in a procedural style.
There do exist a few esoteric functional languages (like Unlambda) that eschew structured programming precepts for the sake of being difficult to program in (and therefore challenging). These languages are the exception to the common ground between procedural and functional languages.
Logic programming
In logic programming, a program is a set of premises, and computation is performed by attempting to prove candidate theorems. From this point of view, logic programs are declarative, focusing on what the problem is, rather than on how to solve it.
However, the
- H :- B1, …, Bn.
have a dual interpretation, both as procedures
- to show/solve H, show/solve B1 and … and Bn
and as logical implications:
- B1 and … and Bn implies H.
A skilled logic programmer uses the procedural interpretation to write programs that are effective and efficient, and uses the declarative interpretation to help ensure that programs are correct.
See also
- Comparison of programming paradigms
- Declarative programming
- Functional programming (contrast)
- Imperative programming
- Logic programming
- Object-oriented programming
- Programming paradigms
- Programming language
- Structured programming
- SQL procedural extensions
References
- ^ "Programming Paradigms".
- S2CID 58175293.
- ^ Stevenson, Joseph (August 2013). "Procedural programming vs object-oriented programming". neonbrand.com. Retrieved 2013-08-19.
External links
- Procedural Languages at Curlie