View source for Programming paradigm

{{Short description|Programming language classification}}

'''Programming paradigms''' are a way to classify [[Programming language|programming language]]s based on their features. Languages can be classified into multiple paradigms.

Some paradigms are concerned mainly with implications for the [[Execution model|execution model]] of the language, such as allowing [[Side effect (computer science)|side effects]], or whether the sequence of operations is defined by the execution model.  Other paradigms are concerned mainly with the way that code is organized, such as grouping a code into units along with the state that is modified by the code.  Yet others are concerned mainly with the style of [[Syntax (programming languages)|syntax]] and [[Formal grammar|grammar]].

Some common programming paradigms are,<ref>Nørmark, Kurt. ''[http://people.cs.aau.dk/~normark/prog3-03/html/notes/paradigms_themes-paradigm-overview-section.html Overview of the four main programming paradigms]''. Aalborg University, 9 May 2011. Retrieved 22 September 2012.</ref><ref>{{cite web |author=Frans Coenen |date=1999-10-11 |title=Characteristics of declarative programming languages |url=http://cgi.csc.liv.ac.uk/~frans/OldLectures/2CS24/declarative.html#detail |url-status=live |access-date=2014-02-20 |website=cgi.csc.liv.ac.uk |language=en-US|archive-date=2014-02-27|archive-url=https://web.archive.org/web/20140227142223/http://cgi.csc.liv.ac.uk/~frans/OldLectures/2CS24/declarative.html}}</ref><ref name="symbolic-programming-lisp">{{cite web
 |url          = http://www.ai.uga.edu/mc/LispNotes/FirstLectureOnSymbolicProgramming.pdf
 |title        = CSCI/ARTI 4540/6540: First Lecture on Symbolic Programming and LISP
 |date         = 2010-08-23
 |access-date   = 2013-11-20
 |author       = Michael A. Covington
 |publisher    = University of Georgia
 |archive-url  = https://web.archive.org/web/20120307124013/http://www.ai.uga.edu/mc/LispNotes/FirstLectureOnSymbolicProgramming.pdf
 |archive-date = 2012-03-07
 |url-status = dead
}}</ref>
* [[Imperative programming|Imperative]] in which the programmer instructs the machine how to change its state,
** [[Procedural programming|procedural]] which groups [[Instruction set architecture|instructions]] into procedures, 
** [[Object-oriented programming|object-oriented]] which groups instructions with the part of the state they operate on,
* [[Declarative programming|Declarative]] in which the programmer merely declares properties of the desired result, but not how to compute it
** [[Functional programming|functional]] in which the desired result is declared as the value of a series of function applications,
** [[Logic programming|logic]] in which the desired result is declared as the answer to a question about a system of facts and rules,
** [[Reactive programming|reactive]] in which the desired result is declared with data streams and the propagation of change

[[Symbolic programming|Symbolic]] techniques such as [[Reflection (computer programming)|reflection]], which allow the program to refer to itself, might also be considered as a programming paradigm. However, this is compatible with the major paradigms and thus is not a real paradigm in its own right.

For example, languages that fall into the '''imperative paradigm''' have two main features: they state the order in which operations occur, with constructs that explicitly control that order, and they allow side effects, in which state can be modified at one point in time, within one unit of code, and then later read at a different point in time inside a different unit of code.  The communication between the units of code is not explicit.  Meanwhile, in '''object-oriented''' programming, code is organized into objects that contain a state that is only modified by the code that is part of the object.  Most object-oriented languages are also imperative languages.  In contrast, languages that fit the '''declarative paradigm''' do not state the order in which to execute operations.  Instead, they supply a number of available operations in the system, along with the conditions under which each is allowed to execute.<ref>{{Cite web |title=Programming paradigms: What are the principles of programming? |url=https://www.ionos.com/digitalguide/websites/web-development/programming-paradigms/ |url-status=live |access-date=2022-05-03 |website=IONOS Digitalguide |date=20 April 2020 |language=en-US |archive-url=https://web.archive.org/web/20220629200645/https://www.ionos.com/digitalguide/websites/web-development/programming-paradigms/ |archive-date=Jun 29, 2022}}</ref>  The implementation of the language's execution model tracks which operations are free to execute and chooses the order independently. More at  [[Comparison of multi-paradigm programming languages]].

== Overview ==
[[Image:Programming paradigms.svg|thumb|250px|left|Overview of the various programming paradigms according to Peter Van Roy<ref>{{Cite web
 |url= http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf
 |title= Programming Paradigms: What Every Programmer Should Know
 |date= 2009-05-12 |access-date= 2014-01-27
 |author= Peter Van Roy |publisher= info.ucl.ac.be
 }}</ref>{{rp|5}}<ref name="Van-RoyHaridi2004">{{cite book|author1=Peter Van-Roy|author2=Seif Haridi|title=Concepts, Techniques, and Models of Computer Programming|url=https://books.google.com/books?id=_bmyEnUnfTsC|year=2004|publisher=MIT Press|isbn=978-0-262-22069-9}}</ref>]]

Just as [[Software engineering|software engineering]] (as a process) is defined by differing ''methodologies'', so the [[Programming language|programming language]]s (as models of computation) are defined by differing ''paradigms''. Some languages are designed to support one paradigm ([[Smalltalk]] supports object-oriented programming, [[Haskell (programming language)|Haskell]] supports functional programming), while other programming languages support multiple paradigms (such as [[Object Pascal]], [[C++]], [[Java (programming language)|Java]], [[JavaScript]], [[C Sharp (programming language)|C#]], [[Scala (programming language)|Scala]], [[Visual Basic]], [[Common Lisp]], [[Scheme (programming language)|Scheme]], [[Perl]], [[Organization:PHP|PHP]], [[Python (programming language)|Python]], [[Ruby (programming language)|Ruby]], [[Oz (programming language)|Oz]], and [[F Sharp (programming language)|F#]]). For example, programs written in C++, Object Pascal or PHP can be purely [[Procedural programming|procedural]], purely [[Object-oriented programming|object-oriented]], or can contain elements of both or other paradigms. Software designers and programmers decide how to use those paradigm elements.

In object-oriented programming, programs are treated as a set of interacting objects. In [[Functional programming|functional programming]], programs are treated as a sequence of stateless function evaluations. When programming computers or systems with many processors, in [[Process-oriented programming|process-oriented programming]], programs are treated as sets of concurrent processes that act on a logical shared [[Data structure|data structure]]s.

Many programming paradigms are as well known for the techniques they ''forbid'' as for those they ''enable''. For instance, pure functional programming disallows use of side-effects, while [[Structured programming|structured programming]] disallows use of the [[Goto|goto]] statement. Partly for this reason, new paradigms are often regarded as doctrinaire or overly rigid by those accustomed to earlier styles.<ref name="rubin87goto">{{cite journal|author=Frank Rubin |date=March 1987 |url=http://www.ecn.purdue.edu/ParaMount/papers/rubin87goto.pdf |title='GOTO Considered Harmful' Considered Harmful |journal=Communications of the ACM |volume=30 |issue=3 |pages=195–196 |doi=10.1145/214748.315722 |s2cid=6853038 |url-status = dead|archive-url=https://web.archive.org/web/20090320002214/http://www.ecn.purdue.edu/ParaMount/papers/rubin87goto.pdf |archive-date=March 20, 2009}}</ref> Yet, avoiding certain techniques can make it easier to understand program behavior, and to [[Automated theorem proving|prove theorems]] about program correctness.

Programming paradigms can also be compared with ''[[Programming model|programming model]]s'', which allows invoking an [[Execution model|execution model]] by using only an API. Programming models can also be classified into paradigms based on features of the execution model.

For [[Parallel computing|parallel computing]], using a programming model instead of a language is common.  The reason is that details of the parallel hardware leak into the abstractions used to program the hardware.  This causes the programmer to have to map patterns in the algorithm onto patterns in the execution model (which have been inserted due to leakage of hardware into the abstraction).  As a consequence, no one parallel programming language maps well to all computation problems.  Thus, it is more convenient to use a base sequential language and insert API calls to parallel execution models via a programming model.  Such parallel programming models can be classified according to abstractions that reflect the hardware, such as [[Shared memory|shared memory]], [[Distributed memory|distributed memory]] with [[Message passing|message passing]], notions of ''place'' visible in the code, and so forth.  These can be considered flavors of programming paradigm that apply to only parallel languages and programming models.

== Criticism ==
Some programming language researchers criticise the notion of paradigms as a classification of programming languages, e.g. Harper,<ref>{{cite web|first=Robert|last=Harper|title=What, if anything, is a programming-paradigm?|url=http://www.cambridgeblog.org/2017/05/what-if-anything-is-a-programming-paradigm/|website = FifteenEightyFour|publisher = Cambridge University Press|date = 1 May 2017}}</ref> and Krishnamurthi.<ref>{{cite journal |first= Shriram |last= Krishnamurthi |publisher= ACM |url= http://dl.acm.org/citation.cfm?id=1480846 |title= Teaching programming languages in a post-linnaean age |journal= ACM SIGPLAN Notices |date= November 2008 |volume= 43 |issue= 11 |pages= 81–83|doi= 10.1145/1480828.1480846 |s2cid= 35714982 }}.</ref>  They argue that many programming languages cannot be strictly classified into one paradigm, but rather include features from several paradigms. See [[Comparison of multi-paradigm programming languages]].

== History ==
Different approaches to programming have developed over time, being identified as such either at the time or retrospectively. An early approach consciously identified as such is [[Structured programming|structured programming]], advocated since the mid 1960s. The concept of a "programming paradigm" as such dates at least to 1978, in the Turing Award lecture of [[Biography:Robert W. Floyd|Robert W. Floyd]], entitled ''The Paradigms of Programming'', which cites the notion of paradigm as used by [[Biography:Thomas Kuhn|Thomas Kuhn]] in his ''The Structure of Scientific Revolutions'' (1962).<ref>{{Cite journal |last1= Floyd |first1= R. W. |title= The paradigms of programming | doi= 10.1145/359138.359140 |journal= Communications of the ACM |volume= 22 |issue= 8 |pages= 455–460 |year= 1979 |doi-access= free }}</ref> Early programming languages did not have clearly defined programming paradigms and sometimes programs made extensive use of goto statements, liberal use of these statements lead to "[[Spaghetti code|spaghetti code]]" which is difficult to work with. This led to the development of structured programming paradigms that disallowed the use of goto statements and only allow the use of clearly defined programming constructs.<ref>{{cite book | url=https://books.google.com/books?id=POAplMgrk4wC&dq=programming+paradigm+structured&pg=PA20 | title=Java 5: Objects First | isbn=9780763737207 | last1=Soroka | first1=Barry I. | year=2006 }}</ref>

=== Machine code ===
The [[Low-level programming language|lowest-level]] programming paradigms are [[Machine code|machine code]], which directly represents the instructions (the contents of program memory) as a sequence of numbers, and [[Assembly language|assembly language]] where the machine instructions are represented by mnemonics and [[Memory address|memory address]]es can be given symbolic labels. These are sometimes called [[First-generation programming language|first-]] and [[Second-generation programming language|second-generation]] languages.

In the 1960s, assembly languages were developed to support library COPY and quite sophisticated conditional macro generation and preprocessing abilities, CALL to ([[Subroutine|subroutine]]s), external variables and common sections (globals), enabling significant code re-use and isolation from hardware specifics via the use of logical operators such as READ/WRITE/GET/PUT. Assembly was, and still is, used for time-critical systems and often in [[Embedded system|embedded system]]s as it gives the most direct control of what the machine does.

=== Procedural languages ===
The next advance was the development of procedural languages. These [[Third-generation programming language|third-generation]] languages (the first described as [[High-level programming language|high-level languages]]) use vocabulary related to the problem being solved. For example,
* COmmon Business Oriented Language ([[COBOL]]){{snd}} uses terms like [[Computer file|file]], [[Software:Move (command)|move]] and [[Software:Copy (command)|copy]].
* FORmula TRANslation (FORTRAN){{snd}} using mathematical language terminology, it was developed mainly for scientific and engineering problems.
* ALGOrithmic Language ([[ALGOL]]){{snd}} focused on being an appropriate language to define [[Algorithm|algorithm]]s, while using mathematical language terminology, targeting scientific and engineering problems, just like FORTRAN.
* Programming Language One (PL/I){{snd}} a hybrid commercial-scientific general purpose language supporting [[Pointer (computer programming)|pointer]]s.
* Beginners All purpose Symbolic Instruction Code ([[BASIC]]){{snd}} it was developed to enable more people to write programs.
* [[C (programming language)|C]]{{snd}} a general-purpose programming language, initially developed by [[Biography:Dennis Ritchie|Dennis Ritchie]] between 1969 and 1973 at AT&T Bell Labs.

All these languages follow the procedural paradigm. That is, they describe, step by step, exactly the procedure that should, according to the particular programmer at least, be followed to solve a specific problem. The [[Chemistry:Efficacy|efficacy]] and [[Algorithmic efficiency|efficiency]] of any such solution are both therefore entirely subjective and highly dependent on that programmer's experience, inventiveness, and ability.

=== Object-oriented programming ===
{{Main|Object-oriented programming}}

Following the widespread use of procedural languages, [[Object-oriented programming|object-oriented programming]] (OOP) languages were created, such as [[Simula]], [[Smalltalk]], [[C++]], [[Eiffel (programming language)|Eiffel]], [[Python (programming language)|Python]], [[Organization:PHP|PHP]], [[Java (programming language)|Java]], and [[C Sharp (programming language)|C#]]. In these languages, [[Data|data]] and methods to manipulate it are kept as one unit called an [[Object (computer science)|object]].  With perfect [[Encapsulation (computer programming)|encapsulation]], one of the distinguishing features of OOP, the only way that another object or user would be able to access the data is via the object's ''methods''. Thus, an object's inner workings may be changed without affecting any code that uses the object. There is still some [[Object-oriented programming#Criticism|controversy]] raised by Alexander Stepanov, [[Biography:Richard Stallman|Richard Stallman]]<ref>{{cite web|url=http://groups.google.com/group/comp.emacs.xemacs/browse_thread/thread/d0af257a2837640c/37f251537fafbb03?lnk=st&q=%22Richard+Stallman%22+oop&rnum=5&hl=en#37f251537fafbb03|title=Mode inheritance, cloning, hooks & OOP (Google Groups Discussion)}}</ref> and other programmers, concerning the efficacy of the OOP paradigm versus the procedural paradigm. The need for every object to have associative methods leads some skeptics to associate OOP with [[Software bloat|software bloat]]; an attempt to resolve this dilemma came through [[Polymorphism (computer science)|polymorphism]].

Because object-oriented programming is considered a paradigm, not a language, it is possible to create even an object-oriented assembler language. [[Software:High Level Assembly|High Level Assembly]] (HLA) is an example of this that fully supports advanced data types and object-oriented assembly language programming{{snd}} despite its early origins. Thus, differing programming paradigms can be seen rather like ''motivational [[Philosophy:Meme|meme]]s'' of their advocates, rather than necessarily representing progress from one level to the next.{{Citation needed|date=March 2018}} Precise comparisons of competing paradigms' efficacy are frequently made more difficult because of new and differing terminology applied to similar entities and processes together with numerous implementation distinctions across languages.

=== Further paradigms ===
[[Literate programming]], as a form of [[Imperative programming|imperative programming]], structures programs as a human-centered web, as in a [[Hypertext|hypertext]] essay: documentation is integral to the program, and the program is structured following the logic of prose exposition, rather than compiler convenience.

Independent of the imperative branch, [[Declarative programming|declarative programming]] paradigms were developed. In these languages, the computer is told what the problem is, not how to solve the problem{{snd}} the program is structured as a set of properties to find in the expected result, not as a procedure to follow. Given a database or a set of rules, the computer tries to find a solution matching all the desired properties. An archetype of a declarative language is the [[Fourth-generation programming language|fourth generation language]] [[SQL]], and the family of functional languages and logic programming.

[[Functional programming]] is a subset of declarative programming. Programs written using this paradigm use [[Subroutine|functions]], blocks of code intended to behave like [[Function (mathematics)|mathematical functions]]. Functional languages discourage changes in the value of variables through [[Assignment (computer science)|assignment]], making a great deal of use of [[Recursion (computer science)|recursion]] instead.

The [[Logic programming|logic programming]] paradigm views computation as [[Automated reasoning|automated reasoning]] over a body of knowledge. Facts about the [[Software:Domain (software engineering)|problem domain]] are expressed as logic formulas, and programs are executed by applying inference rules over them until an answer to the problem is found, or the set of formulas is proved inconsistent.

[[Symbolic programming]] is a paradigm that describes programs able to manipulate formulas and program components as data.<ref name="symbolic-programming-lisp" />  Programs can thus effectively modify themselves, and appear to "learn", making them suited for applications such as [[Artificial intelligence|artificial intelligence]], [[Expert system|expert system]]s, natural-language processing and computer games.  Languages that support this paradigm include [[Lisp (programming language)|Lisp]] and [[Prolog]].<ref>{{cite web
 |url= http://www.allbusiness.com/glossaries/symbolic-programming/4950308-1.html
 |title= Business glossary: Symbolic programming definition
 |access-date= 2014-07-30
 |website= allbusiness.com
}}</ref>

[[Differentiable programming]] structures programs so that they can be differentiated throughout, usually via [[Automatic differentiation|automatic differentiation]].<ref>{{Citation|last1=Wang|first1=Fei|title=Backpropagation with Callbacks: Foundations for Efficient and Expressive Differentiable Programming|date=2018|url=http://papers.nips.cc/paper/8221-backpropagation-with-callbacks-foundations-for-efficient-and-expressive-differentiable-programming.pdf|work=Advances in Neural Information Processing Systems 31|pages=10201–10212|editor-last=Bengio|editor-first=S.|publisher=Curran Associates, Inc.|access-date=2019-02-13|last2=Decker|first2=James|last3=Wu|first3=Xilun|last4=Essertel|first4=Gregory|last5=Rompf|first5=Tiark|editor2-last=Wallach|editor2-first=H.|editor3-last=Larochelle|editor3-first=H.|editor4-last=Grauman|editor4-first=K.}}</ref><ref name="innes">{{Cite journal|last=Innes|first=Mike|date=2018|title=On Machine Learning and Programming Languages|url=http://www.sysml.cc/doc/37.pdf|journal=SysML Conference 2018|access-date=2019-02-13|archive-url=https://web.archive.org/web/20180920175619/http://www.sysml.cc/doc/37.pdf|archive-date=2018-09-20|url-status=dead}}</ref>

== Support for multiple paradigms{{anchor|Multi-paradigm}} ==

Most [[Programming language|programming language]]s support more than one programming paradigm to allow programmers to use the most suitable programming style and associated language constructs for a given job.<ref>{{cite web |title=Multi-Paradigm Programming Language |url=https://developer.mozilla.org/en-US/docs/multiparadigmlanguage.html |website=Mozilla Developer Network |date= Jun 21, 2013 |publisher=[[Organization:Mozilla Foundation|Mozilla Foundation]] |archive-url=https://web.archive.org/web/20130821052407/https://developer.mozilla.org/en-US/docs/multiparadigmlanguage.html |archive-date=21 August 2013}}</ref>

== See also ==

{{div col}}
* [[Comparison of programming paradigms]]
* [[Domain-specific language]]
* [[Modeling language]]
* [[Programming domain]]
* [[Turing completeness]]
* [[Von Neumann programming languages]]
{{div col end}}

== References ==
{{Reflist}}

==External links==
*[http://www.info.ucl.ac.be/~pvr/paradigms.html Classification of the principal programming paradigms]
*[http://www.janeve.me/articles/understanding-programming-paradigms How programming paradigms evolve and get adopted?]

{{Navboxes
| title= Software engineering
| state= collapsed
| list=
{{Computer language}}
{{Software engineering}}
{{Computer science}}
}}
{{Navboxes
| title= Programming
| state= collapsed
| list=
{{Programming language generations}}
{{Major programming languages}}
{{Types of programming languages}}
}}

{{Computer_science}}

{{DEFAULTSORT:Programming paradigm}}
[[Category:Programming paradigms| ]]
[[Category:Programming language classification]]
[[Category:Programming language topics]]

{{Sourceattribution|Programming paradigm}}