exam01 topics

exam01 will be 2024-oct-17 (Thu) in-class, on-paper, closed-notes.

The following topics may be on the exam:

• Anything on hw01–hw06.
• The design recipe (incl. union types and product(compound) types):
  • built-in types (not much to say here)
  • union-types (incl. the template for it) in racket, but not in Java (yet)
  • structs (a.k.a. compound types or product types) (incl. template)
  • combos: union-of-union, struct-of-struct, and struct-of-unions (defer to helpers appropriately);
  • union-of-structs and its template
  • union-of-structs with a self-reference in the data def'n (add natural-recursive call, to template)
    

    Note: Lists are merely an example of this category, as are natural numbers, trees racket/java, and the nonsense-example glarps-and-blahs

    Note: You will not be required to use java, though it may be allowed for some problems.

• Applying the design recipe: Given a description of what we want to represent, come up with suitable unions/structs as needed, and be able to write functions processing them.
  E.g. be able to work through an example similar to, albeit more sensible than, glarps-and-blahs.
• Standard vocabulary (e.g. parameter vs. argument vs. local variable; expression vs. statement; statically typed vs. dynamic typing vs. untyped; compiled vs. interpreted)
• Scope and shadowing: a binding occurrence vs. a bound occurrence; racket's let and let*.
• programming language paradigms — low-level, procedural, O.O., functional, declarative. (incl. being able to give the primary features of each family/paradigm, and give a notable language associated with that paradigm.)

  Note: If this is on the exam, it won't be heavily emphasized.

You will not need to know for exam01 (but will be on exam02):

• Trade-offs of mutable vs. immutable data
• tail recursion
• Higher order functions, including how to write a function which returns a (newly-created) function.
• grammars

Sample exam

Here is a practice exam (D2L) (incl. solution). Note that it does not necessarily cover all of the above topics (and, it covers grammars and , which will we haven't yet covered).

I suggest you sit and take the practice exam directly, writing down all answers (not just thinking about them in your head), before looking at the solution.

Instructions:

• This exam is 75min, in-class, on-paper.
• Please use any suggested abbreviations (in non-gray), to save writing. In addition, I recommend using short (but mnemonic) field-names (3 letters or so). E.g., “def/c” for “define/contract”, “def-str/c” for “define-struct/c”, “mk-…” for “make-…”, “str<?” for “string<?”, and “nat?” for “natural?”.
• Unless otherwise specified, you may write any exam-code in Java, or in Racket. You may switch languages between problems; just be sure to use the correct field/struct names.
  For each java method, specify which class that method belongs in.
• If using Java, you may use records, or regular classes where you can assume a standard/boilerplate constructor, toString, equals, and hashCode have been written.
• For any question, you may use functions defined in previous questions, even if you didn't complete the previous question.