Introduction to Programming Paradigms. Prepared By: Neeraj Raheja

Transcription

1 Introduction to Programming Paradigms Prepared By: Neeraj Raheja

2 Programming paradigm is a fundamental style of computer programming Paradigms differ in concepts and abstractions used to represent the elements of program

3 Procedural/Imperative Functional Logic Object-Oriented

4 Derived from latin word imperare means to command 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.

5 It defines sequences of commands for the computer to perform Imperative programming is characterized by programming with a state and commands

6 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.

7 For example, X := X+2 Assignment changes the value at a location. A program execution generates a sequence of states

8 The unstructured commands contains: assignment command, sequential composition of commands, a provision to identify a command with a label, unconditional and conditional GOTO commands

9 The unconditional goto command has the form: goto LABEL i The sequence of instructions next executed begin with the command labeled with LABEL i. The conditional goto command has the form: if conditional expression then goto LABEL i

10 The goal of structured programming is to provide control structures that make it easier to reason about imperative programs.

11 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

12 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.

13 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.

14 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

15 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.

16 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);

17 Declarative programming var results = collection.where( num=>num%2!= 0); Does not step through the collection

18 Procedural Assembler, Fortran, Cobol, C, etc Non-Procedural SQL, Visual Basic, etc etc.

19 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

20 Functional programming is all about expressions. Functions are used as objects in FP. Functional Programming is about abstraction and reducing complexity

21 spam = ['pork','ham','spices'] numbers = [1,2,3,4,5] def eggs(item): return item map(afunction, asequence)

22 L = map(eggs, spam) print L Same thing could have been done by: for i in spam: L.append(i) print L

23 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)

24 It is the use of mathematical logic for computer programming The problem-solving task is split between the programmer and theorem-prover

25 To study logic programming means to study proofs. It is based upon the fact of a backwards reasoning proof Eg. : If B 1 and and B n then H

26 Prolog is a general purpose logic programming language associated with artificial intelligence and computational linguistics It is based on Facts and Rules

27 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

28 facts consist of a relation and the items that this refers to, called arguments A general model is shown below: relation(<argument1>,<argument2>,...,<arg umentn> ).

29 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.

30 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).

31 Now if we ask to prolog :?- mortal(socrate). What prolog will respond? Why?

32 One of Prolog's most useful features is the simple way it lets us state generalizations. Example: enjoys(vincent,x) :- burger(x). Vincent enjoys burgers, except Big Kahuna burgers, how do we state this in Prolog?

33 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

34 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).

35 The first two lines describe Vincent's preferences. The last 4 lines describe a world containing 3 burgers, a, b, and c

36 This is what happens:?- enjoys(vincent,a). yes?- enjoys(vincent,b). no?- enjoys(vincent,c). yes

37 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).

38 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)).

39 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.

40 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.

41 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.

42 Class Object Instance Method Message passing Inheritance Abstraction Encapsulation Polymorphism

43 Encapsulation: a logical boundary around methods and properties Inheritance Re-usability method overloading and overriding Information Hiding is achieved through "Access Modifiers"

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