View source for Programming paradigm

{{Sidebar
| title        = Programming paradigms
| name         = Programming paradigms
| contentstyle = text-align: left
| content1     =
* [[Declarative programming|Declarative]] (very different from: [[Imperative programming|Imperative]])
** [[Functional programming|Functional]]
*** [[Tacit programming|Pointfree]]
** [[Logic programming|Logic]]
** [[Event-driven programming|Event-driven]]
* [[Imperative programming|Imperative]] (very different from: [[Declarative programming|Declarative]])
** [[Procedural programming|Procedural]]
*** [[Structured programming|Structured]]
** [[Object-oriented programming|Object-oriented]]
* [[Parallel computing|Parallel]]
}}

'''Programming [[paradigm]]s''' are a way of grouping [[programming language]]s by what they do. Languages can be in more than one paradigm.

Some paradigms look at the way the code is run, such as allowing [[Side effect (computer science)|side effects]], or having to do things in a certain order. Other paradigms look at the way that code is grouped, such as [[Monolithic system|putting code into one or two pieces]] (or instead, [[Modular programming|many small pieces]]).  Some other paradigms look at the [[syntax|order]] and [[grammar|pieces]] that make the program the way it is.

There are two main groups of paradigms, '''imperative''' and '''declarative'''. A language can be both at the same time.<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
 |accessdate   = 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><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>

== Imperative programming ==
In imperative programs, [[programmer]]s give the computer '''a set of ordered steps''' that need to be done in order to do something. If someone wanted the computer to draw a cat face, they might give directions like "Draw a circle here, draw two smaller circles there, draw two [[triangle]]s on top" and so on. Imperative programs sometimes have a lot of [[Side effect (computer science)|side effects]].

There are two major imperative paradigms, and a lot of the time a language will have both:

*[[Structured language|Structured]]{{snd}}The computer is given directions that are always in a certain order. Steps like "go back to step 3" (known as [[goto|goto statements]]) are not allowed.
**[[Procedural programming|Procedural]]{{snd}}The program lets the [[programmer]] give a name to a list of orders, which turns those orders into a "procedure" they can use later. Most structured languages are also procedural.
* [[Object-oriented programming|Object-Oriented]]{{snd}}[[Idea]]s are explained to the computer using [[Object (computer science)|objects]], pieces of code that have a set of [[Method (computer science)|orders they can be given]] and [[Property (computer science)|some information about them]].

== Declarative programming ==
In declarative paradigms, the [[programmer]] tells the computer '''what''' to do instead of '''how''' to do it. If they wanted the computer to draw a cat face, they might give directions like "Draw a face, draw two eyes, two ears, and a mouth".

The most well-known declarative paradigms are:<ref>{{cite web
 |url= http://cgi.csc.liv.ac.uk/~frans/OldLectures/2CS24/declarative.html#detail
 |title= Characteristics of declarative programming languages
 |date= 1999-10-11 |accessdate= 2014-02-20
 |author= Frans Coenen |website= cgi.csc.liv.ac.uk
}}</ref>

*[[Functional programming|Functional]]{{snd}}Most of the work is done by [[Function (mathematics)|functions]] with no [[Side effect (computer science)|side effects]].
*[[Logic programming|Logic]]{{snd}}A set of facts are stated, and then one or more "questions" are asked.
*[[Event-driven programming|Event-driven]]{{snd}}Pieces of code are set to run when certain things happen (like the computer being turned on).

== Other paradigms ==
Some paradigms can be found in both imperative ''and'' declarative languages. These paradigms are usually found with one of the above paradigms instead of going on their own.

* [[Parallel computing|Parallel]]: More than one piece of code is run at the same time.
* [[Metaprogramming|Meta]]: Special things in the language let the programmer change the way the language itself acts.

== Overview ==
[[Image:Programming paradigms.svg|thumb|250px|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 for Dummies: What Every Programmer Should Know
 |date= 2009-05-12 |accessdate= 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>|alt=]]

Programming languages are grouped by paradigms in the same way that machines might be grouped by what they're used for.

A few languages fit in just one main paradigm, such as:

* [[Smalltalk]] (object-oriented)
* [[Assembly language|Assembly]] (imperative, but not structured or object-oriented)
* [[Haskell (programming language)|Haskell]] (functional)
* [[Prolog]] (logic)

Most languages, though, are in more than one paradigm. Some of the ones that stand out for having more than just one are:

* [[Scala (programming language)|Scala]] (object-oriented, functional, parallel)
* [[Visual Basic]] (event-driven, object-oriented)
* [[Common Lisp]] (procedural, functional, object oriented, meta)
* [[Scheme (programming language)|Scheme]] (functional, procedural, meta)
* [[Perl]] (functional, procedural, meta, object-oriented, event-driven)
* [[Python (programming language)|Python]] (functional, object-oriented, procedural)
* [[Ruby (programming language)|Ruby]] (functional, object-oriented, procedural)
* [[Wolfram Language]] (functional, procedural, generally declarative)
* [[Oz (programming language)|Oz]] (logic, functional, imperative, object-oriented)
* [[F Sharp (programming language)|F#]] (functional, imperative, object-oriented, meta)

Having more paradigms is not always good. One time that having fewer paradigms can be a good thing is when there is a language that is only [[Functional programming|functional]]. A [[Function (mathematics)|function]] in one of these languages sometimes does less work (like only going over the parts of a group of things it actually needs to) than it might have to if the language was also [[Procedure (computer science)|procedural]].<ref name=":0">{{Cite journal|url=https://dl.acm.org/citation.cfm?id=72554|title=Conception, Evolution, and Application of Functional Programming Languages|last=Hudak|first=Paul|date=September 1989|journal=ACM Computing Surveys|volume=21|issue=3|pages=359–411|doi=10.1145/72551.72554|s2cid=207637854}}</ref>

Many programming paradigms are as well known for the things they ''do not'' let people do as for those they ''do'' let people do. One time where this is true is functional languages. When a functional language is ''only'' or ''mostly'' functional, it usually will not allow [[side-effect (computer science)|side-effects]].<ref name=":0" /> Another time where this is true is [[structured programming]]: it is different from normal [[Imperative programming|imperative languages]] because it does not let programmers use "[[goto|goto statements]]" (statements telling the program to go to an earlier step). Because of this and other reasons, people sometimes think new paradigms do not allow enough things.<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 |archiveurl=https://web.archive.org/web/20090320002214/http://www.ecn.purdue.edu/ParaMount/papers/rubin87goto.pdf |archivedate=March 20, 2009}}</ref> It is sometimes okay for the computer to not let people do things, though: it can help people avoid problems with their code, and let the computer make guesses that so it can run code faster, or even [[Static typing|check code for problems before the code runs]]!

== Problems with paradigms ==
Some people who study programming languages do not like that paradigms are used to group programming languages, such as 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= SIGPLAN |id= Not. 43, 11 |date= November 2008 |volume= 43 |issue= 11 |pages= 81–83|doi= 10.1145/1480828.1480846 |s2cid= 35714982 }}.</ref>  Those people say that a lot of programming languages can't just be grouped into paradigms because languages borrow things and ideas from lots of paradigms.

== History ==
New paradigms have been created over time, and people either pointed them out at the time, or when looking back. One of the first paradigms that was recognized as a new way of programming was [[structured programming]] from the 1960s. The idea of a "programming paradigm" is from 1978 if not earlier, when [[Robert W. Floyd]] used it while teaching. The word "paradigm" in the way Robert meant it was first used by [[Thomas Kuhn]] in his book, ''[[The Structure of Scientific Revolutions]]'' (1962).<ref>{{Cite journal |last1= Floyd |first1= R. W. |title= The paradigms of programming |url= http://dl.acm.org/ft_gateway.cfm?id=359140&ftid=289772&dwn=1&CFID=285645736&CFTOKEN=55009136| doi= 10.1145/359138.359140 |journal= Communications of the ACM |volume= 22 |issue= 8 |pages= 455–460 |year= 1979 |pmid= |pmc= |s2cid= 207607885 }}</ref>

=== Machine code ===
The [[low-level programming language|lowest-level]] (closest to how the computer likes to understand things) and oldest programming paradigm is [[machine code]],<ref>{{Cite web|url=https://www.britannica.com/science/computer-science|title=Computer science - Programming languages|website=Encyclopedia Britannica|language=en|accessdate=2018-12-29}}</ref> an [[Imperative programming|imperative]] paradigm. The [[Instruction set|directions]] in machine code are just a set of numbers in a certain order. [[Assembly language]] is a little bit less [[Low-level programming language|low-level]] (and a little bit less old). In assembly language, the directions for the computer are given [[mnemonic]]s (easier-to-remember names), and [[memory address]]es (directions to find a piece of information in the computer) can be given names. These are sometimes called [[First-generation programming language|first-]] and [[Second-generation programming language|second-generation]] languages.

In the 1960s, assembly languages were made better by adding new things like library COPY, [[Macro (computer programming)|macros]] (bits of "special" code that got transformed to normal code before the program started running),<ref>{{Cite journal|last=Maurer|first=Ward|date=May 14, 1969|title=The compiled macro assembler|url=https://www.computer.org/csdl/proceedings/afips/1969/5073/00/50730089.pdf|journal=AFIPS Spring Joint Computing Conference|volume=|pages=|via=}}</ref> running [[Subroutine|procedures]] (sets of directions given a name and saved for later), and [[variable]]s (items given names and saved for later) from outside the program. This let people use some code in more than one project, and not have to worry about with hardware-specific problems (problems that only happen one one kind of computer) thanks to commands (names for directions) like READ/WRITE/GET/PUT.

Assembly was, and sometimes still is, used in systems where it is important for the code to be fast, and it is also used a lot in [[embedded system]]s because lets the user have exact control of what the machine does.

=== Procedural languages ===
In the very late 1960s, people started inventing [[procedural language]]s. These [[third-generation programming language|third-generation]] languages (the first few of what we now call [[high-level programming language|high-level languages]]) had words related to what they were trying to solve. For example,
* COmmon Business Oriented Language ([[COBOL]]){{snd}}uses words like [[computer file|file]], [[move (command)|move]] and [[copy (command)|copy]].<ref>{{Cite journal|last=Mackinson|first=Thomas N.|date=1961-08-01|title=COBOL: a sample problem|url=https://dx.doi.org/10.1145/366678.366687|journal=Communications of the ACM|volume=4|issue=8|pages=340–346|doi=10.1145/366678.366687|s2cid=22846031|issn=0001-0782}}</ref>
* FORmula TRANslation ([[FORTRAN]]){{snd}}uses [[Mathematics|mathematical]] words and symbols ( shapes used in writing and typing). It was developed mostly for science and engineering.
* ALGOrithmic Language ([[ALGOL]]){{snd}}made for writing [[algorithm]]s (sets of steps telling the computer what to do). It uses mathematical words and symbols, just like FORTRAN.
* Programming Language One ([[PL/I]]){{snd}}was supposed to be useful to everyone.
* Beginners All purpose Symbolic Instruction Code ([[BASIC]]){{snd}}made to help beginners program.
* [[C (programming language)|C]]{{snd}} a programming language meant to do many things. [[Dennis Ritchie]] worked on it from 1969 to 1973 at [[AT&T Bell Labs]].

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

After many people had started using [[procedural languages]], they invented [[object-oriented programming]] languages. In these languages, [[data]] and its "methods" (ways of manipulating the data) are put in one "[[object (computer science)|object]]".  Some programmers, such as [[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> do not agree that object-oriented languages are better for explaining ideas to a computer than procedural languages.

Because object-oriented programming is a paradigm, not a language, people have made object oriented [[assembly language]]s like [[High Level Assembly|HLA (High Level Assembly]]).

=== Declarative paradigms ===
At the same time, some people were making [[declarative programming|declarative programming languages]]. A language that is well known for being declarative is [[SQL]] (a language for adding and removing things from [[Table (information)|tables]]).

==Related pages==
{{Div col|colwidth=20em}}
* [[Mindset]]
* [[Type system]]
* [[Turing completeness]]{{div col end}}

== References ==
{{Reflist}}

==Other websites==
{{Commonscat|Programming language by paradigm}}
*[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?] {{Webarchive|url=https://web.archive.org/web/20160303215115/http://www.janeve.me/articles/understanding-programming-paradigms |date=2016-03-03 }}

{{DEFAULTSORT:Programming paradigm}}
[[Category:Computer programming]]