1 / 32

David Evans cs.virginia/evans

Lecture 3: Rules of Evaluation. David Evans http://www.cs.virginia.edu/evans. CS200: Computer Science University of Virginia Computer Science. Menu. Language Elements Why don’t we just program computers using English? Evaluation Procedures.

kieran-huff
Download Presentation

David Evans cs.virginia/evans

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. Lecture 3: Rules of Evaluation David Evans http://www.cs.virginia.edu/evans CS200: Computer Science University of Virginia Computer Science

  2. Menu • Language Elements • Why don’t we just program computers using English? • Evaluation • Procedures CS 200 Spring 2004

  3. When learning a foreign language, which elements are hardest to learn? Primitives: lots of them, and hard to learn real meaning Means of Combination Complex, but, all natural languages have similar ones (Chomsky) SOV (45% of all languages) Korean: Sentence ::= Subject Object Verb SVO (42%) English: Sentence ::= SubjectVerbObject VSO (9%): Welsh: Sentence ::= Verb Subject Object “Lladdodd y ddraig y dyn.” (Killed the dragon the man.) OSV (<1%): Tobati (New Guinea) Schemish: Expression ::= (VerbObject) Means of Abstraction Few of these, but tricky to learn differences across languages Language Elements CS 200 Spring 2004

  4. CS 200 Spring 2004

  5. CS 200 Spring 2004

  6. CS 200 Spring 2004

  7. Core language issues list has 440 items! CS 200 Spring 2004

  8. CS 200 Spring 2004

  9. Why don’t we just program computers using English? CS 200 Spring 2004

  10. The first bug: Moth found in UNIVAC relay Admiral Hopper’s Notebook, Sept 1945 CS 200 Spring 2004

  11. Why don’t we just program computers using English? • Too hard and complex Non-native English speakers don’t need convincing. The rest of you have spent your whole life learning English (and first 5 years of your life doing little else) and still don’t know useful words like floccipoccinihilipilification! There are thoughts that even native speakers find it hard to express. By the end of today you will know enough Scheme (nearly the entire language) to express and understand every computation. By PS7, you will know enough to completely and precisely describe Scheme in terms of itself (try doing that in English!) CS 200 Spring 2004

  12. Why don’t we just program computers using English? • Not concise enough English: To find the maximum of two numbers, compare them. If the first number is greater than the second number, the maximum is the first number. Otherwise, the maximum is the second number. Scheme: (define (max a b) (if (> a b) a b)) CS 200 Spring 2004

  13. Why don’t we just program computers using English? • Limited means of abstraction There are only a few pronouns: he, she, it, they, these, … (English doesn’t even have a gender-neutral pronoun for a person!) Only Webster and Oxford can make up new ones. defineallows any programmer to make up as many pronouns as she wants, and use them to represent anything. CS 200 Spring 2004

  14. Why don’t we just program computers using English? • Mapping between surface forms and meanings are ambiguous and imprecise The 500 words used most in the English language each have an average of 23 different meanings in the Oxford English Dictionary. http://www.vuse.vanderbilt.edu/~jgray/funny.html I said he thought secret users only may write secret data.(From Only His Only Grammarian Can Only Say Only What Only He Only Means, Peter Neumann) The exact meaning(s) of every Scheme expression is determined by simple, unambiguous rules we will learn today (and refine later in the course). CS 200 Spring 2004

  15. Essential Scheme Expression ::= (Expression1Expression*) Expression ::=(ifExpression1 Expression2 Expression3 ) Expression ::= (definenameExpression) Expression ::=Primitive Primitive ::= number Primitive ::= + | - | * | … Primitive ::= … Grammar is easy, just follow the replacement rules. But what does it all mean? CS 200 Spring 2004

  16. Evaluation

  17. Expressions and Values • (Almost) every expression has a value • Have you seen any expressions that don’t have values? • When an expression with a value is evaluated, its value is produced CS 200 Spring 2004

  18. Evaluation Rule 1: Primitives If the expression is a primitive, it is self-evaluating. > 2 2 > #t #t > + #<primitive:+> CS 200 Spring 2004

  19. Evaluation Rule 2: Names If the expression is a name, it evaluates to the value associated with that name. > (define two 2) > two 2 CS 200 Spring 2004

  20. Evaluation Rule 3: Application • If the expression is an application: • Evaluate all the subexpressions of the combination (in any order) • Apply the value of the first subexpression to the values of all the other subexpressions. (expression0 expression1 expression2 … ) CS 200 Spring 2004

  21. Rules for Application • If the procedure to apply is a primitive, just do it. • If the procedure is a compound procedure, evaluate the body of the procedure with each formal parameter replaced by the corresponding actual argument expression value. CS 200 Spring 2004

  22. Making Procedures • lambda means “make a procedure” Expression ::= (lambda(Parameters)Expression) Parameters ::= Parameters ::= Name Parameters CS 200 Spring 2004

  23. Lambda Example: Tautology Function make a procedure with no parameters with body#t (lambda () #t) > ((lambda () #t) 200) #<procedure>: expects no arguments, given 1: 200 > ((lambda () #t)) #t > ((lambda (x) x) 200) 200 CS 200 Spring 2004

  24. You’ve Already Used Lambda! (define (closer-color? sample color1 color2) Expr) is a shortcut for: (define closer-color? (lambda (sample color1 color2) Expr)) CS 200 Spring 2004

  25. Eval and Apply are defined in terms of each other. Without Eval, there would be no Apply, Without Apply there would be no Eval! Eval Apply CS 200 Spring 2004

  26. All of Scheme • Once you understand Eval and Apply, you can understand all Scheme programs! • Except: • We have special Eval rules for special forms (like if) Evaluation Rule 4: If it is a special form, do something special. CS 200 Spring 2004

  27. Evaluating Special Forms • Eval 4-if. If the expression is (ifExpression0 Expression1 Expression2) evaluate Expression0. If it evaluates to #f, the value of the if expression is the value of Expression2. Otherwise, the value of the if expression is the value of Expression1. • Eval 4-lambda. Lambda expressions self-evaluate. (Do not do anything until it is applied.) CS 200 Spring 2004

  28. More Special Forms • Eval 4-define. If the expression is (defineName Expression) associate the Expression with Name. • Eval 4-begin. If the expression is (beginExpression0 Expression1 …Expressionk) evaluate all the sub-expressions. The value of the begin expression is the value of Expressionk. CS 200 Spring 2004

  29. Scheme Expression ::= Primitive Eval 1: If the expression is a primitive, it is self-evaluating. Expression ::= Name Eval 2: If the expression is a name, it evaluates to the value associated with that name.Expression ::= (ExpressionExpressionList)Eval 3: If the expression is an application:(a) Evaluate all the subexpressions (in any order)(b) Apply the value of the first subexpression to the values of all the other subexpressions. ExpressionList ::= ExpressionList ::=ExpressionExpressionList CS 200 Spring 2004

  30. Special Forms Expression ::= (lambda (Parameters)Expression) Eval 4-lambda. Lambda expressions self-evaluate. Parameters ::= Parameters ::= NameParametersExpression ::= (defineNameExpression)Eval 4-define. If the expression is (defineName Expression) associate the Expression with Name. Expression ::= (ifExpression0 Expression1Expression2) Eval 4-if. Evaluate Expression0. If it evaluates to #f, the value of the if expression is the value of Expression2. Otherwise, the value of the if expression is the value of Expression1. Expression ::= (beginExpressionList Expression) Eval 4-begin. Evaluate all the sub-expressions. The value of the begin expression is the value of Expression. CS 200 Spring 2004

  31. Now, you really know all of Scheme! (Except for 3 more special forms you will learn for PS5.) CS 200 Spring 2004

  32. Charge • Friday: • PS2 Due Monday 2 Feb • Lots more code to write than PS1 • Reading for Friday: SICP, 1.2 • Reading for Monday: GEB, Ch 5 CS 200 Spring 2004

More Related