Jigar Gaglani

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

 Procedural/Imperative  Functional  Logic  Object-Oriented

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

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

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

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

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

 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

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

 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

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

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

 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

 Declarative programming is a non- imperative style of programming  Does not explicitly list command or steps that need to be carried out to achieve the results.

 For example: List collection = new List {1,2,3,4,5 };  Imperative programming List results = new List (); foreach(var num in collection) { if (num % 2 != 0) results.Add(num); }

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

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

 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

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

 spam = ['pork','ham','spices'] numbers = [1,2,3,4,5] def eggs(item): return item map(aFunction, aSequence)

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

 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) print L

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

 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

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

 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 ?- sunny.

 facts consist of a relation and the items that this refers to, called arguments  A general model is shown below: relation(,,...., ).

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

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

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

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

 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

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

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

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

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

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

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

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

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

 Class  Object  Instance  Method  Message passing  Inheritance  Abstraction  Encapsulation  Polymorphism  Decoupling

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

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

 ming  Files/plbook/imperati.htm  ming  tutorial.org/functional_programming   now/html/node90.html