exam01 topics

exam01 will be 2023-oct-12 (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 and the nonsense-example glarps-and-blahs

• 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)

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

• 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.)
• Trade-offs of mutable vs. immutable data
• scope and shadowing
• tail recursion
• Higher order functions, including how to write a function which returns a (newly-created) function.
• grammars

Sample problem

An additional practice-problem for recursive data-type definitions can be found as problem #2 here. The solution will be posted on D2L, but not until Sunday mid-afternoon. I highly recommend working through the problem (even more than the sample-exam).

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, 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 assume a standard/boilerplate constructor, toString, equals, and hashCode have been written (as if using records, or perhaps automatically by your IDE).
• For any question, you may use functions defined in previous questions, even if you didn't complete the previous question.