
Classification of the principal programming paradigms - jboynyc
https://www.info.ucl.ac.be/~pvr/paradigms.html
======
z1mm32m4n
The idea of "programming paradigms" is not a useful way to talk about
programming language design.

> The trouble with programming paradigms is that it is rather difficult to say
> what one is, or how we know we have a new one. Without precise definitions,
> nothing precise can be said, and no conclusions can be drawn, either
> retrospectively or prospectively, about language design. > > _What, if
> anything, is a programming paradigm?_ [0]

Luckily, we've studied programming languages and their design rigorously for
decades, and we already have a rich, common language for discussion the design
space of programming languages: type theory.

It sounds intimidating: "theory" is often general abstract nonsense that's
only useful in academic research, etc., etc. But that's not the case at all.
"Type theory" is really just a really useful way to understand individual
features of a programming language, and how they compose with one another.

[0]: [http://www.cambridgeblog.org/2017/05/what-if-anything-is-
a-p...](http://www.cambridgeblog.org/2017/05/what-if-anything-is-a-
programming-paradigm/)

~~~
DonbunEf7
Type theory is only useful up to a certain point; there are plenty of
languages that appear identical from a type-theoretic viewpoint but that have
deeper richer interpretations in category- or set-theoretic settings. Check
out the actual diagram in the article; it shows off some distinctions that
would have been totally washed out if only types were considered interesting.

~~~
qznc
If a language has syntax specifically for some paradigm then the paradigm is
reflected in the type system. A paradigm is invisible in the type system if it
is implemented as library only.

~~~
nine_k
Isn't this why sometimes entire paradigms can be implemented as libraries in
Lisp? Isn't the whole idea of DSLs dependent on this?

------
platz
Lets just put Oz, Alice, and Curry in every box.

How "state" is classified seems quite ad-hoc.

------
misc_CIA_victim
There _many_ important dimensions of difference in programming languages that
matter to the programmer. Which of those are "fundamental"? What does that
question even mean??

One fork in the road between academic/theory answers to that question and
developer answers concerns the role of the standard libraries and available
IDEs. The out-of-the-box work/contribution of those tools is super important
to developers in practice, but irrelevant to academic discussions. Some
academics focus on real theory and declare that their statements about PL are
basically a kind of applied mathematics - use it if it is somehow relevant to
you, and ignore it, like other piles of math, if it isn't. Others make claims
that the distinctions capture important properties like preventing careless
errors. In that case, one can also talk about which tools are
helpful/important to prevent careless errors. And similar remarks can be made
for other properties such as speed/brevity of coding/expression, availability
of pre-existing parts and ease of integrating them, etc. IMO, there is room
for theory that tries harder to abstract the dimensions that drive software
practice.

------
INTPnerd
I'm working on a new flavor of the logic paradigm [https://github.com/still-
dreaming-1/PurposefulPhp](https://github.com/still-dreaming-1/PurposefulPhp)

------
anon335dtzbvc
Could someone explain to me why everyone is crazy about type theory? ATM i
learn category theory by watching and reading the awesome material from
Bartosz Milewski. Should i stop and learn type theory instead, if i want to
know more about programming languages in an abstract / general sense?

------
stcredzero
I think there's a form of misplaced attention when it comes to programming.
There should be a focus on the UX of the programmer. The programming paradigm
is just one component of this. It's missing the forest for the trees.

~~~
lioeters
There is a phrase "developer experience" ("DX") that I've seen used
occasionally. It would be great if that concept could be developed further,
similar to how "UX design" has been maturing as a field over the years.

~~~
Retra
For all the maturing "UX design" has done over the years, using a computer
still feels mostly like swimming in garbage. Sure, now it's pretty brand-name
garbage. But I'd hardly call that an improvement.

------
iitalics
I don't think it's possible to create a satisfying diagram like this. It's
already been said, but compartmentalizing languages into "paradigms" is
generally pointless.

------
vvanders
Kinda surprised to see Erlang and Smalltalk in two different columns.

------
coldcode
2008 diagram, missing a decade

~~~
olavk
What new major paradigms do you think it is missing?

~~~
smitherfield
Type systems, which the chart doesn’t address at all, are now usually
considered at least as important an aspect to language’s ‘paradigm’ as the
(increasingly-blurry) functional vs imperative distinction. And a lot of the
examples are pretty dated, coming as it did at the tail end of the object-
oriented and XML fads. And concurrency and especially parallelism are given
short shrift.

~~~
nextos
Paradigms are quite orthogonal to type systems. Mozart/Oz and AliceML
implement more or less the same set of paradigms. One is dynamic the other is
statically typed.

~~~
smitherfield
Then they don’t implement the same set of paradigms. Type systems (can)
fundamentally shape how computations may be expressed in a language. For
example, C++’s type system was famously proved Turing-complete.

~~~
naasking
So is Java's type system [1], and Rust's and Haskell's with some modest
extensions, and Scala's. Many type systems have turned out to be Turing
complete.

[1] [https://arxiv.org/abs/1605.05274](https://arxiv.org/abs/1605.05274)

------
201709User
JavaScript: Mistake-oriented paradigm.

~~~
sctb
Could you please start commenting civilly and substantively?

[https://news.ycombinator.com/newsguidelines.html](https://news.ycombinator.com/newsguidelines.html)

~~~
201709User
I have no other way to describe weak typing and scoping rules of the said
language. I stand by my words.

