Acknowledgements: These slides accompany section 1.3, “Primary Programming Paradigms” from Chapter 1 “Fundamental Concepts” of “Introduction to Functional Programming Using Haskell”.

Advisory: The HTML version of this document may require use of a browser that supports the display of MathML. A good choice as of August 2017 is a recent version of Firefox from Mozilla.

Programming Paradigm

Timothy A. Budd. Multiparadigm Programming in Leda, Addison-Wesley, 1995, page 3:

"a way of conceptualizing what it means to perform computation, of
structuring and organizing how tasks are to be carried out on a
computer."

Primary Paradigms

• Historical programming language paradigms

  1. imperative

  2. declarative

• Recent programming languages blur distinctions

• But concept of programming paradigm meaningful

Imperative Paradigm (1)

• Imperative program

  • has implicit state (values of variables, program counters, etc.)
  • modified (i.e., side-effected or mutated)
  • by constructs (i.e., commands)

• Imperative language

  • has explicit sequencing for precise control of state changes

• Imperative program

  • expresses how something computed

Imperative Paradigm (2)

    int count =  0;
    int maxc  = 10;
    while (count <= maxc) {
        System.out.println(count) ;
        count = count + 1
    }

• State includes

  • values of count and maxc
  • output lines printed
  • next statement to be executed

• State changes (side effects)

  • assignment changes count value
  • println adds line to output
  • stepping from one statement to next

Imperative Paradigm (3)

    int count =  0;
    int maxc  = 10;
    while (count <= maxc) {
        System.out.println(count) ;
        count = count + 1
    }

• Execution in sequence

  • while causes execution zero or more times
  • depending upon changing values count, maxc

Imperative Paradigm (4)

    int count =  0;
    int maxc  = 10;
    while (count <= maxc) {
        System.out.println(count) ;
        count = count + 1
    }

• State implicit because state assumed from context

• Variable count mutable because value can change

  • name count yields different values at different times

• Variable maxc also mutable, but does not change here

Imperative Paradigm (5)

• Imperative languages well suited for traditional computer architectures

• Examples: Fortran, C, C++, Java, C#, Python, JavaScript, Lua

• Object-oriented languages?

  • different dimension of categorization
  • most are imperative

Declarative Paradigm (1)

• Declarative program

  • has no implicit state
  • any state must be explicit

• Declarative program

  • consists of expressions (or terms)
  • that are evaluated
  • not commands that are executed

• Declarative language

  • repetition by recursion
  • not by sequencing commands

Declarative Paradigm (2)

• Declarative programs

  • express what computed
  • rather than how computed

• Declarative paradigm subdivided into

  • functional (or applicative)
  • relational (or logic)

Functional Paradigm (1)

• Underlying computational model is mathematical function

  • applied to zero or more arguments to compute one result
  • result deterministic (or predictable).

Functional Paradigm (2)

    counter :: Int -> Int -> String 
    counter count maxc 
        | count <= maxc = show count ++ "\n" ++ counter (count+1) maxc 
        | otherwise     = ""

• Above Haskell fragment similar in meaning to earlier Java fragment

  • defines function counter
  • takes integer arguments count and maxc
  • returns string with integers count to maxc one per line

• Function “call” (application) of counter

  • references values of count and maxc, explicit parameters of call
  • cannot change variable values within call
  • can change arguments for recursive call

Functional Paradigm (3)

    counter :: Int -> Int -> String 
    counter count maxc 
        | count <= maxc = show count ++ "\n" ++ counter (count+1) maxc 
        | otherwise     = ""

• Repetition of counter by recursive call

• State of counter explicit because passed in arguments

• Values of arguments immutable within body

• Names like count and maxc (in pure functional language)

  • are referentially transparent
  • always have same value in same context

Functional Paradigm (4)

• Referential transparency very important

  • allows subexpression evaluation in any order, even in parallel
  • allows substitution of value for variable and vice versa

• In functional languages, functions often are

  • first class values, can pass or store function
  • higher-order, take or return other functions

• Higher-order functions very important

  • allow regular and powerful abstractions

Functional Paradigm (5)

• Pure examples: Haskell, Idris, Elm. Miranda, Hope, Backus’ FP.

• Hybrid examples: Scala, F#, OCaml, SML, Erlang, Elixir, Lisp, Clojure, Scheme

• Mainstream imperative language with functional subsets: Java 8+, C#, Python, Ruby, Groovy, Rust, and Swift

Relational (or Logic) Paradigm (1)

• Underlying computational model is mathematical relation (or predicate)

  • (nondeterministic) association of group of values
  • with backtracking to resolve additional values

Relational (or Logic) Paradigm (2)

    counter(X,Y,S) :- count(X,Y,R), atomics_to_string(R,'\n',S).

    count(X,X,[X]). 
    count(X,Y,[])     :- X  > Y. 
    count(X,Y,[X|Rs]) :- X < Y, NX is X+1, count(NX,Y,Rs).

• Above SWI-Prolog code similar in meaning to earlier Java amd Haskell code

  • generates string with integers from X to Y, one per line

• Defines database consisting of clauses

  1. count(X,X,[X]). defines a fact

     • for any variable value X and list [X] consisting of single value X, count(X,X,[X]) is asserted as true

  2. count(X,Y,[]) :- X > Y. defines a rule

     • left-side of :- is true if right-side is also true
     • count(X,Y,[]) is true when X > Y

Relational (or Logic) Paradigm (3)

    counter(X,Y,S) :- count(X,Y,R), atomics_to_string(R,'\n',S).

    count(X,X,[X]). 
    count(X,Y,[])     :- X  > Y. 
    count(X,Y,[X|Rs]) :- X < Y, NX is X+1, count(NX,Y,Rs).

• Can query database for missing components

  • count(1,1,Z). yields value Z = [1]
  • count(X,1,[1]. yields value X = 1.
  • generates all components in some nondeterministic order

Relational (or Logic) Paradigm (4)

• Imperative and functional languages run computation in one direction yielding one answer

• Prolog can run computation in multiple directions yielding multiple answers

• Example relational languages: Prolog, Parlog, and miniKanren.

• Most Prolog implementations not pure, have imperative features (cut, assert and retract clauses)