2 Skills
Skills are meant to be small statements that are simple to assess (5-15min). The skills for this class are the following:
2.1 Intro + Functional programming (4 skills)
F1: Designing simple functions (new: with the design recipe) [Required for D]
"I can apply the design recipe to solve a given problem using a recursive function."
F2: Working with functions as arguments [Required for D]
"I can use functions as arguments or results and predict the behavior of a small higher-order program."
F3: Step through a function’s execution [Required for D]
"I can trace a short Plait program that uses function application, local bindings, conditionals, and datatype case analysis."
F4: Translate surface syntax into an AST [Required for D]
"I can translate between surface syntax and a Plait AST, including nested applications and lambda terms, given a grammar and AST definition."
2.2 Runtime semantics (10 skills)
R1: Understanding surface syntax of LetLang/Lam (intuition)
"I can identify binders, their scopes, free variable occurrences in supplied let expressions and lambda terms."
R2: Understand variable shadowing and substitution (intuition)
"I can perform substitution in a supplied expression, respecting shadowing to prevent variable capture."
R3: Classify expressions as values, reducible, or stuck (intuition)
"I can classify a supplied term as a value, a reducible expression, or a stuck term, justifying my classification using the given evaluation rules and definition of values."
R4: Identify the next expression to reduce in call-by-value semantics (intuition)
"I can identify the next subexpression to evaluate using supplied call-by-value evaluation rules and a definition of values."
R5: Trace the lambda calculus using small-step semantics (intuition)
"I can construct an evaluation trace for a supplied expression using the given lambda-calculus runtime semantics."
R6: Construct a single-step derivation tree (applying)
"I can small-step a program using a derivation tree (as opposed to a trace) given the evaluation rules for IfLang/LetLang/Lam."
R7: Construct a multi-step derivation tree (applying)
"I can construct a derivation tree justifying a multi-step evaluation using the supplied rules for individual steps and their composition."
R8: Implement a small-step interpreter (applying) [R8 or R9 is required for a B]
"I can implement an interpreter for IfLang/LetLang/Lam given supplied small-step semantic rules."
R9: Implement a multi-step or big-step interpreter (applying) [R8 or R9 is required for a B]
"I can implement an interpreter for IfLang/LetLang/Lam given supplied big-step semantic rules."
R10: Identify and explain stuck programs (understanding)
"I can construct a syntactically valid term that becomes stuck under supplied evaluation rules, showing its evaluation trace and explaining why no rule applies to the resulting non-value term."
2.3 Type systems and logic (5 skills)
T1: Interpret typing judgments (intuition)
"I can interpret a supplied typing judgment as code (in the new code typing judgments), and identify its context, expression, and type without complicated types with runtime values."
T2: Type-check simple STLC expressions (intuition)
"I can type-check simple expressions in STLC (or infer what their type should be) by looking up a variable’s types and extending a supplied typing context, correctly handling shadowing and explaining what its entries represent."
T3: Construct typing derivations (applying)
"I can construct a complete typing derivation for a well-typed expression (like LetLang or the STLC) using the supplied typing rules."
T4: Implement a type-checker in Plait (implementing) [Required for B]
"I can implement a type-checker from a given set of typing rules."
T5: Construct counterexamples for typing and execution (understanding)
"Given rules for a type system, I can construct an expression in valid syntax that runs (and may return a runtime error), but doesn’t type-check. If possible, I can also identify expressions that type-check, but will crash."
2.4 Grade expectations
D: You can do the foundations.
C: D + 6 skills (speedrun: "runtime intuition and one application").
B: D + 11 skills (speedrun: "all intuition" and "1 apply + 1 implement" for runtime and types).
Required: implement an interpreter (R8) and type-checker (T4).
A: You have passed 19 skills (all listed here).
To get a C or above, you must also complete a presentation. Grades from your presentation are minimums.
2.4.1 Partial Credit
+: Evidence of a skill means showing you can pass a skill assessment twice. Partial credit means you have passed a skill once, for half of all remaining skills.
++: In addition to this, you will get another grade bump if you complete the revised midterm as a homework assignment.
Examples: Partial credit
Example 1:
You have passed the C threshold (11/19 skills) and have passed four more skills assessments.
You now have a C+.
Example 2:
You have passed the B threshold (16/19 skills) and have passed two more skills assessments.
You now have a B+.
Examples: Partial credit + revised midterm
Example 1:
You have a C+ (11/19 skills + 4 assessments) and complete a midterm revision:
C+ → B-
Example 2:
You have a B+ (16/19 skills + 2 assessments) and complete a midterm revision:
B+ → A-
Example 3:
You have passed the C threshold (11/19 skills) and complete a midterm revision:
C → C+
Example 4:
You have passed the B threshold (16/19 skills) and complete a midterm revision:
B → B+