Imperative programming Procedural programming is classified as an
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,
object-oriented programming (OOP) involves dividing a program implementation into objects that expose behavior (methods) and data (members) via a well-defined interface. In contrast, procedural programming is about dividing the program implementation into
variables,
data structures, and
subroutines. An important distinction is that while procedural involves procedures to operate on data structures, OOP bundles the two together. An object is a data structure and the behavior associated with that data structure. 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:
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)
first-class functions,
anonymous functions and
closures, although these concepts have also been included in procedural languages at least since
Algol 68. • Functional programming languages tend to rely on
tail call optimization and
higher-order functions instead 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
backward reasoning technique, implemented by
SLD resolution, used to solve problems in logic programming languages such as
Prolog, treats programs as goal-reduction procedures. Thus clauses of the form: : have a dual interpretation, both as procedures :to show/solve , show/solve and … and and as logical implications: :. 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 ==