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