Please read pages 17--26 in *Programming Languages: Build, Prove, and Compare*.

1.  What is the value of the following Impcore expression?

        (if (> 3 5) 17 99)

2.  Which of the following best describes the syntactic structure of
    Impcore?

    (a)   An expression can be made with any definition as one of its parts
    (b)   A definition can be made with any expression as one of its parts
    (c)   Both of the above
    (d)   None of the above

3.  Does the following Impcore test pass? Please answer "yes" or "no."

        (check-expect (+ 1 2 3) 6)

    Assuming `x` is bound to a global variable, does the following
    Impcore test pass? Again, please answer "yes" or "no."

        (check-expect (set x 1) 1)

Next read section 1.3, which starts on page 27, about abstract syntax.

4.  After reading about abstract syntax, look at this picture of an
    abstract-syntax tree for a "calculator expression":

    ![Picture of an abstract-syntax tree](ast.jpg) 

    Answer these questions:

    (a) What concrete syntax could you write in C for this expression?
    (b) What concrete syntax could you write in Impcore for this expression?

In *Seven Lessons in Program Design*, at
<https://www.cs.tufts.edu/comp/105/design/lessons.pdf>, read the
Introduction and Lesson 1.

5.  I show you a recursive function `f` that takes one argument, 
    a natural number `n`.  The structure of `n`, and therefore the
    internal structure of `f`, are based on the Peano proof system from
    the handout.

    (a) What are the different ways `n` can be formed?
    (b) When `f` is given `n`, what code do you expect `f` to use to
        determine how `n` was formed?
    (c) For which values of `n` do you expect `f` to make a recursive call?
    (d) When a recursive call is made, what value is passed as argument?


Read the expectations about contracts in the [*course coding
guidelines*](../coding-style.html#contracts).

6.  In *Seven Lessons in Program Design*, just before the end of
    Lesson 1, you will find a section on "Complete process examples."
    This section suggests that the `factorial` function---but not the
    `power` function---could be submitted without a contract.
    
    (a) Why would it be OK to submit the `factorial` function without
        a contract?  For an idea, look at the "Exemplary" column in
        the "Documentation" section of the general coding rubric.
    (b) Why doesn't the same argument apply to the `power` function?
        For an idea, check the design lesson.