Presentation is loading. Please wait.

Presentation is loading. Please wait.

1 Chapter 8: Overview of Programming Language Paradigms Outline Imperative Languages Functional Programming Logic Programming Object-oriented Programming.

Similar presentations

Presentation on theme: "1 Chapter 8: Overview of Programming Language Paradigms Outline Imperative Languages Functional Programming Logic Programming Object-oriented Programming."— Presentation transcript:

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

2 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 3 Imperative Languages 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 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 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 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 7 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 = 3.14  Pi:.DATA3.14 (in Pascal) (in assembly language) Imperative Languages

8 8 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 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 10 Imperative Languages Boolean conditions: 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 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 else 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 12 Imperative Languages Compound Statement Form: begin S 1 ; S 2 ; … S N ; end; Example begin writeln(‘This is the first statement’); writeln(‘This is the second statement’); writeln(‘This is the third statement’); end; Attention: semicolon after the “end”

13 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 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 begin sum := sum + number; readln(number); end; writeln( ‘ The total is ‘, sum:5); end.

15 15 Imperative Languages Example of user session (after running the program “ adder ” ): Enter a positive integer, terminate with an negative integer ’ 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 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 17 Imperative Languages The Fortran program: 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 READ(*,*) NUMBER GO TO 10 ENDIF WRITE(*,20) SUM 20 FORMAT(‘ ‘, ‘The Total is ‘, I5) END

18 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 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 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 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 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 23 Imperative Languages Adder program in C: /* This a comment, the program adds positive integers until a negative one is typed in */ #include /* 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 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 25 Functional Programming 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 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 actual argument = 3  the result value is 6 Because 3. is a repetition of 1., the same result is produced

27 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 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 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.x 2 Sample invocations with actual arguments (polynomial 3)  result: 18 (polynomial 4)  result: 32 (polynomial -1)  result: 2

30 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 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 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!!! Example (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 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 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 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 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 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 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 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 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 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 42 Insertion: Recursive Functions Another example Fibonacci numbers: F 1 = F 2 = 1 F n = F n-1 + F n-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: Get N 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 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 Algorithmic Foundations Hardware Virtual Machine Software Applications Social Issues But now each chapter is a disk

44 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 InitialAuxiliaryTarget

45 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 Move 1 to Target InitialAuxiliaryTarget 3 1 2

46 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 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) Print “ Move N from i to t ” 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 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 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 50 Logic Programming Prolog facts: 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 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). No.

52 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 Example: ?-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 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 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). Yes.

55 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 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 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 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 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 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: Dynamic binding Multiple inheritance

61 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 62 Parallel Programming Example for SIMD: 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 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) End Parallel

Download ppt "1 Chapter 8: Overview of Programming Language Paradigms Outline Imperative Languages Functional Programming Logic Programming Object-oriented Programming."

Similar presentations

Ads by Google