1 / 36

Extended Introduction to Computer Science

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

nasia
Download Presentation

Extended Introduction to Computer Science

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Extended Introduction to Computer Science

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

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

  4. Computer Science

  5. Geometry Giha Earth Metra Measure

  6. Declarative Knowledge “What is true”

  7. [Heron of Alexandria] Imperative Knowledge “How to” • 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

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

  9. Scheme “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. Designing Programs • Controlling Complexity • Black Box Abstraction • Conventional Interfaces • Meta-linguistic Abstraction

  11. Expressions Data or procedures Syntax Semantics 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

  12. The Scheme Interpreter • The Read/Evaluate/Print Loop • Read an expression • Compute its value • Print the result • Repeat the above • The Environment Name Value

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

  14. Language Elements Syntax Semantics

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

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

  17. Evaluation of 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 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)

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

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

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

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

  22. 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 • To Evaluate a combination: (other than special form) • Evaluate all of the sub-expressions in any order • Apply the procedure that is the value of the leftmost sub-expression to the arguments (the values of the other sub-expressions) 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

  23. (* 3 3) (* 4 4) + 9 16 25 Using Abstractions ==> (define square (lambda(x)(* x x))) Environment Table ==> (square 3) square Proc (x)(* x x) 9 ==> (+ (square 3) (square 4))

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

  25. 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 • To Evaluate a combination: (other than special form) • Evaluate all of the sub-expressions in any order • Apply the procedure that is the value of the leftmost sub-expression to the arguments (the values of the other sub-expressions) Evaluation of An Expression (reminder)  reduction in lambda calculus The Substitution model 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

  26. Let’s Not Forget The Environment ==> (define x 8) ==> (+ x 1) 9 ==> (define x 5) ==> (+ x 1) The value of (+ x 1) depends on the environment! 6

  27. 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,7 replace by result of operation

  28. 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. Values and types In scheme almost every expression has a value Examples: • The value of 23 is 23 • The value of + is a primitive procedure for addition • The value of (lambda (x) (* x x)) is the compound procedure proc (x) (* x x) Valueshavetypes. For example: • The type of 23is 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)

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

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

  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 !

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

  35. Some examples: (define twice ) (twice 2) ==> 4 (twice 3) ==> 6 (lambda (x) (* 2 x)) Using “syntactic sugar”: (define (twice x) (* 2 x)) (define second ) (second 2 15 3) ==> 15 (second 34 -5 16) ==> -5 (lambda (x y z) y) Using “syntactic sugar”: (define (second x y z) y)

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

More Related