Transcript Programming_Paradigms

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
from latin word imperare means
“to command”
 Derived
 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
location.
A
changes the value at 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 nonimperative 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
 Functional
are used as objects in FP.
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>,....,<argume
ntN> ).
 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
 Why
prolog will respond ?
?
 One
of Prolog's most useful features is the
simple way it lets us state generalizations.
 Example:
• enjoys(vincent,X) :- burger(X).
enjoys burgers, except Big
Kahuna burgers, how do we state this in
Prolog?
 Vincent
 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_kahuna_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_program
ming
 http://www.emu.edu.tr/aelci/Courses/D-318/D318-Files/plbook/imperati.htm
 http://en.wikipedia.org/wiki/Procedural_program
ming
 http://www.ocamltutorial.org/functional_programming
 http://boklm.eu/prolog/page_4.html
 http://cs.union.edu/~striegnk/learn-prolognow/html/node90.html