---- general

Why use (lambda (exp) ...) instead of the shorthand?



---- tests

What do the string arguments mean or do?

How do the (check-exn exn:fail? ...) expressions work?



---- utilities

Why define displayln and list-index if they aren't used?
Will they come into play later?

Why not use builtin index-of instead of implementing list-index?

Why define list-of at all? 
  just write the two lines instead of the function (or one?)
What is the design tradeoff?

Why make list-of higher order?
If curried, why not list-of-length?



---- syntax procs

Why define boom-number and number->value?
  just use Racket numbers
Why use identity?  What does it mean?

Why define *unary-operators* and *binary-operators*?
  just put the lists in the functions

Naming conventions
  Why name those lists with **s?
  Why use the names unary-exp and binary-exp
    and not make-unary-exp and make-binary-exp?
  Is there specific convention for syntax procedure naming?

Why define the "syntactic sugar" functions in syntax-procs?
  just replace (binary-@? exp) with (eq? '@ (binary-exp->operator exp)

Would it be better to handle sugared operators in boom-exp?
    rather than later?
  would make core vs abstraction apparent sooner

Why provide all-defined-out?
  won't this export things like *unary-operators*?
  is there any advantage other brevity?



---- preprocess

Is there an advantage to using 'let' to name the parts?
  just use the accessors directly in the code

Why make the recursive calls in the 'let' values?
  just do it in the body of the let

Will inline code scale for the syntactic expressions?
  (this is the inverse question)

Why does preprocess have an unreachable state?

Why preprocess into Boom syntax when eval-exp turns it into Racket?
  just produce Racket directly
  
Why preprocess at all?
Why have syntactic abstractions at all?
  just evaluate directly
  (an implementer *can*)



---- eval-exp

Why check legality before preprocessing?
  let preprocess find the errors

How does eval-exp deal with division by 0?

Could we name parameters 'boom-exp' when the function expects a valid exp,
  else name them 'exp'?

Could we use 'case' or 'match' instead of 'cond'?

Could we use a data structure to map operators to their behavior?
  (then list-index could be useful)
Is Racket's 'eval' the only other way?

Why does eval-exp have an unreachable state?



---- general

Many small functions versus a few large functions
  Is the former less efficient?
  Can former be excessive and too fragmented to read?

How easy is it to extend the language with new features?
  (this is a part of the decomposition tradeoff)

What syntactic sugar would be best to add next to the language?

Is there a set structure that we should follow when looking
  at a problem of this size?
  (reading or writing?)