exam01 topics

exam01 will be 2025-mar-20 (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 should be able to implement union- and struct-types in either racket or Java.

• 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, scripting, 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

An old practice exam (D2L) (incl. solution) is available. Note that it does not necessarily cover all of the above topics (and, it covers grammars, which we haven't yet covered).
I strongly 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-…”, “bool?” for “boolean?”, “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.