Learning Objectives and Learning Assessments

To directly assess your mastery of the learning objectives of this course, we will conduct a series of learning assessments over the course of the semester. The use LAs of this course is inspired by mastery-based testing practices found in mathematics.

Most of the LAs will also appear as in-class paper-based ten-minute quizzes, given in class on various days.

Each LA will correspond to one of the learning objectives described below.

If you do not complete the learning assessment for a learning objective the first time, you will have multiple chances to retry.

The objectives may change slightly during the semester as the schedule shifts.

Object-Oriented Design

I expect that by the end of the semester, you will have mastered the basics of object-oriented design. In particular, I expect that you will be able to

• describe and use four pillars of object-oriented design:
  • encapsulation (OOP LO #01: Encapsulation),
  • inheritance, representing a form of the is-a relationship (OOP LO #02: Inheritance),
  • composition, representation a form of the has-a relationship (OOP LO #03: Composition), and
  • polymorphism, including both
    • parametric polymorphism (OOP LO #04: Parametric Polymorphism) and
    • subtype polymorphism (OOP LO #05: Subtype Polymorphism);
• apply object-oriented design principles to separate interface from implentation (OOP LO #06: Data Abstraction)
• identify and use a variety of basic design patterns (OOP LO: 07: Design Patterns), such as Model-View-Controller, Factory, Singleton, Adapter, and Decorator;
• identify objects and classes that will contribute to a program or solution, design those objects and classes, and implement those objects and classes (OOP LO #08: Object Design); and
• describe a common layout of objects in memory (OOP LO #09: Mental Models).

Design and Analysis of Algorithms

I expect that by the end of the semester, you will have significantly extended your skills in the design, implementation, and analysis of algorithms. In particular, I expect that you will be able to

• describe and implement classic algorithms, including
  • binary search (Algorithms LO #01: Binary Search),
  • sequential search (Algorithms LO #02: Sequential Search),
  • insertion sort (Algorithms LO #03: Insertion Sort),
  • selection sort (Algorithms LO #04: Selection Sort),
  • heap sort (Algorithms LO #05: Heap Sort),
  • Quicksort (Algorithms LO #06: Quicksort),
  • merge sort (Algorithms LO #07: Merge Sort),
  • graph and tree traversal (Algorithms LO #08: Traversal), and
  • shortest path (Algorithms LO #09: Shortest path);
• design new algorithms using a variety of approaches including
  • greed (Algorithms LO #10: Greed) and
  • divide and conquer (Algorithms LO #11: Divide and Conquer);
• read and interpret the formal definition of Big-O (Algorithms LO #12: Big-O Notation);
• informally analyze the running time of iterative algorithms and the number of steps in complex nested loops (Algorithms LO #13: Analysis of Iterative Algorithms);
• informally analyze the running time of recursive algorithms (Algorithms LO #14: Analysis of Recursive Algorithms);
• describe or use loop invariants to better design and verify iterative algorithms (Algorithms LO #15: Loop Invariants).

Design and Analysis of Abstract Data Types and Data Structures

I expect that by the end of the semester, you will have significantly extended your skills in the design, implementation, and analysis of abstract data types and algorithms. In particular, I expect that you will be able to

• describe and implement classic ADTs and data structures, including
  • lists (ADT/DS LO #01: Lists),
  • stacks (ADT/DS LO #02: Stacks),
  • queues (ADT/DS LO #03: Queues),
  • priority queues (ADT/DS LO #04: Priority Queues),
  • dictionaries/maps (ADT/DS LO #05: Dictionaries),
  • hash tables (ADT/DS LO #06: Hash Tables),
  • binary search trees (ADT/DS LO #07: BSTs),
  • heaps (ADT/DS LO #08: Heaps), and
  • graphs (ADT/DS LO #09: Graphs);
• implement one or more data types using arrays (ADT/DS LO #10: Array-based Structures);
• implement one or more data types using linked structures (ADT/DS LO #11: Linked Structures);
• design new ADTs using the PUM (philosophy, uses, methods) approach (ADT/DS LO #12: Design ADTs);
• design new data structures using the LIA (layout, implement, analyze) approach (ADT/DS LO #13: Design Data Structures); and
• design, implement, and use iterators for one or more compound data types (ADT/DS LO #14: Iterators).

Software Design and Development

I expect that by the end of the semester, you will be a competent beginning software developer. In particular, in addition to having the skills described above, I expect that you will be able to

• work with one or more other students on the creation of a program (Development LO #02: Collaboration);
• manage development of multi-file programs in Java using a build tool (in our case, Maven) (Development LO #02: Build Tools);
• design, implement, and run unit tests (Development LO #03: Unit Testing);
• develop software using an integrated development environment (in our case, Visual Studio Code) (Development LO #04: IDE);
• collaborate on and keep track of the development history of code using a version control system* (in our case, Git) (Development LO #05: Version Control);
• read, understand, and modify code that you did not write (Development LO #06: Code Reading);
• exercise good practices in documenting code and create Javadoc documentation for Java programs (Development LO #07: Documentation);
• design and develop libraries for use in other programs (Development LO #08: Build Libraries);
• use libraries in your own programs (Development LO #09: Use Libraries);
• signal and recover from errors using exceptions (Development LO #10: Exceptions);
• responsibly incorporate code that you did not write into your own program (Development LO #11: Ethical Reuse); and
• understand and explain the responsibilities of a software designer (Development LO #12: Professional Ethics).