2. 1 Extended Introduction to Computer Science

3. 2 Administration סגל הקורס: –מרצים: ד"ר דניאל דויטש, איל כהן –מתרגלת:לבנת ג'רבי –בודק: ינון פלד Book: Structure and Interpretation of Computer Programs – by Abelson & Sussman Web: http://www.cs.tau.ac.il/~scheme

4. 3 Course Structure Three Elements –Lectures (הרצאות) –Recitations (תרגולים) –Homework (תרגילי בית) Final Grade = Homework (30%) + Final Exam (70%) חובה להגיש ולקבל ציון עובר עבור לפחות 80% מהתרגילים!!

5. 4 This Course… Is NOT a programming course It is an extended introduction to COMPUTER SCIENCE…

6. 5 Declarative Knowledge “What is true”

7. 6 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 Knowledge “How to” An algorithm due to: [Heron of Alexandria]

8. 7 X = 2G = 1 X/G = 2G = ½ (1+ 2) = 1.5 X/G = 4/3G = ½ (3/2 + 4/3) = 17/12 = 1.416666 X/G = 24/17G = ½ (17/12 + 24/17) = 577/408 = 1.4142156 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

9. 8 “How to” knowledge Process – series of specific, mechanical steps for deducing information, based on simpler data and set of operations Procedure – particular way of describing the steps a process will evolve through Need a language for description: vocabulary rules for connecting elements – syntax rules for assigning meaning to constructs – semantics

10. 9 Designing Programs Controlling Complexity –Black Box Abstraction –Conventional Interfaces –Meta-linguistic Abstraction

11. 10 Scheme We will study LISP = LISt Processing –Invented in 1959 by John McCarthy –Scheme is a dialect of LISP – invented by Gerry Sussman and Guy Steele ExpressionsData or procedures SyntaxSemantics

12. 11 The Scheme Interpreter The Read/Evaluate/Print Loop –Read an expression –Compute its value –Print the result –Repeat the above The Environment score23 total25 percentage92 Name Value

13. 12 Designing Programs Controlling Complexity –Problem Decomposition –Black Box Abstraction Implementation vs. Interface –Modularity

14. 13 Language Elements Means of Abstraction (define score 23) Associates score with 23 in environment table Syntax Semantics Means of Combination (+ 3 17 5) Application of proc to arguments Result = 25 Primitives 23 + * 23 Proc for adding Proc for multiplying

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

16. 15 Computing in Scheme ==> score 23 ==> (define total 25) ==> (* 100 (/ score total)) 92 ==> (define percentage (* 100 (/ score total)) Name Value Environment Table 23score 25total 92percentage ==>

17. 16 Evaluation of Expressions To Evaluate a combination: (as opposed to special form) a.Evaluate all of the sub-expressions in some order b.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: number The value of a built-in operator: machine instructions to execute The value of any name: the associated value in the environment

18. 17 Using Evaluation Rules ==> (define score 23) ==> (* (+ 5 6 ) (- score (* 2 3 2 ))) Special Form (second sub- expression is not evaluated) *+56 11 -23*322 12 11 121

19. 18 Abstraction – Compound Procedures How does one describe procedures? (lambda (x) (* x x)) To process something multiply it by itself formal parametersbody Internal representation Special form – creates a “procedure object” and returns it as a “value” Proc (x) (* x x)

20. 19 Lambda The use of the word “lambda” is taken from lambda calculus. –Introduced in the Discrete Math course. –Useful notation for functions.

21. 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 ==> ((lambda(x)(* x x)) 5) Proc(x)(* x x) 5 (* 5 5) 25

22. 21 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) a.Evaluate all of the sub-expressions in any order b.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: number The value of a built-in operator: machine instructions to execute The value of any name: the associated object in the environment

23. 22 Using Abstractions ==> (square 3) 9 ==> (+ (square 3) (square 4)) ==> (define square (lambda(x)(* x x))) (* 3 3) (* 4 4) 916+ 25 Environment Table NameValue squareProc (x)(* x x)

24. 23 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

25. 24 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) a.Evaluate all of the sub-expressions in any order b.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: number The value of a built-in operator: machine instructions to execute The value of any name: the associated object in the environment The Substitution model  reduction in lambda calculus

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

27. 26 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

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

29. 28 Values and types Values have types. For example: 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) 1)The type of 23 is numeral 2)The type of + is a primitive procedure 3)The type of proc (x) (* x x) is a compound procedure 4)The type of (> x 1) is a boolean (or logical)

30. 29 No Value? In scheme almost every expression has a value Why almost? Example : what is the value of the expression (define x 8) In scheme, the value of a define expression is “undefined”. This means “implementation-dependent” Dr. Scheme does not return (print) any value for a define expression. Other interpreters may act differently.

31. 30 More examples ==> (define x 8) Name Value Environment Table 8x ==> (define x (* x 2)) ==> x 16 ==> (define x y) reference to undefined identifier: y ==> (define + -) # + ==> (+ 2 2) 0

32. 31 The IF special form ERROR2 (if ) If the value of is #t, Evaluate and return it Otherwise Evaluate and return it (if ( 2 (if (

33. 32 IF is a special form In a general form, we first evaluate all arguments and then apply the function (if ) is different: determines whether we evaluate or. We evaluate only one of them !

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

35. 34 (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

36. 35 Summary Computer science formalizes the computational process Programming languages are a way to describe this process Syntax Sematics Scheme is a programming language whose syntax is structured around compound expressions We model the semantics of the scheme via the substitution model, the mathematical equivalent of lambda calculus