1. Jigar Gaglani

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 non- imperative style of programming  Does not explicitly list command or steps that need to be carried out to achieve the results.

16.  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); }

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

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

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

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

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?

48.  http://en.wikipedia.org/wiki/Imperative_program ming  http://www.emu.edu.tr/aelci/Courses/D-318/D- 318-Files/plbook/imperati.htm  http://en.wikipedia.org/wiki/Procedural_program ming  http://www.ocaml- tutorial.org/functional_programming  http://boklm.eu/prolog/page_4.html  http://cs.union.edu/~striegnk/learn-prolog- now/html/node90.html