Programming Paradigms: By, Janeve George & Nilesh Mevada

Intelligent People. Uncommon Ideas.
1
Programming Paradigms
(http://www.directi.com | http://wiki.directi.com | http://careers.directi.com)
Licensed under Creative Commons Attribution Sharealike Noncommercial
By, Janeve George
janeve.g@directi.com
& Nilesh Mevada
nilesh.m@directi.com
2
Creative Commons Sharealike Attributions Noncommercial
Few Instruction
It's a workshop not a presentation !!!
Parking Lot
Perks
3
Aim of the session
Introduction to programming concepts and techniques
Differentiate between various programming paradigms
Q: Why there are so many programming paradigms?
A:

Q: Isn't there 'one language' that would suffice?
A:

Q: How can we deal with understanding so many paradigms?
A:
4
Flow of the session
Programming Paradigm Definition
Why bother about 'Programming Paradigms'?
Appreciating 'Programming paradigms'
Programming Concepts
An Overview
Eager and Lazy Evaluation
Procedures
Functions
External and Internal State
Concurrency
Static vs Dynamic Typing
Some Real-Life Problems
Search (Java vs Prolog)
Higher Order Functions (Java vs Haskell)
5
Flow of the session
Programming Paradigm - Definition
An Overview
Procedures
Functions
Concurrency
6
What are Programming Paradigms?
Fundamental style of computer programming. (wikipedia.org)
It serves as a pattern or model for a programming language
Function
Oriented
Object
Oriented
Logical
Programming
Java
ML
Haskell
Prolog
Mercury
Oz
Erlang
Smalltalk
7
Flow of the session
An Overview
Procedures
Functions
Concurrency
8
9
Bridge Example
Requirement Better approach
Tools one
knows
The bridge should be
- Earthquake resistant at x level
- Should be erosion resistant
- So on...
Pros and cons of
building it with
either wood
or iron
One knowing pros & cons of
wood, iron (& possibly
concrete) to satisfy the
requirements.
10
Programming world
Requirement Better approach
Tools one
usually knows
General real-life
problems
a set of programming
concepts related to a
programming paradigm
one knowing programming
concepts related to multiple
programming paradigms
11
Tools (Programming Languages) may not suffice to deal
with the real life problems.
They might not support the solution at all or only partially.
Learning new programming languages becomes easier
To bring innovations in programming technologies
12
Flow of the session
An Overview
Procedures
Functions
Concurrency
13
An example of how a trivial concept can affect/support a
computation and hence a particular style of
programming...
Int X;

Int Y = X;

Print( Y );
Execution Flow
?
14
Flow of the session
An Overview
Procedures
Functions
Concurrency
15
Programming Concepts An Overview
Set of
Programming
Concepts

Procedures
Functions
Higher/1
st
Order
Evaluation
Eager/Lazy
Variables
Single/Multi store
Scope
Scope of variables
Typing
State
Internal/External
Objects
Classes
Concurrency
& on & on & on.....
16
Subset of
Concepts
Programming
Model
Set of
Programming
Concepts
Programming
Language(s)
Embraced
by
Followed
by
Embraced
by
Followed
by
17
Subset of
Concepts
OO
Programming
Model
Set of
Programming
Concepts
OO
Programming
Language(s)
Embraced
by
Followed
by
Java
Ruby
Oz
C++
Scala
Etc...
Objects
Classes
Inheritance
Polymorphism
Explicit State
Etc...
Embraced
by
Followed
by
18
Subset of
Concepts
Functional
Programming
Model
Set of
Programming
Concepts
Functional
Programming
Language(s)
Embraced
by
Followed
by
Lazy/Eager Evaluation
Functions
Higher Order Func.
Etc...
Haskell
Erlang
ML
Scheme
Etc...
Embraced
by
Followed
by
19
Concepts
Java
Prolog, Mercury
Programming
model/paradigm
Programming
Languages
Higher-Order Functions,
Intrnal State, Determinism
Function Oriented
Programming model
Haskell, OCamel,
ML, Scheme
Procedures, External State,
Concurrency
Object Oriented
Programming model
Procedures, External State,
Pointcuts, Advice, Weaving
Aspect Oriented
Programming model
AspectJ, AspectC#,
AspectC++
Facts, Rules,
Search, Determinism
Logic Oriented
Programming model
20
Functional + Object Oriented Scala
Oz
Programming
models
Multiple paradigm
Languages
Procedural
+ Functional
+Object Oriented
21
Few important concepts
Eager Evaluation
Lazy Evaluation
Procedures
Functions
External State
Internal State
Concurrency
22
Programming Concepts Eager Evaluation
An expression which is evaluated as soon as it gets bound
to a variable
Importance
Simple
Commonly found
Easy implementation for languages
Problems
Expressions are always evaluated
Languages supporting easy evaluation
Almost all including java, c#, c, etc.
23
Programming Concepts Eager Evaluation
....
List Gen( int N ) {
ArrayList list = new ArrayList();
list.add( N );
list.addAll( Gen(N+1) );
return list;
}

void myMethod () {
List K = Gen(1);
System.out.println( "Elements: " + K.getElementAt( 3 ) );
}
....
24
Programming Concepts Lazy Evaluation
An expression is evaluated only when needed
Also known as delayed evaluation or call-by-need.
Importance
To deal with potentially infinite data.
Generally, calculations are not repeated.
Problems
Difficult at glance
Difficult to predict time/space complexity
Languages supporting Lazy Evaluation
Haskell, Oz, Scheme, OCamel
25
Programming Concepts Lazy Evaluation
declare fun lazy {Gen N}
N | {Gen N+1}
end

declare K = {Gen 1}

{Browse Elements: + Nth K 3}
26
Programming Concepts Procedures
A code construct which can
Execute a set of statements in an order
Accept zero or more arguments
Return zero or more results
Produce a side effect
Importance
One of the most basic building block of any programming language
A means of telling the system how to execute some behavior
May be used as to abstract out functions, objects & classes
Languages that support procedures
C, C++, C#, Oz
proc {Max X Y ?Z}
if X>=Y then Z=X else Z=Y end
end
27
Programming Concepts Procedures
local Default MaxOrDefault in

Default=10

proc {MaxOrDefault Arg ?Result}
if Arg >= Default then
Result = Arg
else
Result = Default
end
end

local Result in
{MaxOrDefault 5 Result}
{Browse Result}
end

end
28
Programming Concepts Functions
A code construct which can
Execute a set of statements in a given order
Accept zero or more arguments
Returns only one result and no side effect
Pure functions avoid state and mutable data
Importance
A basic building block of many programming language
A means of telling the system how to execute some behavior
Can replicate a pure mathematical model
Languages that support Functions
Haskell, OCamel, ML, Oz
fun {Max X Y}
if X>=Y then Z=X else Z=Y end
end

Z = {Max 10, 20}
29
Programming Concepts Functions (Higher Order)
Higher Order Functions
Accepts functions as arguments along with other types
Can return a function as result
Ordering means...
1st order :- having no functions as args
2nd order :- can have 1st order functions as args
nth order :- can have n-1th order functions as args
We can build abstraction using Higher Order Functions
map f [] = []
map f (x:xs) = f x : map f xs

numbers = [7,9,13]
inc x = x + 1
more_numbers = map inc numbers
30
Programming Concepts Functions (Higher Order)
listsum [] = 0
listsum (x:xs) = x + listsum xs

listprod [] = 1
listprod (x:xs) = x * listprod xs
fold op init [] = init
fold op init (x:xs) = x `op` fold op init xs

listsum = fold (+) 0
listprod = fold (*) 1
31
Programming Concepts External and Internal State
Explicit State
State remembrance across calls
Importance
One of the base concept for Object Orientation
Implicit state
Defined by the function for its internal calculations.
Importance
Storing temporary results which otherwise might
require repetitive calls.
Languages that support external state
Object Oriented languages like Java, Smalltalk, etc
Languages that have global variables
Languages that support internal state
All languages that have variables in procedures / functions
32
Programming Concepts External and Internal State
fun {Sum Numbers}
Result = {NewCell 0}
Input = {NewCell Numbers}
proc {Sum}
case @Input of nil then skip
[] X | Y then
Result := @Result + X
Input := Y
{Sum}
end
end in
{Sum}
@Result
end
33
Programming Concepts Concurrency
Multiple and independent executions
From real-life problems point of view, the definition adds
this clause and communicates only when needed
Importance
relates more to real-life problems
response time improved due to parallel executions
Problems
race condition
Languages that support concurrent execution
Java, Oz
thread
ConcurrentFlow1 = {GenerateNumbers 1 10}
end
34
fun {GenerateNumbers FromArg ToArg}
{Delay 100}
if FromArg > ToArg then
nil
else
FromArg | {GenerateNumbers FromArg+1 ToArg}
end
end

thread
end

thread
end

{Browse ConcurrentFlow1}
{Browse ConcurrentFlow2}
35
....
public void main(String[] args) throws InterruptedException {
Temp temp = new Temp();

createAConcurrentFlow(1, 10);
createAConcurrentFlow(11, 20);
}
....
private void createAConcurrentFlow(int FromArg, int ToArg) {
new Runnable() {
public void run() {
try {
new Temp().GenerateNumbers(FromArg, ToArg);
}
catch (InterruptedException e) { }
}
};
}
....
36
Programming Concepts Static Typing
Type checking is performed during compile-time
Variables should be defined before they're used.
Variables can be cast into other types
Variables don't get converted
Importance
Improved error-catching ability, efficiency, security
partial program verification
Problems
reducing expressiveness of the programming language
restrictions for the programmer on the programs he can write
Languages that use static typing
C, C++, C#, Java, ML, Pascal, Haskell
37
Programming Concepts Static Typing
int num, sum; // explicit declaration
num = 5; // now use the variables
sum = 10;
sum = sum + num;
38
Programming Concepts Dynamic Typing
Type checking is performed during runtime
It's not necessary to define the variable before used
Variables can be converted to other types implicitly
Importance
variables can be bound to any first-class-citizen in the lang. (proc,
func, mix of data-types, etc.)
independent compilations of the program (since no type checking
at compile time)
Problems
more type-error-prone code at run-time.
Languages that uses dynamic typing
JavaScript, Lisp, Perl, PHP, Prolog, Python, Ruby
39
Programming Concepts Dynamic Typing
foo() {
x = 1;
x = 'hello';
}
40
Flow of the session
Programming Paradigm Definition
An Overview
Procedures
Functions
Concurrency
41
Some Real-Life Problems Prolog vs Java
%
% Facts
%

male(hrithik).
male(shahrukh).
male(salman).
male(abhishek).
male(akshay).
male(aamir).

female(diya).
female(aishwarya).
female(katrina).
female(malaika).

parent(hrithik,shahrukh).
parent(hrithik,salman).
parent(hrithik,diya).
parent(shahrukh,abhishek).
parent(shahrukh,akshay).
parent(salman,aishwarya).
parent(salman,katrina).
parent(salman,aamir).
parent(diya,malaika).
%
% Rules
%

father(X,Y) :- parent(X,Y), male(X).
mother(X,Y) :- parent(X,Y), female(X).
grandparent(X,Y) :- parent(X,Z), parent(Z,Y).
paternalgrandfather(X,Y) :- father(X,Z), father(Z,Y).
sibling(X,Y) :- parent(Z,X), parent(Z,Y).
brothers(X,Y) :- sibling(X,Y),male(X),male(Y), \+ (X=Y).

%
% Queries
%

cmd: mother(diya,malaika)
% Outupt: yes/no

cmd: mother(Mother,Child).
% Output: lists (mother,child) pair found in facts
% according to associations defined
42
Some Real-Life Problems Statistics
LOC
Prolog 15 min little hard 25 Lines
Java easy 7x times
Haskell 15 min hard 9 lines
Java 45 min easy 90 lines
Ease of
Implementation
Ease of
Understanding
45 min, 1/3
rd
complete
Higer Order Functions (Java vs Haskell)
43
How to approach Programming Paradigm?
Our Way was...
Concepts first, Languages Later.
Other effective ways...
Mastering any one programming model (e.g. Object Oriented)
and then comparing it with others (e.g. functional, procedural,
etc.)
44
References
Books
Concepts, Techniques & Models Of Computer Programming by
Peter Van Roy & Seif Haridi
Links On Web
http://wikipedia.org
http://www.infocheese.com/programmingparadigms.html
45
What we expect post this session
Experimentation with other programming languages
Functional language -> Haskell / ML / Scheme
Object Oriented language -> Java, C++, C#, Scala
Aspect Oriented language -> AspectJ, AspectC++
Logic language -> Prolog / Mercury
Mixed languages -> Scala, Oz
Sharing your experiences with us...
A testimonial
I want to thank you and DIRECTI for conducting such a marvelous
session and I am very much indebted for that.
I fell in love with LISP programming language and found that it was very
much ideal for signal processing algos.
The approach u have suggested was just great and the book you have
suggested was really really great. - Chinni Krishna, Mukt '08 Session
Attendee
46
Questions???

janeve.g@directi.com & nilesh.m@directi.com

http://directi.com
http://careers.directi.com

Download slides: http://wiki.directi.com
47
Retrospective!!!

janeve.g@directi.com & nilesh.m@directi.com

http://directi.com
http://careers.directi.com

Download slides: http://wiki.directi.com

Programming Paradigms: By, Janeve George & Nilesh Mevada

Uploaded by

Copyright:

Available Formats

You might also like

Programming Paradigms: By, Janeve George & Nilesh Mevada

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programming Paradigms: By, Janeve George & Nilesh Mevada

Uploaded by

Copyright:

Available Formats

Intelligent People. Uncommon Ideas.

You might also like