1. Chapter 8: Overview of Programming Language Paradigms
Outline
Imperative Languages
Functional Programming
Logic Programming
Object-oriented Programming
Parallel Programming
Social Issues
Applications
Software
Virtual Machine
Hardware
Algorithmic Foundations

2. Imperative Languages
From Chapter 7 we know that a HLL has following advantages when compared to assembly language (or machine language):
1. Programmers need not to manage data movement
2. Programmers have a macroscopic view of tasks
3. Programs in HLL are portable (not machine specific)
4. Statements in a HLL are closer to standard English and usual notations
Consider LOGO:
1. Yes: MAKE “x SUM THING “y 4  no explicit data movement
2. Yes: no store and load, jump to address instruction
3. Yes: LOGO programs are portable
4. Yes: LOGO programs are far more descriptive than assembly/machine language
Thus, in fact LOGO is a “good” representative of a HLL when we restrict ourselves to above four characteristics

3. Imperative Languages The consequence is:
However:
LOGO has one similarity to assembly language:
 The programmer still thinks of memory locations when treating data
How?: LOGO uses the notion of a “variable” in order to indirectly “speak” of memory (in fact LOGO is rather functional but it uses variables too)
To be more clear: A variable is nothing but a memory location with a name associated to it (not an address as in assembly language!).
The consequence is:
Any program is treating “named” memory but in a similar way the machine does it internally, that is, instruction by instruction
The philosophy of instructing the processor to do something is partly clear in a LOGO program
Any programming language that is based on such instruction philosophy is called Imperative Language (or Procedural Language)

4. Imperative Languages Example of imperative languages:
LOGO has imperative constructs (but is rather functional)
Pascal
Fortran C
Cobol
Last 4 languages have the same philosophy, namely, treating the program as a sequence of (high-level) instructions that manipulate data stored in named memory (or variables)
Hence: They are very similar as we shall see
We will look at these languages by means of the following example:
A user types in nonnegative integers
The program reads them until a sentinel (negative) value is typed in
The program then displays the sum of read integers
This program will serve as comparison of the four languages

5. Imperative Languages
But before speaking about the program, you may be asking yourself a) what is different in these languages, and b) why do we need different but similar ones relying on the same philosophy?
1) Differences?
differences in syntax (rules of grammar!)
Rules of control flow; e.g. how an if-then-else or while loop statement is represented
How modules are represented
 But once again all of them base on the step-by-step way of problem solving and the notion of a variable
2) Do we need all of them?
Strictly speaking no, BUT that was an evolution…
Also, each of these languages was designed for a special application domain

6. Imperative Languages Examples: Pascal  Teaching
Fortran  Numerical applications
Cobol  Databases
C  Operating systems
Pascal was designed by N. Wirth (ETH Zurich, Switzerland) in the 1970s with the aim of teaching disciplined programming
A Pascal name can be any combination of letters and digits as long as it starts with a letter
Some reserved words are not allowed as names
Constant values can be given names:
const Pi = 3.14
Changeable values are called variables and they can be named:
var Radius: real;
Since binary numbers may be interpreted as positive whole numbers, signed numbers, letters, or real numbers, Pascal enforces the programmer to declare the type of each variable

7. Imperative Languages Suppose we declare two variables: var
Number: integer;
Letter: char;
Pascal will not allow us to add Letter to Number (since it does not make sense)
 Our program will be more reliable than in assembly language, where such errors cannot be intercepted.
Data types in Pascal:
integer: whole numbers
real: real numbers
char: letters
Words like var, integer, char, const and so on are reserved words
const Pi =  Pi: .DATA 3.14
(in Pascal) (in assembly language)

8. Imperative Languages Input-output statements:
Recall in our Pseudo language, we wrote for example:
Get values of Radius
Written in Pascal this would be:
readln(Radius);
Correspondingly, for:
Print value of Surface
In Pascal:
writeln(Surface);
Better:
writeln(‘The surface is ‘, Surface);
Print a new (empty) line:
writeln;

9. Imperative Languages Statements in Pascal: variable := expression;
Meaning:
Set the value of “variable” to “(arithmetic) expression”
Steps:
1. Evaluate expression
2. Copy the value to the memory location associated with “variable”
Examples:
B := 3; C := -12; A := A + 1;
A := B + C; NetSalary := Income – Tax;
Recall: one such assignment corresponds to several assembly language instructions.

10. Imperative Languages Boolean conditions: Initial := ‘D’;
An expression that evaluates to “true” or “false”
Examples:
 A = 0 (is A equal zero?)
 B < (A+C) (is the values of B less than the sum of the values of A and C?)
 A <> B (is the value of A not equal the value of B?)
Comparison need not be numeric, example for use of char:
Initial := ‘D’;
Initial = ‘F’ (false)
Initial < ‘P’; (true)
Use of AND and OR is allowed:
(A = 0) or (B < (A+C))

11. Imperative Languages If-then-else statement General form
if(Boolean condition) then S1
else
S2;
Example:
if(B < (A+C)) then
A := 2*A
A := 3*A;
Suppose:
Before: B = 2, A = 2, C = 3  After: B = 2, A = 4, C = 3
Before: B = 6, A = 2, C = 3  After: B = 6, A = 6, C = 3

12. Imperative Languages Compound Statement Form: begin S1; S2; … SN; end;
Example
writeln(‘This is the first statement’);
writeln(‘This is the second statement’);
writeln(‘This is the third statement’);
Attention: semicolon after the “end”

13. Imperative Languages While loops in Pascal
General form of a While-loop
while(Boolean condition) do
S1;
Example: while (c > 0) do c := c –1;
Also functions/procedures are allowed in Pascal
Comments between curly braces  { comment }
Structure of a Pascal program:
program “program name” (list of files)
constant declarations;
variable declarations;
procedure declarations;
begin
program body
end.

14. Imperative Languages
program adder(input, output) {adds positive integers and terminates with a negative one} var number: integer; sum : integer;
begin
writeln(‘Enter a positive integer, terminate with a negative integer’);
sum := 0;
readln(number);
while(number >= 0) do
sum := sum + number;
end;
writeln(‘The total is ‘, sum:5);
end.

15. Imperative Languages
Example of user session (after running the program “adder”):
Enter a positive integer, terminate with an negative integer’ 89
116 43
-1234
The total is 248
NOW: let us use another language, FORTRAN, for the same program
FORTRAN = FORmula TRANslation
Introduced very early in the mid-1950s at IBM
First HLL in the world; intended for engineering purposes

16. Imperative Languages Unlike Pascal, Fortran has the following rules:
Program instruction must be written between columns 7-72
First 6 columns used for special purposes
A ‘C’ in the first column indicates that the line is a comment
Columns 1-5 are used for statement numbers (“numeric” labels, like assembly language!)
A positive integer value in column 6 indicates that the line is a continuation of the precedent one
No punctuations separate statements (compare semicolon in Pascal) because each line is a complete instruction unless denoted by the 6-th column of the next line
Variable names have at most 6 characters, all uppercase letters or digits but always beginning with an uppercase letter
Numerical variables do not need to be declared; defaults are I, J, K, L, M, and N for integers and other names for real variables

17. Imperative Languages The Fortran program: 123456 PROGRAM MAIN
C adds positive integers and terminates with a negative one
INTEGER SUM, NUMBER
WRITE(*,*) ‘Enter a positive integer, terminate with a negative one’
SUM = 0
READ(*,*) NUMBER
10 IF (NUMBER .GE. 0)THEN
SUM = SUM + NUMBER
GO TO 10
ENDIF
WRITE(*,20) SUM
20 FORMAT(‘ ‘, ‘The Total is ‘, I5)
END

18. Imperative Languages About the program:
We did not need to declare SUM and NUMBER as integers
WRITE(*,*):
1. * = to standard output  screen
2. * = use standard format  here print on a new line
READ(*,*):
1. * = from standard input  keyboard
2. * = free formatting
.GE. = greater or equal (new Fortran compilers allow >=,<=, …)
GO TO: does the work of a while loop
Major difference to Pascal
Gotos make programs unreadable!!!
WRITE(*,20):
20 is the label of the subsequent format instruction
FORMAT(…)
‘ ‘ means single-spacing between lines
Formats output, I5 means 5 positions for the SUM

19. Imperative Languages Fortran is still in use Because of new versions
Because there is a wealth of programmed functions in Fortran, which are well-tested and thus highly reliable
 Reuse of code (is it old?)
Cobol
Cobol = COmmon Business-Oriented Language
Introduced in
Designed for processing files:
Master file: e.g. inventory file containing names and quantities of items available
Transaction files: e.g. containing names and quantities sold
 Master file should be updated (using information of transaction file) e.g. on weekly basis and a summary report would be printed.
Cobol is less formal than Pascal/Fortran:
SUM = A+B reads in Cobol: ADD A TO B GIVING SUM

20. Imperative Languages
Like with FORTRAN there is now a large amount of applications programmed in Cobol
Cobol is more adept at handling file input than keyboard input
For example, the data to be added should be prepared in a file (prior to running the program). This also unburdens the user from entering the same or almost the same data when running the program more than one time
In Cobol columns 1-6 are reserved for line numbers
Column 7 may indicate that the line is a comment
A period marks the end of a sentence, which is a group of one or more statements

21. Imperative Languages
Here the structure of the adder (details are omitted to keep things simple)
IDENTIFICATION DIVISION.
 Here e.g. name of program, author
ENVIRONMENT DIVISION.
 Specify a file as input and the screen as output
DATA DIVISION.
 Specify how data are formatted
PROCEDURE DIVISION.
 the actual program is in the procedure division
BEGIN. OPEN INPUT INPUT-DATA, OUTPUT OUTPUT-DATA.
READ-IT.
 Read next number in the file and print it on the screen if >= 0 and
GO TO E-O-J if the number is negative
E-O-J.
 End of job paragraph
 Write the cumulative sum on the screen
STOP RUN.

22. Imperative Languages The C programming language
Emerged in the early 1970s
HLL but with hardware-oriented constructs
Why?
Because C was designed for systems programming
The operating system Unix was written in C (now other OSs too)
Because sometimes efficiency counts more than readability
In fact, when using C you can be almost as efficient as the underlying hardware, but in the same time you can use powerful HLL abstractions, such modules (in C called functions).
C is now one of the most used programming languages
Compared to Pascal, Fortran, and Cobol, C is rather similar to Pascal
Liberal use of columns
Liberal use of variable names
Compact code
No Gotos are needed (because while can be used)

23. Imperative Languages Adder program in C:
/* This a comment, the program adds positive integers
until a negative one is typed in */
#include <stdio.h> /* always include this when using input and output */
main()
{ /* ‘{‘ is like begin of Pascal; ‘}’ is like end of Pascal */
int number, sum;
sum = 0;
printf(“Enter a positive number, terminate with a negative one\n”); /* like writeln of Pascal */
scanf(“%d”, &number); /* &number means address of the variable number */
while(number >= 0) {
sum = sum + number;
scanf(“%d”, &number); /* like readln of Pascal */ }
printf(“The total is %5d“, sum);

24. Imperative Languages A final word:
The family of imperative languages includes C, Pascal, Fortran, Cobol, and others not mentioned here
The main characteristic of these languages is the use of a step-by-step instruction sequence to solve a problem
All of them use the notion of variables (for memory locations) and programs directly manipulate variables in order to get final results
Similarities
Fortran rather similar to Cobol (Gotos, column numbering, …)
Pascal rather similar to C (no Gotos, while loops, liberal spacing…)
No wonder:
Fortran and Cobol rather old programming languages
Pascal and C are (relatively) newer ones

25. Functional Programming
A program is a combination of transformations on items. The paradigm abstracts from variables, memory, and instructions.
A real functional programming language is LISP
LISP = LISt Processing
Designed 1958 at MIT
Second to FORTRAN in longevity:
FP (Functional Programming) is also another functional programming language designed in 1977 (by designers of Fortran)
Here we will use examples based on Scheme (a Lisp dialect)
Recall: LOGO is also similar to Lisp

26. Functional Programming
Functional programming paradigm:
Everything is a function (or each computing task is a function)
Function (like e.g. in C):
A mathematical recipe for taking argument(s) and doing something
on them, and delivering a result
Formally: f(arg1, arg2, arg3, …) is a function iff f transforms actual values of arg1, arg2, arg3, … into a corresponding result (value) using some specified rules
Different values of args may produce different results
BUT: same values of args always produce same results
Example: f(x) = 2*x
1. actual argument = 3  the result value is 6
2. actual argument = 6  the result value is 12
3. actual argument = 3  the result value is 6
Because 3. is a repetition of 1., the same result is produced

27. Functional Programming
In the broad sense:
A functions transforms a set of input data into a set of output data
In a functional programming language certain functions, called primitives, are predefined (in libraries)
Compare: printf, scanf of C: These are predefined functions
Programmers can also defines own functions:
(define (double x)
(* 2 x))
“define”: indicates that some new function is being defined
The function name (here double) and its arguments (here x) follow in parentheses
After defining a function, we can invoke it by providing its name and a list of argument values (here only one for the x)

28. Functional Programming
Examples of functions invocations:
(double 4)
Result is: 2*4 = 8
(double 6)
Result is: 2*6 = 12
Another function:
(define (square x)
(* x x))
“square” multiplies its argument value by itself
Examples
(square 3)  results is: 9
(square 8)  results is: 64

29. Functional Programming
We can use already defined functions in order to defines new ones
Example:
(define (polynomial x)
(double (square x)))
Mathematically: f(x) = 2.x2
Sample invocations with actual arguments
(polynomial 3)
 result: 18
(polynomial 4)
 result: 32
(polynomial -1)
 result: 2

30. Functional Programming
Computations steps for (polynomial x): ( hidden now!!!)
1. Evaluate the value of x (including accessing memory)
2. Compute the value of (square x) and store the result in r (memory!)
3. Compute the values of (double r) and get the final result
Attention:
These steps are given in order to understand how the computer actually performs the computation
These steps are hidden for the programmer
The programmer does not think in terms of evaluation steps and of memory
For the programmer: “polynomial” is a black box that gives a result when invoked using actual input values; it is a “real” function!

31. Functional Programming
Observe that “polynomial” uses two other functions:
“square”
“double”
In functional programming languages complex functions can be built by applying the results of other functions, which may also apply the results of still other ones, and so on
 functional languages are also called applicative languages
Lisp processes lists of arguments (recall Lisp = LISt Processing)
No arguments means an empty list of arguments, called nil
Primitive list processing functions in Scheme:
list: creates a list of argument
Example
(list 2 3 4)  creates the list (2 3 4)

32. Functional Programming
car: pronounced as in automobile
car takes a nonempty list as argument and returns the first element of the list as a result
Note: the result of car is not always a list!!!
Example
(car (list 2 3 4))  returns 2
cdr: pronounced could-er
cdr takes a nonempty list as argument and returns as a result the list that remains after the first element of the list has been removed
Note: the result of cdr is always a list!!!
(cdr (list 2 3 4))  returns (3 4)
As a special case: if the list has only one element cdr returns nil
(cdr (list 6))  returns nil

33. Functional Programming
null?:
When applied on a list it returns true if the list is nil and false otherwise
Examples:
(null? Nil)  result: true
(null? (2 4 5))  result: false
With the four primitives (list, car, crd, and null?) we can now write our old adder program in Lisp
Rather than using a sentinel value in order to mark end of the list of values to be added, a user only types for example:
(adder (list 3 4 5))
This would produce the result (the sum): = 12

34. Functional Programming
Adder program in Lisp:
(define (adder input-list)
(cond ((null? input-list) 0)
(else (+ (car input-list) (adder (crd input-list)))))
Some remarks about the program:
Adder is a function
It has one argument named input-list
When we invoke it using (adder (list 3 4 5)) the input-list actual value becomes (3 4 5)
cond (conditional) is like if in Pascal or C
Observe:
no loop has been used
Every thing acts a function

35. Functional Programming
Now: how does this program work?
Assume user types in: (adder (list 3 4 5))
Then following steps are performed:
1. input-list = (3 4 5)
2. (null? (3 4 5))  false
3. Else execution:
3.1 (car (3 4 5)) returns 3, which is added to a second quantity
3.2 The second quantity is the result of invoking the adder function on the argument (cdr (3 4 5)), which is (4 5)
3.3 Hence the result so far is: 3 + (adder (list 4 5))
4. Now the program invokes itself again in order to compute the remaining (smaller) part (adder (list 4 5)), thus returning to step 1 with new value for the input-list

36. Functional Programming
5. Once again a test null? is done on the list (4 5)  false
6. Thus, so far results is: (adder (5))
7. Adder function calls itself another time using (5) as input-list
8. Null?  false
9. Result is so far: (adder nil)
10. Last time adder is called using nil as input-list
11. Null?  delivers true this time (since input-list = nil)
12. Thus, final result is = 12
All of these steps are done automatically, after typing (adder (list 3 4 5)), the user will instantly see the result: 12

37. Functional Programming
The computation steps at a glance:
(adder (3 4 5)) =
3 + (adder (4 5)) =
(adder (5)) =
(adder nil) =
= 12
The adder function definition involves itself again, but acting on a shorter list
 Recursion
Recursive function:
A function that uses itself in its definition
e.g. adder uses adder
A way to ensure termination of a recursive function f is to require that any call of f should operate on a smaller input data set (e.g. adder operates on a shorter list)

38. Functional Programming
What is the beauty of functional programming:
You think mathematically: everything is a function
You need not know where temporary values and results are stored
Your program can be very complex but still compact and understandable
Your program is better suited to be verified using a specification (correctness proofs)
No side effects are possible, which enhance reliability
Questionable is efficiency:
Always calling new functions takes time
Function implementations need a lot of memory space
However: for prototyping these questions are not primary ones

39. Insertion: Recursive Functions
Recursion is a fundamental way of problem solving in computer science
In fact, not only Lisp but almost all programming languages (including Pascal, C, Fortran 90) support recursion
Recursion is eminently useful, because it simplifies problem solving tremendously
Recursion is a property of an algorithm, thus, we can treat it without referring to a special programming language, or say you can write recursive algorithms using Pseudo-Code, if we extend it by function definitions
Recursion is often used in real life:
Reading a book may be defined as reading the first page followed by reading the rest of the book (the rest of … = a shorter step!)
Climbing a ladder can be defined as climbing the first rung followed by climbing the rest of the ladder (a shorter step!)
Driving an amount of miles can be defined as driving one mile and then driving the rest of the distance (a shorter distance!)

40. Insertion: Recursive Functions
How to use recursion at the Pseudo-Code level:
Give your algorithm a name and some arguments, the arguments specify the initial problem to solve (that is, the whole problem)
In some steps of the algorithm apply your algorithm (by using its name) on different arguments that specify some sub-problem
Example: computing the factorial N (the product N*(N-1)*…*2*1)
First, here a non-recursive version
Get N
Set fac to 1
Set I to 1
While I <= N
Set fac to fac*I
Increment I
Print fac

41. Insertion: Recursive Functions
Now, the recursive version of factorial:
1. Get N
2. Print fac(N)
fac(N):
1. if(N = 1) then
2. 1
else
3. n*fac(N-1)
Remarks:
Step 1/2: solves the simplest case (N=1)
Step 3: solves the general case by combining a multiplication and a recursive call of the algorithm using a new input argument (N-1); in order words, the problem fac(N) is now broken down to the simpler problem fac(N-1)
This simple example shows how recursion really simplifies a solution of a whole problem by using the solution of a sub-problem

42. Insertion: Recursive Functions
Another example Fibonacci numbers:
F1 = F2 = 1
Fn = Fn-1 + Fn-2 for n >= 2
A non-recursive algorithm (you need to know the formula!):
Get N
Print sqrt(5)/2*((1+sqrt(5))/2)n - sqrt(5)/2*((1-sqrt(5))/2)n
A recursive solution:
Print F(N)
F(N):
If(N = 1 or N = 2) then 1
Else
F(N-1) + F(N-2)
Often, like here, recursion consumes more resources, but recursive solutions are often simpler.

43. Insertion: Recursive Functions
A last (but a nice) example using recursion
Towers of Hanoi:
A number of disks of decreasing diameter are put the one on the other
Like our lecture stuff 
Social Issues
Applications
Software
Virtual Machine
Hardware
Algorithmic Foundations
But now each chapter is a disk

44. Insertion: Recursive Functions
The Hanoi Problem:
Given:
3 different places called: Initial, Target, and Auxiliary AND
A tower of N disks in place Initial
Goal:
Move the tower of disks from Initial to Target using the following 2 rules:
Only one disk may be moved at a time and this disk must be the top disk on a tower
A larger disk can never be placed on top of a smaller one
Initial
Auxiliary
Target

45. Insertion: Recursive Functions
Example: Solution for 3 disks
Move 1 to Target
Move 2 to Auxiliary
Move 1 to Auxiliary
Move 3 to Target
Move 1 to Initial
Move 2 to Target 1 2 3
Initial
Auxiliary
Target

46. Insertion: Recursive Functions
But how about a general solution, that is, for an arbitrary N?
You may get mad when moving without a general scheme …
However: Recursion helps here !!!
Idea of recursive solution:
Move N-1 disks from Initial to Auxiliary
Move disk N from Initial to Target
Move N-1 disks from Auxiliary to Target
Thus, we decompose the problem into 3 steps, each step adheres to the moving rules.
Now the algorithm is easy (we use 1=Initial, 2=Auxiliary, 3=Target):
Get N
HanoiMove(N, 1, 2, 3)

47. Insertion: Recursive Functions
HanoiMove(N, i, a, t):
if(N = 1)
Print “Move N from i to t”
else
HanoiMove(N-1, i, t, a)
HanoiMove(N-1, a, i, t)
Tracing the algorithm:
1 Disk: N = 1  HanoiMove(1, 1, 2, 3)
Prints: Move 1 from 1 to 3
2 Disks: N = 2  HanoiMove(2, 1, 2, 3)
HanoiMove(1, 1, 3, 2)  Prints: Move 1 from 1 to 2
Move 2 from 1 to 3 (printed by this call)
HanoiMove(1, 2, 1, 3)  Prints: Move 1 from 2 to 3

48. Logic Programming
Functional programming has the goal of letting the programmer think about a (virtual) machine that understands functions and operates on them. (no memory, no instructions, etc.)
Logic programming goes a step further:
The programmer should only know facts about a special domain AND
Provide rules of how new facts can be deduced
When a user poses a query (question) to the computer, the latter begins with a fact storehouse and attempts to apply a logical deduction to answer the user query
Domains of interests are those where the use of facts makes sense e.g.:
Medicine
Literature
Chemistry …

49. Logic Programming
Logic has been used successfully to write expert systems
A “human” expert in a special domain provides facts and rules, based on his/her experience and knowledge
A logic program can make inferences that are “close” (?) to what the human expert would make
Best representative of a logic programming language is Prolog
Prolog = PROgramming in LOGic
Facts in Prolog
Express a property about a single object or a relationship among several ones
Example: Domain: US History
Which president was in office during what known event?

50. Logic Programming Prolog facts: That was a prolog program !!!
president(lincoln, gettysburg_address).
president(lincoln, civil_war).
president(nixon, first_moon_landing).
president(jefferson, lewis_and_clack).
president(kennedy, cuban_missile_crisis).
before(jefferson, lincoln).
before(lincoln, fdr).
before(fdr, kennedy).
before(kennedy, nixon).
That was a prolog program !!!
Only a list of facts
No Gotos, whiles, memory references, …

51. Logic Programming User interactions with the program:
User poses a query and
Program tries to answer it
Examples:
?-before(lincoln, fdr). {this is a user query}
Yes. {this is the Prolog answer}
Prolog asks after a response:
More? (Y/N):
If there are no matching facts, Prolog will print:
No.
?-president(lincoln, civil_war).
Yes.
?-president(truman, world_war_II).

52. Logic Programming More complicated queries can be phrased
A comma means an AND
To query facts A and B, the user writes A, B
Example:
?-president(lincoln, civil_war), before(lincoln, fdr).
Yes.
So far, only retrieval from a fact database but Prolog can do more!
 Use of variables
Attention: Do not confuse Prolog variables with variables of Pascal, C, and so on (memory aspect is hidden in Prolog)
Prolog variables are templates and they must begin with uppercase letters
?-president(lincoln, X).
This is to say give ANY known event during the office period of lincoln
Or in other words: ?-president(lincoln, Something).

53. Logic Programming On the query ?-president(lincoln, X).
Prolog would answer:
X = gettysburg_address
X = civil_war
The query ?-before(lincoln, kennedy) would yields to No.
However, the facts:
before(lincoln, fdr).
before(fdr, kennedy).
Are part of the database ???
We have to tell Prolog, by means of a rule, that Lincoln precedes Kennedy, even if the facts do not say that directly
 A new rule has to be added

54. Logic Programming A Prolog rule behaves like an if-then statement
Its form is:
A :- B
This means if fact B is true, then fact A is also true
Now we can add a new rule for the “precedes” relation:
precedes(X, Y) :- before(X, Y).
precedes(X, Y) :- before(X, Z), precedes(Z, Y).
Observe this was a recursive rule!
Now we can ask Prolog:
?-precedes(fdr, kennedy).
Yes.
?-precedes(lincoln, nixon).

55. Logic Programming ?-precedes(lincoln, X).
X = fdr
X = kennedy
X = nixon
We can add another rule to say when an event is earlier than another one.
New rule:
earlier(X, Y) :- president(PX, X), president(PY, Y), precedes(PX, PY).
That is to say: the corresponding president should be earlier
We ask Prolog:
?-earlier(world_war_II, X)
X = first_moon_landing
X = cuban_missile_crisis

56. Object-oriented Programming
OOP is another paradigm: Everything is an object
Idea: simulate the real world where everything is an object that has some properties and can perform some tasks (functions)
OOP does not aim directly to hide the step-by-step instruction scheme (like in functional and logic programming), the idea is rather to put instruction sequences in the right contexts and to leverage more programmability, reliability, and reusability
Objects:
Have attributes and
Behavior
Can communicate among each other

57. Object-oriented Programming
Attributes:
Data related to an object
Exmaple: Object “Person” would have attributes like
Name
Birthday
Hobbies …
Behavior:
Set of functions an object can perform
Example: “Person” has function like:
isWorking()
ReadText()
WriteText()
isAtHome()

58. Object-oriented Programming
Communication among objects:
Using the behavioral functions
Example: Person1 wants to know whether or not person2 is at home:
if(person2.isAtHome())
doSomething1
else
doSomething2
Example: Person1 wants to give something to read to person2:
person2.ReadText(“I am back from my journey …”);
Representatives of OO languages are:
C++
Java
Smalltalk

59. Object-oriented Programming
Attributes and functions may have access restrictions
Public: for everyone to use
Protected: only some objects may use them (e.g. lower in the hierarchy)
Private: only the owner object can use them (not allowed for the public)
Information Hiding (Encapsulation)
Private attributes/functions are not accessible from the outside
Public functions can be provided as interfaces. Access to private data is controlled by the public functions
Inheritance:
Objects may inherit attributes/functions from other ones (“relatives”)
For example:
Object “Student”
Object “Teacher”
Both may inherit attributes/functions from object “Person” (since
they are also persons)

60. Object-oriented Programming
Polymorphism
Operation can operate on different data types
Mechanisms:
Overloading of operators
+: for real, integers, …
- : for real, integers, … …
 selection at compile time
Dynamic binding
Selection of module at run-time
Source of failures:
Multiple inheritance

61. Parallel Programming
Parallel programming aims at reducing computation time
Like OOP parallel programming (PP) does not aim at hiding step-by-step instruction processing
Rather, the Von-Neumann type style is changed in another way:
Computations are allowed to execute in parallel
Classes based on the architecture (see also Chapter 5):
SIMD
 Vector computers
MIMD
 Parallel computers (e.g. Intel iPSC, Transputers, …)

62. Parallel Programming Example for SIMD: Exampl for MIMD:
V: private { V is private for each ALU (in ALU local memory) }
K: public { K is the global for all ALUs (in main memory) } …
Parallel [1..5] { use 5 ALUs }
V = V + K; { done in each ALU }
End Parallel
 Example adds (K, K, K, K, K) to (V, V, V, V, V)
Exampl for MIMD:
Search a name in a 20, 000, 000-entry list
 use 100 processors

63. Parallel Programming
myList = List[ ]: private { for each processor a potion }
Name: public …
Parallel [1..100] { use 100 processors }
SeqSearch(myList, Name, Interrupt)
If found then send interrupt
End Parallel
MIMD does not require that all processors do the same task:
Parallel
Processor 1: A = 1
Processor 2: Read(B)
Processor 3: Average(X, Y, Z)