1. Programming Paradigms
Procedural
Functional
Logic
Object-Oriented

2. Specifying the WHAT Describe the Inputs
Specific values
Properties
Describe the Outputs (as above)
Describe the Relationships Between I x O
As a possibly infinite table
Equations and other predicates between input and output expressions
For a given input, output may not be unique
CS784

3. Specifying the HOW Describe the Inputs
Specific values
Properties
Describe HOW the Outputs are produced
Models of existing computers
Program State
Control Flow
A Few Abstractions
Block Structure
Recursion via a Stack
CS784

4. Procedural programming
Describes the details of HOW the results are to be obtained, in terms of the underlying machine model.
Describes computation in terms of
Statements that change a program state
Explicit control flow
Synonyms
Imperative programming
Operational
Fortran, C, …
Abstractions of typical machines
Control Flow Encapsulation
Control Structures
Procedures
No return values
Functions
Return one or more values
Recursion via stack
CS784

5. Procedural Programming: State
Program State
Collection of Variables and their values
Contents of variables change
Expressions
Not expected to change Program State
Assignment Statements
Other Statements
Side Effects
CS784

6. C, C++, C#, Java Abstractions of typical machines
Control Flow Encapsulation
Control Structures
Procedures
No return values
Functions
Return one or more values
Recursion via stack
Better Data Type support
CS784

7. Illustrative Example Expression (to be computed) : a + b + c
Recipe for Computation
Account for machine limitations
Intermediate Location
T := a + b; T := T + c;
Accumulator Machine
Load a; Add b; Add c
Stack Machine
Push a; Push b; Add; Push c; Add
CS784 7

8. Declarative Programming
Specifies WHAT is to be computed abstractly
Expresses the logic of a computation without describing its control flow
Declarative languages include
logic programming, and
functional programming.
often defined as any style of programming that is not imperative.
CS784

9. Imperative vs Non-Imperative
Functional/Logic style clearly separates WHAT aspects of a program (programmers’ responsibility) from the HOW aspects (implementation decisions).
An Imperative program contains both the specification and the implementation details, inseparably inter-twined.
CS784 9

10. Procedural vs Functional
Program: a sequence of instructions for a von Neumann m/c.
Computation by instruction execution.
Iteration.
Modifiable or updatable variables..
Program: a collection of function definitions (m/c independent).
Computation by term rewriting.
Recursion.
Assign-only-once variables.
CS784 10

11. Functional Style : Illustration
Definition: Equations
sumto(0) = 0
sumto(n) = n + sumto(n-1)
Computation: Substitution and Replacement
sumto(2) = 2 + sumto (2-1) = 2 + sumto(1)
= sumto(1-1) = sumto(0)
= = …
= 3
CS784 11

12. Paradigm vs Language Imperative Style Functional Style tsum := 0;
while (i < n) do
i := i + 1;
tsum := tsum + I od
Storage efficient
func sumto(n: int): int;
if n = 0
then 0
else n + sumto(n-1) fi
endfunc;
No Side-effect
CS784 12

13. Bridging the Gap
Imperative is not always faster, or more memory efficient than functional.
E.g., tail recursive programs can be automatically translated into equivalent while-loops.
func xyz(n : int, r : int) : int;
if n = 0
then r
else xyz(n-1, n+r) fi
endfunc
CS784 13

14. Analogy: Styles vs Formalisms
Iteration
Tail-Recursion
General Recursion
Regular Expression
Regular Grammar
Context-free Grammar
Recursion = Iteration + Stack
Tail-recursion = Iteration
CS784 14

15. Logic Programming Paradigm
edge(a,b).
edge(a,c).
edge(c,a).
path(X,X).
path(X,Y) :- edge(X,Y).
path(X,Y) :- edge(X,Z), path(Z,Y).
Reflexive transitive closure
CS784 15

16. Logic Programming A logic program defines a set of relations.
This “knowledge” can be used in various ways by the interpreter to solve different “queries”.
In contrast, the programs in other languages
Make explicit HOW the “declarative knowledge” is used to solve the query.
CS784 16

17. Append in Prolog append([], L, L). append([ H | T ], X, [ H | Y ]) :-
append(T, X, Y).
True statements about append relation.
Uses pattern matching.
“[]” and “|” stand for empty list and cons operation.
CS784 17

18. Different Kinds of Queries
Verification
append: list x list x list
append([1], [2,3], [1,2,3]).
Concatenation
append: list x list -> list
append([1], [2,3], R).
CS784 18

19. More Queries Constraint solving Generation
append: list x list -> list
append( R, [2,3], [1,2,3]).
append: list -> list x list
append(A, B, [1,2,3]).
Generation
append: -> list x list x list
append(X, Y, Z).
CS784 19

20. Object-Oriented Style
Programming with Abstract Data Types
ADTs specify/describe behaviors.
Basic Program Unit: Class
Implementation of an ADT.
Abstraction enforced by encapsulation..
Basic Run-time Unit: Object
Instance of a class.
Has an associated state.
CS784 20

21. Procedural vs Object-Oriented
Emphasis on procedural abstraction.
Top-down design; Step- wise refinement.
Suited for programming in the small.
Emphasis on data abstraction.
Bottom-up design; Reusable libraries.
Suited for programming in the large.
CS784 21

22. Integrating Heterogeneous Data
In C, Pascal, etc., use
Union Type / Switch Statement
Variant Record Type / Case Statement
In C++, Java, Eiffel, etc., use
Abstract Classes / Virtual Functions
Interfaces and Classes / Dynamic Binding
CS784 22

23. Comparison : Figures example
Data
Square
side
Circle
radius
Operation (area)
side * side
PI * radius * radius
Classes
Square
side
area
(= side * side)
Circle
radius
(= PI*radius*radius)
CS784 23

24. Adding a new operation Data ... Operation (area) Operation (perimeter)
Square
4 * side
Circle
2 * PI * radius
Classes
Square
...
perimeter
(= 4 * side)
Circle
(= 2 * PI * radius)
CS784 24

25. Adding a new data representation
...
rectangle
length
width
Operation (area)
length * width
Classes
...
rectangle
length
width
area
(= length * width)
CS784 25

26. Procedural vs Object-Oriented
New operations cause additive changes in procedural style, but require modifications to all existing “class modules” in object-oriented style.
New data representations cause additive changes in object-oriented style, but require modifications to all “procedure modules”.
CS784 26

27. Object-Oriented Concepts
Data Abstraction (specifies behavior)
Encapsulation (controls visibility of names)
Polymorphism (accommodates various implementations)
Inheritance (facilitates code reuse)
Modularity (relates to unit of compilation)
CS784 27

28. Example : Role of interface in decoupling
Client
Determine the number of elements in a collection.
Suppliers
Collections : Vector, String, List, Set, Array, etc
Procedural Style
A client is responsible for invoking appropriate supplier function for determining the size.
OOP Style
Suppliers are responsible for conforming to the standard interface required for exporting the size functionality to a client.
In OOP style, the interface between suppliers and clients is standardized, so that by requiring the suppliers to conform to this standard, the clients can safely assume the form of messages.
This enables clients to choose from a number of suppliers facilitating interchangeability, upgradability, reuse, etc and enables clients to be extendable by being able to accommodate future suppliers that conform to the standard (open universe context).
E.g, Double-click on DeskTop icons for view,
Displaying info : XML approach, etc
CS784 28 28

29. Client in Scheme (define (size C) (cond
( (vector? C) (vector-length C) )
( (pair? C) (length C) )
( (string? C) (string-length C) )
( else “size not supported”) )))
(size (vector 1 2 (+ 1 2)))
(size ‘(one “two” 3))
When a new collection is added, in the procedural style, the entire client needs to be recompiled because of the additional clause in the COND.
Furthermore, it is the client’s responsibility to write the glue code to get the appropriate functionality from what the supplier provides.
These restrictions make it suitable for closed world applications.
CS784 29 29

30. Suppliers and Client in Java
Interface Collection {int size(); }
class myVector extends Vector
implements Collection { }
class myString extends String
public int size() { return length();}
class myArray implements Collection {
int[] array;
public int size() {return array.length;}
Collection c = new myVector(); c.size();
Standard interfaces are a minimum requirement for flexibility, and for supporting reuse and interchangeability.
The supplier is responsible for conforming to the interface.
Interfaces and Dynamic Binding ensure that the client not need to be aware of the implementation details of the supplier and can comfortably handle different suppliers at run-time.
CS784 30 30