Principles of Programming Languages Lecture 1 Slides by Daniel Deutch, based on lecture notes by...
-
Upload
edward-gilmore -
Category
Documents
-
view
222 -
download
0
Transcript of Principles of Programming Languages Lecture 1 Slides by Daniel Deutch, based on lecture notes by...
Principles of Programming Languages
Lecture 1
Slides by Daniel Deutch, based on lecture notes by Prof. Mira Balaban
Introduction• We will study Modeling and Programming Computational Processes• Design Principles
– Modularity, abstraction, contracts…• Programming languages features
– Functional Programming• E.g. Scheme, ML• Functions are first-class objects
– Logic Programming• E.g. Prolog• “Declarative Programming”
– Imperative Programming• E.g. C,Java, Pascal• Focuses on change of state
– Not always a crisp distinction – for instance scheme can be used for imperative programming.
3
Declarative Knowledge
0 and such that theis 2 yxyyx
“What is true”
4
To find an approximation of x:
• Make a guess G• Improve the guess by averaging G and x/G• Keep improving the guess until it is good enough
Imperative and Functional Knowledge
“How to”
An algorithm due to:
[Heron of Alexandria]
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• Scheme
– Dynamically Typed– Functions are first-class citizens– Simple (though lots of parenthesis ) and allows to show different programming styles
• ML– Statically typed language– Polymorphic types
• Prolog– Declarative, Logic programming language
• Languages are important, but we will focus on the principles
Administrative Issues
•Web-site•Exercises•Mid-term•Exam •Grade
Use of Slides
• Slides are teaching-aids, i.e. by nature incomplete
• Compulsory material include everything taught in class, practical sessions as well as compulsory reading if mentioned
Today
• Scheme basics– Syntax and Semantics– The interpreter– Expressions, values, types..
10
Scheme
• LISP = LISt Processing– Invented in 1959 by John McCarthy– Scheme is a dialect of LISP – invented by Gerry
Sussman and Guy Steele
11
The Scheme Interpreter
• The Read/Evaluate/Print Loop– Read an expression– Compute its value– Print the result
– Repeat the above
• The (Global) Environment
– Mapping of names to values
score23
total25
percentage92
Name Value
12
Language Elements
Means of Abstraction
(define score 23)Associates score with 23 in environment table
Syntax Semantics
Means of Combination
(composites)
(+ 3 17 5)Application of proc to arguments
Result = 25
Primitives23+*#t, #f
23
Primitive Proc (add)
Primitive Proc (mult)
Boolean
13
Computing in Scheme
>==23
23
+( >==3 17 5)
25
+( >==3 *( 5 6 )8 2)
43
( >==define score 23)
Name Value
Environment Table
23score
Opening parenthesis
Expression whose value is a procedure
Other expressions
Closing parenthesis
14
Computing in Scheme
>==score
23
( >==define total 25)
*( >==100 /( score total))
92
( >==define percentage (* 100 (/ score total))
Name Value
Environment
23score
25total
92percentage
>==
Atomic (can’t decompose) but not primitive
A name-value pair in the env. is called binding
15
Evaluation of Expressions
To Evaluate a combination: (as opposed to special form)a. Evaluate all of the sub-expressions in some orderb. Apply the procedure that is the value of the leftmost
sub-expression to the arguments (the values of the other sub-expressions)
The value of a numeral: numberThe value of a built-in operator: machine instructions to executeThe value of any name: the associated value in the environment
16
Using Evaluation Rules
( >==define score 23)
+( *( >==5 6 -( ) score (* 2 3 2 )))
Special Form (second sub-expression is not evaluated)
* + 5 6
11
- 23 * 3 22
12
11
121
17
Abstraction – Compound Procedures
•How does one describe procedures?
•(lambda (x) (* x x))
To process something multiply it by itself
formal parameters
body
Internal representation
• Special form – creates a “procedure object” and returns it as a “value”
Proc (x) (* x x)
18
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?
19
Evaluation of An ExpressionTo 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 5)
25
20
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
To Evaluate a combination: (other than special form).aEvaluate all of the sub-expressions in any order.bApply the procedure that is the value of the leftmost sub-expression to the
arguments (the values of the other sub-expressions)
The value of a numeral: numberThe value of a built-in operator: machine instructions to executeThe value of any name: the associated object in the environment
21
Using Abstractions
( >==square 3)
9
( +( >==square 3( )square 4))
( >==define square (lambda(x)(* x x)))
*( 3 3 *( )4 4)
9 16+
25
Environment Table
NameValuesquare Proc (x)(* x x)
22
Yet More Abstractions
==> (define f (lambda(a) (sum-of-two-squares (+ a 3) (* a 3))))
( >==sum-of-two-squares 3 4)
25
==> (define sum-of-two-squares (lambda(x y)(+ (square x) (square y))))
Try it out…compute (f 3) on your own
23
Evaluation of An Expression (reminder)
To Apply a compound procedure: (to a list of arguments) Evaluate the body of the procedure with the formal parameters
substituted by the corresponding actual values
To Evaluate a combination: (other than special form).aEvaluate all of the sub-expressions in any order.bApply the procedure that is the value of the leftmost sub-expression to the
arguments (the values of the other sub-expressions)
The value of a numeral: numberThe value of a built-in operator: machine instructions to executeThe value of any name: the associated object in the environment
24
Lets not forget The Environment
( >==define x 8 )
+( >==x 1 )
9
( >==define x 5 )
+( >==x 1 )
6The value of (+ x 1) depends
on the environment !
25
Using the substitution model
)define square (lambda (x) (* x x))()define average (lambda (x y) (/ (+ x y) 2))(
)average 5 (square 3)()average 5 (* 3 3)(
)average 5 9(first evaluate operands,then substitute
+) /)5 9 (2( /)14 2(if operator is a primitive procedure,
7replace by result of operation
26
Booleans
Two distinguished values denoted by the constants
#t and #f
The type of these values is boolean
<( >==2 3 )
#t
<( >==4 3 )
#f
27
Values and types
Values have types. For example:
In scheme almost every expression has a value
Examples:
1) The value of 23 is 232) The value of + is a primitive procedure for addition3) The value of (lambda (x) (* x x)) is the compound
procedure proc(x) (* x x) (also denoted <Closure (x) (* x x)>
1) The type of 23 is numeral 2) The type of + is a primitive procedure3) The type of proc (x) (* x x) is a compound procedure4) The type of (> x 1) is a boolean (or logical)
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
29
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 func., prints the value of its argument to the screen]
• In scheme, the value of a define, display expression is “undefined” . This means “implementation-dependent”
• 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 ]
31
More examples
( >==define x 8 )
Name Value
Environment Table
8x
( >==define x (* x 2) )
>==x
16 16
( >==define x y )
reference to undefined identifier: y
( >==define )- +
>-<#+
+( >==2 2)
0
Bad practice, disalowed by some interpreters
32
The IF special form
ERROR2
(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 3 >== )2
(if (< 2 3) 2 (/ 1 0) >== )
33
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 !
Conditionals
(lambda (a b) (cond ( (> a b) a) ( (< a b) b) (else -1 )))
35
Syntactic Sugar for naming procedures
(define square (lambda (x) (* x x))
(define (square x) (* x x) )
Instead of writing:
We can write:
36
(define second )
(second 2 15 3 >== )15
(second 34 -5 16- >== )5
Some examples:
(lambda (x) (* 2 x))
(lambda (x y z) y)
Using “syntactic sugar:”
(define (twice x) (* 2 x))
Using “syntactic sugar:”
(define (second x y z) y)
(define twice )
(twice 2) ==> 4
(twice 3) ==> 6
Symbols> (quote a)a> ’aa> (define a ’a)> aa> ba> (define 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
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 for functions is denoted “->”
• Example: [Number X Number –> Number] is the type of all procedures that get as input two numbers, and return a number
• If all types are allowed we use a type variable:– [T –> T] is the type of all procs. That return the same type as they get
as input
• Note: there is nothing in the syntax for defining types! This is a convention we manually enforce (for now..).
Scheme Type Grammar
Type --> ’Unit’ | Non-Unit [Unit=Void]Non-unit -> Atomic | Composite | Type-variableAtomic --> ’Number’ | ’Boolean’ | ’Symbol’Composite --> Procedure | UnionProcedure --> ’Unit ’->’ Type | ’[’ (Non-Unit ’*’)* Non-Unit ’->’ Type ’]’Union --> Type ’union’ TypeType-variable -> A symbol starting with an upper case letter
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