Jigar Gaglani

Programming paradigm is a fundamental style of computer programming

Paradigms differ in concepts and abstractions used to represent the elements of program

Procedural/Imperative Functional Logic Object-Oriented

Derived from latin word imperare means “to command”

It is based on commands that update variables in storage

Is a programming paradigm that describes computation in terms of statements that change a program state.

It defines sequences of commands for the computer to perform

Imperative programming is characterized by programming with a state and commands

In imperative programming, a name may be assigned to a value and later reassigned to another value.

A name is tied to two bindings, a binding to a location and to a value.

The location is called the l-value and the value is called the r-value.

For example, • X := X+2

Assignment changes the value at a location.

A program execution generates a sequence of states

The unstructured commands contains:• assignment command, • sequential composition of commands, • a provision to identify a command with a

label,• unconditional and conditional GOTO

commands

The unconditional goto command has the form: • goto LABELi

The sequence of instructions next executed begin with the command labeled with LABELi.

The conditional goto command has the form: • if conditional expression then goto LABELi

The goal of structured programming is to provide control structures that make it easier to reason about imperative programs.

an IF statement corresponds to an If condition then command and a DO statement corresponds to a While condition Do command.

  • IF guard --> command FI=if guard then

command• DO guard --> command OD=while guard do

command 

An imperative program can only be understood in terms of its execution behavior. 

Thus, the whole program may need to be examined in order to understand even a small portion of code.

The program is built from one or more procedures

It provides a programmer a means to define precisely each step in the performance of a task.

The ability to re-use the same code at different places in the program without copying it.

An easier way to keep track of program flow than a collection of "GOTO" or "JUMP" statements

Declarative programming is a non-imperative style of programming

Does not explicitly list command or steps that need to be carried out to achieve the results.

For example:• List<int> collection = new List<int>

{1,2,3,4,5 };

Imperative programming• List<int> results = new List<int>();• foreach(var num in collection){ if (num % 2 != 0) results.Add(num);}

Declarative programming• var results = collection.Where( num=>num

%2 != 0);

Does not step through the collection

Procedural• Assembler, Fortran, Cobol, C, etc

Non-Procedural• SQL, Visual Basic, etc etc.

It treats computation as the evaluation of mathematical functions and avoids state and mutable data.

It emphasizes the application of functions, in contrast to the imperative programming style

Functional programming is all about expressions.

Functions are used as objects in FP.

Functional Programming is about abstraction and reducing complexity

spam = ['pork','ham','spices']numbers = [1,2,3,4,5]def eggs(item): return item

map(aFunction, aSequence)

L = map(eggs, spam)print L

Same thing could have been done by: • for i in spam: L.append(i)

print L

If we want to create a new list of only odd numbers :• def isOdd(n): return (n%2 != 0)• L = filter(isOdd, numbers)• print L

Alternatively• def isOdd(n): return (n%2 != 0)• for i in numbers:• if isOdd(i):• L.append(i)• print L

It is the use of mathematical logic for computer programming

The problem-solving task is split between the programmer and theorem-prover

To study logic programming means to study proofs.

It is based upon the fact of a backwards reasoning proof

Eg. :• If B1 and … and Bn then H

Prolog is a general purpose logic programming language associated with artificial intelligence and computational linguistics

It is based on Facts and Rules

Simple Facts:• Facts either consist of a particular item or a

relation between items.

For Eg :• the fact that it is sunny is represented by writing

the program : sunny.

We can now ask a query of Prolog by asking • ?- sunny.

facts consist of a relation and the items that this refers to, called arguments

A general model is shown below:

relation(<argument1>,<argument2>,....,<argumentN> ).

The basic Prolog terms are an integer, an atom, a variable or a structure.

Example : • likes(john,mary).

In the above fact john and mary are two atomes.

Consider the following sentence : • 'All men are mortal'

We can express this as :• mortal(X) :- human(X).

Let us define the fact that Socrate is a human. • mortal(X) :- human(X). 

human(socrate).

Now if we ask to prolog : • ?- mortal(socrate).

What prolog will respond ?

Why ?

One of Prolog's most useful features is the simple way it lets us state generalizations.

Example:• enjoys(vincent,X) :- burger(X).

Vincent enjoys burgers, except Big Kahuna burgers, how do we state this in Prolog?

As a first step, let's introduce another built in predicate fail/0

fail enables us to write some interesting programs, and in particular, it lets us define exceptions to general rules

Consider the following code: • enjoys(vincent,X) :- big_kahuna_burger(X),!,

fail.enjoys(vincent,X) :- burger(X). burger(X) :- big_mac(X).burger(X) :- big_kahuna_burger(X).  big_mac(a).big_kahuna_burger(b).big_mac(c).

The first two lines describe Vincent's preferences.

The last 4 lines describe a world containing 3 burgers, a, b, and c

This is what happens:

• ?- enjoys(vincent,a).yes ?- enjoys(vincent,b).no ?- enjoys(vincent,c).yes

The key is the combination of ! and fail in the first line

This cut-fail combination lets us define a form of negation called negation as failure

General notation: • neg(Goal) :- Goal,!,fail.

neg(Goal).

For any Prolog goal, neg(Goal) will succeed precisely if Goal does not succeed.

Using our new neg predicate, we can describe Vincent's preferences as:• enjoys(vincent,X) :- burger(X), neg(big_kahu

na_burger(X)).

Object-oriented programming (OOP) is a programming paradigm that uses "objects" – data structures consisting of datafields and methods together with their interactions – to design applications and computer programs.

It is a paradigm where we focus real life objects while programming any solution.

We actually write behaviours of our programming objects, those behaviours are called methods in objected oriented programming.

They enable programmers to create modules that do not need to be changed when a new type of object is added.

A programmer can simply create a new object that inherits many of its features from existing objects.

Class Object Instance Method Message passing Inheritance Abstraction Encapsulation Polymorphism Decoupling

Encapsulation:• a logical boundary around methods and

properties Inheritance Re-usability

• method overloading and overriding Information Hiding

• is achieved through "Access Modifiers"

What are the differences between these programming paradigms, and are they better suited to particular problems or do any use-cases favor one over the others?

http://en.wikipedia.org/wiki/Imperative_programming

http://www.emu.edu.tr/aelci/Courses/D-318/D-318-Files/plbook/imperati.htm

http://en.wikipedia.org/wiki/Procedural_programming

http://www.ocaml-tutorial.org/functional_programming

http://boklm.eu/prolog/page_4.html http://cs.union.edu/~striegnk/learn-prolog-

now/html/node90.html