To directly assess your mastery of the learning objectives of this course, we will conduct a series of sets of learning assessments (SoLAs) over the course of the semester. Each will contain assessments from one or more Learning Assessment Phases (LAPs). The use LAs of this course is inspired by mastery-based testing practices found in mathematics.
There are four primary SoLAs in the course, along with one optional final SoLA.
SoLAs consist of a set of individual assessment problems—one problem for each learning objective of the course covered so far. The approximate lists of learning objectives by LA period are listed below. You will begin your learning assessments during class time. If you need extra time (e.g., for individual assessments left over from the prior assessment), you will have slightly more than one day to complete the problems. All problems are released online in Gradescope. You may choose to attempt as many of the individual assessment problems as you wish for that period. As described in the syllabus, LA problems are graded on a binary satisfactory/non-satisfactory. Once you receive a satisfactory on a problem tied to a particular learning objective, you do not need to attempt additional problems tied to that learning objective in subsequent SoLAs, i.e., you have demonstrated sufficient mastery of that objective, so you are done with it!
Example: The first SoLA will have seven problems corresponding to seven learning objectives from the first Learning Assessment Phase described below. Suppose that you receive S grades on the first five problems but not the sixth or seventh. The second SoLA will have 14 problems: seven corresponding to the first set of learning objectives and seven corresponding to the seven new learning objectives from Phase 2. You do not have to answer the questions corresponding to the first five learning objectives you have mastered already. Instead, you are free to attempt the additional seven areas new to SoLA 2 as well as the problems corresponding to the sixth and seventh objectives from LAP 1 that you missed previously.
SoLA 5 during finals week is a last-chance assessment period.
No new learning objectives are introduced, but you are free to re-attempt any objectives that you missed in previous LAs.
SoLA 5 will be distributed on Tuesday morning and due Wednesday evening.
I will use class time on SoLA days to answer questions. As the schedule suggests, I will hold a review session during class time on reading day.
The objectives may change slightly during the semester as the schedule shifts.
Learning Assessments, Phase 1 (LAP 1)
Decomposition. Decompose a computational problem into smaller sub-problems amendable to implementation with functions.
Procedural abstraction. Take a concrete implementation in Racket and create a procedure that generalizes that behavior.
Tracing. Trace the execution of a Racket program using a substitutive model of computation.
Primitive types. Express basic computations over primitive values and their associated standard library functions.
Conditionals. Use Boolean expressions and values in a program to produce conditional behavior.
Lists. Manipulate lists with fundamental higher-order list functions
Collaboration. Explain best practices for solving problems in a collaborative setting.
Learning Assessments, Phase 2 (LAP 2)
Program style. Write and structure program code in ways that make it easier to understand.
Local bindings. Refactor redundancy and add clarity in computations with let-bindings.
Documentation. Document programs according to good software engineering principles.
Testing. Test programs according to good software engineering principles.
Regular expressions. Read and write programs that take advantage of regular expressions.
List recursion. Design and write recursive functions over lists.
Numeric recursion. Design and write recursive functions over the natural numbers.
Learning Assessments, Phase 3 (LAP 3)
Randomness. Write programs that produce unpredictable output.
Mental models of memory. Describe or diagram the layout of memory for lists, pairs, and vectors/arrays.
Dictionaries. Design and write functions that use dictionaries.
Vectors. Design and write functions (potentially recursive functions) that use vectors.
Data abstraction. Design data structures to separate interface from implementation.
Higher-order procedures. Use
section and composition to simplify computations.
Precondition testing. Verify the preconditions of procedures.
Learning Assessments, Phase 4 (LAP 4)
Structure textual data. Write and use HTML, XML, and CSS.
Write higher-order procedures. Write procedures that take procedures as parameters and return procedures as results.
Tail recursion. Transform recursive functions into tail-recursive functions.
Tree recursion. Design and write recursive functions over trees.
Running time. Use a mental model of computation to count the relevant number of operations performed by a function.
Searching. Update or modify fundamental searching algorithms or trace the execution of those algorithms over concrete inputs.
Functional vs. imperative approaches. Compare aspects of functional programming (e.g., everything is an expression, parameters are not mutable, procedures can be parameters) with aspects of imperative programming (e.g., mutable structures with sequencing).
For programming problems in learning assessments, we are concerned primarily with correctness rather than design. Make sure that your program works according to the specification outlined in the problem by testing it on a variety of inputs. Pay attempt to the prompt for guidance about what aspects of design you need to include in your program, e.g., documentation or explicit test suites.
For problems with written responses, we are looking for responses that address the prompt directly and concisely. In particular, if a written problems asks you to solve a problem in a certain style or show your work, e.g., the trace of the execution of a program, make sure to include this information in the style presented in class.