Principles of Programming Languages Lecture 1 Slides by

Principles of Programming Languages Lecture 1 Slides by Yaron Gonen, based on slides by Daniel Deutch and lecture notes by Prof. Mira Balaban

4 ٤ IV 100

4+5 4 + “hello” +

So What have We Seen? • • Syntax Values Types Operators

Introduction • We will study Computational Processes • Design Principles – Modularity, abstraction, contracts… • Programming Languages Paradigms – Functional Programming • E. g. Racket, Scheme, ML, Java. Script (partially), Java (Since Java 8) • Functions are first-class objects – Logic Programming • E. g. Prolog • “Declarative Programming” – Imperative Programming • E. g. C, Java • Focuses on change of state – Not always a crisp distinction – for instance scheme can be used for imperative programming.

More topics • Types – Type Inference and Type Checking – Static and Dynamic Typing • Different Semantics (e. g. Operational) • Interpreters vs. Compilers – Lazy and applicative evaluation

Languages that will be studied • Racket (dialect of Scheme) – Dynamically Typed – Functions are first-class citizens – Simple (though LOTS of parenthesis ) – Allows to show different programming styles • Prolog – Declarative, Logic programming language • Languages are important, but we will focus on the principles

Administrative Issues • Websites prefix http: //www. cs. bgu. ac. il/ – Course: /~ppl 152 – My (for presentations): /~yarongon • • • Weeks: 14 Exercises: 6 Mid-term Exam Grade

Use of Slides • Slides are teaching-aids, i. e. by nature incomplete • Compulsory material: – Lecture notes (see course website) – Everything taught in class and practical sessions – Compulsory reading if mentioned • Will be on my site (I’ll try as early as possible)

“Wax on, wax off”

Functional Programming • What is a non-functional (imperative) programming? – Imperative computation is a sequence of states (remember automata? ) – Statements or side effects can modify the state (e. g. changing value of variable, display output)

Functional Programming • • • Expressions (no statements) No State (no mutable data) No side-effects Has variables, but denote values (no location) We learn as we go This is not a course in functional programming!! (for that you have APL)

Why Functional Programming? • Small paradigm (but powerful) • Excellent for learning PPL • Is making a comeback in recent years (Java 8, Javascript, Node. JS, Map. Reduce…) • There’s FUN in Functional Programming…

The Power of Abstraction

Racket (Scheme) • LISP = LISt Processing – Invented in 1959 by John Mc. Carthy – Scheme is a dialect of LISP – invented by Gerry Sussman and Guy Steele – Racket is a dialect of Scheme – Small and powerful – Technical stuff in PS and in course website (how to install etc. ) 15

A Word about Values • Value is an abstract concept – User typed “ 4” get the value 4 – Computer calculated the value 4 need to display to user (to. String)

The Racket Interpreter • The Read/Evaluate/Print Loop – Read an expression – Compute its value – Print the result – Repeat the above • The Global Environment – Function from names to values 17 Name Value score 23 total 25 percentage 92

Expressions: Language Elements Primitives Means of Combination (composites) Means of Abstraction 18 Syntax 23 + * #t, #f (+ 3 17 5) (define score 23) Semantics 23 Primitive Proc (add) Primitive Proc (mult) Boolean Application of proc to arguments Result = 25 Associates score with 23 in environment table

Computing in Scheme > 23 Expression whose value is a procedure Closing parenthesis 23 > (+ 3 17 5) 25 Opening parenthesis Environment Table Other expressions > (+ 3 (* 5 6) 8 2) 43 > (define score 23) 19 Name Value score 23

Computing in Scheme Atomic (can’t decompose) but not primitive > score Environment 23 Name Value > (define total 25) score 23 > (* 100 (/ score total)) total 25 92 percentage 92 > (define percentage (* 100 (/ score total)) A name-value pair in the env. is called binding 20

Evaluation of Expressions • The value of a numeral: number • The value of a boolean: true or false • The value of a built-in operator (primitive procedure): machine instructions to execute • The value of any name: the associated value in the environment 21

Evaluation of Expressions • To Evaluate a combination: (as opposed to special form) – Evaluate all of the sub-expressions in some order – Apply the procedure that is the value of the leftmost sub-expression to the arguments (the values of the other sub-expressions) 22

Using Evaluation Rules > (define score 23) > (* (+ 5 6 ) (- * 5 6 + - Special Form (second subexpression is not evaluated) score (* 2 3 2 ))) 23 * 2 3 2 11 121 23

Abstraction – Compound Procedures How does one describe procedures? formal parameters (lambda (x) (* x x)) To process something body multiply it by itself • Special form – creates a “procedure object” (also called closure) and returns it as a “value” Internal representation Proc (x) (* x x) 24

More on lambdas • The use of the word “lambda” is taken from lambda calculus. • A lambda body can consist of a sequence of expressions • The value returned is the value of the last one • So why have multiple expressions at all? 25

Syntactic Sugar for naming procedures Instead of writing: (define square (lambda (x) (* x x)) We can write: (define (square x) (* x x)) 26

Evaluation of An Expression To Apply a compound procedure: (to a list of arguments) Evaluate the body of the procedure with the formal parameters replaced by the corresponding actual values ==> ((lambda(x)(* x x)) 5) Proc(x)(* x x) (* 5 5) 25 27 5

Evaluation of An Expression • To Apply a compound procedure: (to a list of arguments) – Evaluate the body of the procedure with the formal parameters replaced by the corresponding actual values 28

Using Abstractions > (define square (lambda(x)(* x x))) > (square 3) Environment Table Name square 9 Value Proc (x)(* x x) > (+ (square 3) (square 4)) (* 3 3) + 25 29 9 16 (* 4 4)

Yet More Abstractions > (define sum-of-two-squares (lambda(x y)(+ (square x) (square y)))) > (sum-of-two-squares 3 4) 25 > (define f (lambda(a) (sum-of-two-squares (+ a 3) (* a 3)))) Try it out…compute (f 3) on your own 30

Lets not forget The Environment > (define x 8) > (+ x 1) 9 > (define x 5) > (+ x 1) 6 31 The value of (+ x 1) depends on the environment!

Booleans Two distinguished values denoted by the constants #t and #f The type of these values is boolean > (< 2 3) #t > (< 4 3) #f 33

Values and types In scheme almost every expression has a value Examples: 1) The value of 23 is 23 2) The value of + is a primitive procedure for addition 3) The value of (lambda (x) (* x x)) is the compound procedure proc(x) (* x x) (also denoted <Closure (x) (* x x)> Values have types. For example: 1) 2) 3) 4) The type of 23 is numeral The type of + is a primitive procedure The type of proc (x) (* x x) is a compound procedure The type of (> x 1) is a boolean (or logical) 34

Atomic and Compound Types • Atomic types – Numbers, Booleans, Symbols (TBD) • Composite types – Types composed of other types – So far: only procedures – We will see others later

No Value? • In scheme most expressions have values • Not all! Those that don’t usually have side effects Example : what is the value of the expression (define x 8) And of (display x) [display is a primitive function that prints the value of its argument to the screen] • In scheme, the value of a define, display expression is “undefined”. 36 Never write code that relies on such value!

Dynamic Typing • Note that we never specify explicitly types of variables • However primitive functions expect values of a certain type! – E. g. “+” expects numeral values • So will our procedures (To be discussed soon) • The Scheme interpreter checks type correctness at run-time: dynamic typing – [As opposed to static typing verified by a compiler ]

More examples > (define x 8) Environment Table > (define x (* x 2)) Name > x Value x 16 + > (define x y) reference to undefined identifier: y > (define + -) > (+ 2 2) 0 Bad practice, disalowed by some interpreters 38 16 8 #<->

The IF special form (if <predicate> <consequent> <alternative>) If the value of <predicate> is #t, Evaluate <consequent> and return it Otherwise Evaluate <alternative> and return it (if (< 2 3) ==> 2 (if (< 2 3) 2 (/ 1 0)) ==> ERROR 2 39

IF is a special form • In a general form, we first evaluate all arguments and then apply the function • (if <predicate> <consequent> <alternative>) is different: <predicate> determines whether we evaluate <consequent> or <alternative>. We evaluate only one of them ! 40

Condition (lambda (a b) (cond ( (> a b) a) ( (< a b) b) (else -1 )))

cond is a Special Form (cond (<p 1> <e 11>. . . <e 1 k 1>) (<p 2> <e 21>. . . <e 2 k 2>). . . (else <en 1>. . . <enkn>))

Expressions: Summary Atomic Composite • Primitives • Specials forms – Numbers – Booleans – Procedures • Non-primitives – Variables – Special operators symbols – define, lambda, if, cond • Forms

Evaluation: Summary Atomic • • Number Boolean Built-in Primitive Variable Composite • Primitive operator • Operator is a procedure (value of lambda) • Special form (define, if, lambda, cond)

Symbol Type > (quote a) a > ’a a > (define a ’a) > a a > (define b a) > b a > (eq? a b) #t > (symbol? a) #t > (define c 1) > (symbol? c) #f > (number? c) #t Symbols are atomic types, their values unbreakable: ‘abc is just a symbol Primitive procedure that compares two values Primitive procedure that checks if the value is of type symbol

More on Types • A procedure type is a composite type, as it is composed of the types of its inputs (domain) and output (range) • In fact, the procedure type can be instantiated with any type for domain and range, resulting in a different type for the procedure (=data) • Such types are called polymorphic – Another polymorphic type: arrays of values of type X (e. g. STL vectors in C++)

Type constructor • Defines a composite type out of other types • The type constructor functions is denoted “->” • Example: [Number X Number –> Number] is the type of all procedures that get as input two numbers, and return a number • Note: there is nothing in the syntax for defining types! This is a convention we manually enforce (for now. . ).

Value constructor • Means of defining an instance of a particular type. • The value constructors for procedures is lambda – Each lambda expression generates a new procedure