To directly assess your mastery of the learning objectives of this course, we will conduct a series of learning assessments, both individually and in sets (SoLAs), over the course of the semester. The use LAs of this course is inspired by mastery-based testing practices found in mathematics.
SoLAs consist of a set of individual assessment problems—one problem for each learning objective of the course covered so far.
Most of the LAs will also appear as in-class paper-based ten-minute quizzes, given at the start of class on various days.
All of the LAs in a phase (except those marked as in-class-only) will be released as a SoLA on gradescope. Do not discuss the problems on the SoLA with anyone until I have returned graded problems.
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 (S)/not satisfactory (N). 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!
The objectives may change slightly during the semester as the schedule shifts.
Learning Assessments, Object-Oriented Programming
Data abstraction: Apply abject-oriented design principles to separate interface from implementation.
Encapsulation: Apply object-oriented design principles to design and build classes.
Subtype polymorphism: Write polymorphic code that works for objects in all classes that implement an interface or subclass another class.
Parametric polymorphism: Write polymorphic code for structures that can work with a variety of uniformly typed objects, such as lists of X.
Composition: Combine objects/classes to build new objects/classes, implementing the has-a relationship.
Inheritance: Build new objects/classes in terms of other objects/classes, impliementing the is-a relationship.
Mental Models of Java Objects: Describe the layout of objects in memory.
Learning Assessments, Software Design
Project design: Create correct multi-file programs in Java to meet specifications.
Collaboration: Work with one or more other students on the creation of a program.
Testing: Write effective unit tests using a framework such as JUnit and practice test-driven development.
Version control: Employ collaborative version-control software, such as Git, to maintain multiple versions of software under development.
Documentation: Exercise good practices in documenting code and create documentation for Java programs using Javadoc.**
Professional ethics: Understand and explain the responsibilties of a software designer.
Learning Assessments, Data Types and Data Structures
Array-based structures: Implement one or more data types using arrays.
Linked structures: Implement one or more data types using linked structures.
Iterators: Design, implement, and use iterators for one or more data types.
Lists: Implement and use array-based and linked lists.
Stacks and queues: Implement stacks or queues; use both.
Dictionaries/maps: Design a dictionary ADT and implement it in multiple ways, such as with associative arrays, binary search trees, or hash tables.
Hash tables: Implement dictionaries with hash tables using either probing or chaining.
Binary search trees: Implement dictionaries with binary search trees.
Heaps: Describe heaps and how they are built. Optionally use heaps for Heapsort.
Graphs: Describe graphs and basic algorithms on them.
Learning Assessments, Algorithms
Big-O notation: Read and interpret the formal definition of Big-O.
**Analysis of iterative algorithms: Conduct informal big-O analysis of iterative algorithms and nested loops.
**Analysis of recursive algorithms: Conduct informal big-O analysis of recursive algorithms.
Merge sort: Explain, implement, and analyze variants of the merge sort algorithm.
Quicksort: Explain, implement, and analyze the Quicksort algorithm.
Heap sort: Explain, implement, and analyze the heap sort algorithm. (skipped)
Graph and tree traversal: Explain various graph and tree traversal algorithms.
Loop invariants: Describe the use of loop invariants in algorithm design. (skipped)
Programming problems
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.
Written problems
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.
Forthcoming.