Midterm Logistics

• Where? 4 Leconte (http://www.berkeley.edu/map/)

• When? Monday, 4:10 to 5:40• What to do?

– “Review problems” from Thursday/Friday in UCWise.– Two practice exams and solutions are available from

the main CS3 page and through UCWise.– More practice exams available at

http://hkn.eecs.berkeley.edu/cgi-bin/exam-query.cgi?cs3. Be careful though! Some of the older exams test on things we have not gone over in class.

– Open note & open book, but watch the time crunch!

Difference Between Dates• Three versions you should know:

1. Buggy version 1 (general-day-span)2. Correct version 23. Recursive version 3

• Know how each version works, run through various situations (same month, consec month, non-consec month, error cases) in each version and trace the program’s execution– They all obviously have different methods and use different helper

procedures.

• Know how procedures interact with each other– What does a certain procedure expect as input? What would happen if

you didn’t give it the expected input?

• Re-read the reader. Know what the programmer was thinking at each step of the design process. It makes it a lot easier to figure out how something works if you know why it works.

Case Study• Possible types of questions to expect:

– Add on some extra functionality to the original day-span problem

• Example: days-from-beginning-of-year, days-till-end-of-year, number-of-odd-days

• What you should do: Use as many helper procedures as you can to solve the problem. If you’re writing a lot of code, you’re thinking too much about it. A lot of the functionality that you may want to do may already exist in the day-span code. Write code like you’re writing for someone who doesn’t know the program at all.

• Example: Instead of using (first earlier-date) just use (month-name earlier-date), this is clearer to someone who doesn’t know the code at all.

• Be careful! You can use helper procedures from version 1 or 2 of day-span (version 3 if it is allowed, but this is unlikely).

Case Study• Possible types of questions to expect:

– Troubleshoot a bug in day-span

• You may be given a slight change in the day-span code to make it give an incorrect output. You may have to explain why it is now wrong and what the incorrect output is.

– ((equal? month ‘january) 1) turns into ((equal? month ‘january) 2)…what will happen?

• You may be told that you’re now getting incorrect outputs after an unknown code change. You may have to write what changed in the code to make the output wrong (similar to lab).

– Example: (day-span ‘(january 1) ‘(january 1)) is now giving me 2 instead of 1. What change could have happened to the code for this to occur?

• By the way, these are very easy examples, expect something harder.

Case Study

• Let’s look at an old midterm question

Case Study

• Fall 04 #2• So we need to add error checking functionality.

Where would be the most logical place to do this?– We want to make sure we catch the errors before we

do any wrong operations, so we should check before we call day span, right?

– (define (day-span-validated earlier-date later-date) if/cond <error checking here> else <regular execution>

Case Study

• Fall 04 #2• Now we have to think about what errors we

actually need to handle.• What does the example provide us with?

– Impossible date number (January 0, February 30)– Impossible month name (flugalmonth)– Non-number form for date (January Three)

Case Study

• Fall 04 #2• How are we going to handle the error checking?• Our approach: Three cases to consider = three

helper procedures:– valid-month-name?– numeric-date?– valid-day-in-month?

• Make sure that you use as many helper functions as you can when coding it in.

Case Study

• Case in point:• Say we want to check if a given date is valid for

a 30-day month.• Does this code work?

– ((and (member? (first date) ‘(september april june november))

(> (second date) 30)) #f)– Yeah…but, we didn’t use helper functions.

– ((and (member? (month-name date) ‘(september april june november))

(> (date-in-month date) 30)) #f)– Could we do better?

Case Study

• Case in point:• Say we want to check if a given date is valid for

a 30-day month.• Does this code work?

– ((and (member? (month-name date) ‘(september april june november))

(> (date-in-month date) 30)) #f)– Could we do better?

– ((> (date-in-month date) (days-in-month (month-name date))) #f)

Accessors

• You have used them, but what are they?

– Accessors are procedures to access specific information from a larger body of information

– e.g. month-name accesses the name of the month from a sentence with ‘(<month name> <date> <year>)

– e.g. in your quiz, (name <celebrity number>) accessed the name of the celebrity from a database of celebrity information “behind-the-scene”

– Accessors mean that you can change the data format without changing everywhere you access the info

Recursion

• Remember the two parts:– A base case.

• Needs to prevent errors. Can’t get bf of empty sent.

– At least one recursive call.• Needs to take the same number of arguments.• Arguments must be getting smaller. (or else what?)

Boolean and Predicates

• The simple definition of a predicate: A function that returns either #t or #f.

• We have a lot of them in scheme, but they’re all useful in certain situations.

Boolean and Predicates

• equal? vs. =• They both take in two arguments and return #t if

they are equal, #f otherwise.• Why do we need two?

– What happens if you do (= ‘a ‘a)?• Error. = only works with numbers. equal? works with

everything (words, sentences, numbers)

– Why don’t we just use equal? for everything then?• Code simplicity, it is easier for someone who doesn’t know

scheme to understand what = does.

Boolean and Predicates

• member?

• Takes two arguments, first is a character or a word, the second is a word or a sentence.

• We check if the character/word is a member of the second argument.

Boolean and Predicates

• Try these out:– (member? ‘a ‘abcd)

• #t– (member? ‘a ‘(abcd))

• #f– (member? ‘a ‘(a b c d))

• #t– (member? ‘ab ‘abcd))

• ERROR, trying to check a word against a word…• would (member? ‘ab ‘ab) work?

– (member? ‘ab ‘(abcd)) • #f

– (member? ‘ab ‘(ab cd)) • #t

Boolean and Predicates

• And then, the obvious ones.• They take in one argument and check if that argument is

of the specified type.– sentence?– word?– number?– procedure?– string?

• What’s that?– Example “abc”

– empty?– even?– odd?

Special Procedures

• if – Know the basic format:

if (predicate, which will return #t or #f) (what we do if predicate is #t)

(what we do if predicate is #f)– What happens if we don’t have code to run for

when the predicate is false?• If the predicate is true:

– We run the “true” code and have no problems.

• If the predicate is false:– We return “okay”, which is usually meaningless

Special Procedures

• cond– Know the format:

(cond ((pred1) (what we run if pred1 is true)) ((pred2) (what we run if pred2 is true)) ((pred3) (what we run if pred3 is true)) …(else (what we run if no preds are true)))

– How many predicates can we have?• As many as we want (memory pending)

– What if don’t fulfill any preds but we don’t write an else?

• We return ‘okay’

Special Forms

• and– How many arguments can it take?

• As many as it wants.– It evaluates arguments from left to right. It stops the moment it

finds a false result and returns #f. If it does not find a false result, it will return a true value (but not necessarily #t).

– For example:What will this return?(and (= 1 1) (= 2 2) (= 2 3) (= 4 4) (= 5 5))

• #f, it will check (= 1 1) and (= 2 2) and see they are true and continue. When it sees (= 2 3), it knows it is false and returns #f.

– Do we check (= 4 4) or (= 5 5)?• No, since we stop evaluating the moment we get a false result.

– What will this return?(and (= 1 1) (= 2 2) (= 3 3) 4)

• 4, because 4 is a true value in scheme (anything not #f is true)

Special Forms• or

– How many arguments can it take?• As many as it wants.

– It evaluates arguments from left to right. It stops the moment it finds a true result and returns a true value (but not necessarily #t). If it does not find a true result, it will return #f.

– For example:What will this return?(or (= 1 1) (= 2 2) (= 2 3) (= 4 4) (= 5 5))

• #t, it will check (= 1 1) and see it is true and return #t.– Do we check (= 2 2) (= 3 3) (= 4 4) or (= 5 5)?

• No, we stop the moment we see a true value.– What will this return?

(or (= 1 2) (= 34 1) #f)• #f, we check everything, but nothing gives us a true value, so we are forced

to return #f– What will this return?

(or (= 1 0) #f (= 2 3) 26)• 26, because we return the first true value we see, which in this case is 26.

Special Forms

• Example question:– Consider this:

(define (strange a b) (if (> a 3) (+ a 1) (* 2 b)))

– What would happen if we tried to invoke the procedure with this expression?(strange (+ 5 6) (/ 7 0)

– Student A says “This will give an error message because you can’t divide seven by zero.”

– Student B says “There is no error because the first argument a has the value 11, which is greater than 3, so strange never uses the value of the second argument b, so it doesn’t matter if it b is an error.”

– Who is right?

Special Forms

• Example question:– A is right; this expression results in an error.

– It's not relevant that IF is a special form. What matters, in this problem, is that STRANGE is *not* a special form, so when you invoke it, Scheme follows its usual rule: First it evaluates all the subexpressions, then it invokes the procedure. So Scheme tries to compute (/ 7 0) before it ever has a chance to notice that the body of STRANGE includes a call to IF.

– B would be right if the question asked about a direct invocation of IF, such as (if (> 11 3) (+ 11 1) (* 2 (/ 7 0))). But that's not how Scheme works.

Special Forms

• not– How many arguments can it take?

• Just one.

– It evaluates the given argument. If the argument is a true value, not will return #f. If the argument is #f, not will return #t.

– Pretty simple:(not #t) = #f (not #f) = #t

– (not 5)?• #f

Writing Predicates

• Now we have all the elements we need for actually making the computer think and make decisions.

• Be prepared to code something using only if and cond and then again using only and and or.

Writing Predicates

• Example question:

• Write this without using if, cond, and, or and not:

• (define (even-sum-a? x y)

(even? (+ x y)))

• The sum of two odd numbers or two even numbers is even.

Writing Predicates

• Example question:

• Write this without using if, cond, or any math functions (like +, -, /).

• (define (even-sum-b? x y)(or (and (odd? x) (odd? y))

(and (even? x) (even? y))))

• Can you do it better?(equal? (even? x) (even? y)))

Writing Predicates

• Example question:

• Write this without using and, or, not, cond, or any math functions (that leaves if).

• (define (even-sum-c? x y)(if (even? x)

(even? y)

(odd? y) ) )

Writing Predicates

• Example question:

• Write this without using and, or, not, if, or any math functions (that leaves cond).

• (define (even-sum-d? x y)(cond ((even? x) (even? y))

(else (odd? y)))

Quotes and Parens

• We use quotes to pass characters, words, or sentences in a procedure: (explode ‘hello)

• We use parens when we want to call our procedures: (word part1 part2 part3)

• And, we also use parens to help represent a sentence...

– But, we also need a quote at the beginning.

– ‘(this is my sentence)

Quotes and Parens

• What will (square 5) return?– 25

• What will ‘(square 5) return?– (square 5)

• It seems simple now, but it can get easily complicated when you’re doing this in procedures.

• Which code is correct?– (month-name earlier-date)– (month-name ‘earlier-date)

• The first one, since it actually passes us the variable represented by earlier-date…the second one will pass the word “earlier-date” to month-name, and obviously “earlier-date” is not the name of a month.

Quickies(word? 25) #t

(first (bf ''#t)) (first (bf (quote #t)))

(first (first (bf ''#t))) ERROR

(member? 'abc 'xabcyz) ERROR

(and 1 (= (+ 3 2) 5) 5) 5

(or 4 (/ 5 0)) 4

(se (bf (se (first (se '(abc) 'def '(ghi))) (word) (word 'xy (word)))) (bl '(rsi))) (“” xy)

Some More Quickies (to try yourself)

• (first (butfirst ‘(cs3) ) )• (or 4 (/ 4 0) ‘so-true ‘super-true)• (and + ‘+ 5 (= 3 4) )• (and < ‘false (or #t) )• (word)• (sentence)• (sentence “”)• (sentence ‘butfirst ‘of ‘abc ‘is (butfirst abc) ) )• (if (and) (or) (and) )• (count (day-span ‘(january 0) ‘(january 0) ) )• (+ 1 (first (quotient (word 3 4) 3) ) )• (starts-with-prefix? ‘(X I V) )