The schedule below shows the tentative dates for all class topics, readings, and major assignments (MPs and SoLAs). You should complete all assigned readings by 10 p.m. on the night before the class in which they are listed. You should complete all lab writeups before the next class session. You can find the full list of due dates on Gradescope.

Due dates for major assignments will not change. However, the particular topics we cover each day may change as we discover that we need more (or less) time on each topic.

If the title of a class session is blue, you should be able to click on it to view the eboard for that class session.

If you view this page with JavaScript enabled you can jump to the current week on the schedule, and you should see the next day of class highlighted in the schedule below.

Week 1 : Getting started with Java
Jan 22
class 1

Getting started

We begin the course by exploring some key ideas.

Topics: Course goals. Course structure. Academic honesty. ADTs and data structures. Designing a stack ADT (an exercise). A bit about OOP.

Jan 24
class 2

Designing expandable arrays

We practice ADT and data structure design.

Topics: Philosophy. Methods. Layout. Implementation. Analysis.

Jan 26
class 3

Programming in the small with Java

We consider some basic issues of Java programming.

Topics: From C to Java. The structure of a Java program. Compiling and running Java programs. Strings in Java. Numeric types in Java. Arrays in Java. Basic output in Java. Basic input in Java.

Week 2 : More fun with Java
Jan 29
class 4

Getting started with Java development

We consider tools for developing programs in Java, particularly the Microsoft VSCode integrated development environment (IDE) and the Git version control system.

Topics: IDEs. VSCode basics. Version control. Git basics.

Jan 31
class 5

Objects and classes

We consider Java’s approach to objects, the primary building block of object-oriented programming. We also explore Java’s classes and how one might model them.

Topics: Object basics. Modeling objects with classes.

Feb 2
class 6

Objects and classes continued

We continue to explore Java’s approach to classes and objects.

Topics: Practice building objects..

  • No reading
  • MP 2 Pre-reflection
Week 3 : Polymorphism
Feb 5
class 7

Object semantics

We consider some underlying issues in the design and implementation of objects in Java. We explore some ways to represent objects visually.

Topics: References. The stack and the heap. Representing objects.

Feb 7
class 8

Unit testing and debugging

We return to concepts of unit testing and habits of debugging that you first learned in CSC 151. We also introduce the concept of test-driven development, common among agile developers.

Topics: A few thoughts on testing. An example. Test-driven development. Why use debuggers. Debugging vs. print statements. Debugging in VSCode.

Feb 9
class 9

Interfaces and subtype polymorphism

We consider interfaces, which serve as specifications of expected behavior for classes. We also explore how interfaces support one form of polymorphism, a key aspect of object-oriented programming.

Topics: Interfaces. The building blocks of OOP. Subtype polymorphism.

Week 4 : Other object concepts
Feb 12
class 10

Pause for breath

We pause to consider various issues that have come up in the class.

  • No reading
  • No lab

Feb 14
class 11

Generics and parametric polymorphism

We continue our explortation of polymorphism by considering a second type of polymorphism, parametric polymorphism, and its realization in Java’s generics.

Topics: Subtype polymorphism, revisited. Parametric polymorphism. Java generics. Generic classes. Generic interfaces. Generic methods. Generics and arrays.

Feb 16
class 12

Exceptional programming

We introduce exceptions and consider their use.

Topics: Exceptions. Object-oriented design.

Week 5 : Design patterns
Feb 19
class 13


We consider inheritance, the third core aspect of object-oriented design.

Topics: Inheritance basics. Inheritance and polymorphism. Compile time vs. run time.

Feb 21
class 14

List ADTs

We consider lists and ways to think about them. We practice ADT design.

Topics: The design of ADTs, revisited. Scheme lists. Java lists.

  • No reading
  • No lab

Feb 23
class 15

Linear structures

We consider linear structures, such as queues and stacks. We explore ways in which arrays and simple linked objects can be used to implement linear structures.

Topics: Linear structures. Stacks. Queues. Priority queues. Other linear structures. Implementing linear structures with arrays. Implementing linear structures as linked structures.

Week 6 : Analyzing algorithms
Feb 26
class 16

Array-based linear structures

We explore ways in which arrays can be used to implement linear structures.

Topics: Detour: Wrappers. Implementing linear structures with arrays. Array-based queues. Priority queues and their implementation.

Feb 28
class 17


We consider iterators, a standard mechanism for accessing the elements of a collection. We explore the use of Java’s anonymous inner classes to build iterators.

Topics: Iterators. Iterating array-based structures. Iterating linked linear structures. Named iterators. Anonymous inner classes.

Mar 1
class 18

Analyzing algorithms

We consider ways to analyze the resource use of algorithms, including formal notation for describing that use.

Topics: Comparing algorithms. Empirical analysis. Asymptotic analysis. Counting steps. Big-O, formalized. Implications of Big-O.

  • No reading
  • No lab
  • MP 4 Post-reflection
  • MP 5 Pre-reflection
Week 7 : Miscellaneous
Mar 4
class 19

Analyzing algorithms, continued

We continue our exploration of the analysis of algorithms.

Topics: Practice with Big-O. Comparing Big-O and empirical approaches.

  • No reading
  • No lab

Mar 6
class 20

Analyzing recursive algorithms

We consider techniques for analyzing recursive algorithms.

Topics: Iterative analysis, revisited. Recurrence relations. Approaches to recurrence relations.

  • CLRS 3 (Characterizing Running Times)
  • CLRS 4 (intro)
  • CLRS 4.3 – I-4.5 (Methods for solving recurrences)
  • No lab

Mar 8
class 21

Anonymous functions

We consider Java’s support for anonymous functions.

Topics: Anonymous functions reviewed. Anonymous functions in Java. Functional interfaces. Priority queues, revisited. Sorted lists.

Week 8 : Sorting
Mar 11
class 22


We consider the problem of searching a collection and techniques for searching various kinds of collections. We also consider loop invariants, a technique for helping ensure the correctness of programs.

Topics: Modeling the problem of searching. Sequential search. Predicates. Binary search. Comparators. Testing binary search. Reasoning about iterative algorithms. The state of a program. Loop invariants.

Mar 13
class 23

Merge sort

We consider the classic merge sort algorithm.

Topics: Lower bounds on sorting. Divide-and-conquer algorithms. An introduction to merge sort. Analyzing merge sort.

Mar 15
class 24


We return to the problem of sorting a list or array.

Topics: The problem of sorting. Testing sorting algorithms. Insertion sort. Selection sort. Generic sorts.

  • No lab
Spring Break
Week 9 : Lists, revisited
Apr 1
class 25


We consider the classic Quicksort algorithm.

Topics: A quick introduction to Quicksort. Partitioning. Partitioning with invariants. Key ideas from Quicksort.

  • MP 6 Pre-reflection

Apr 3
class 26

List Iterators

We return to list ADTs, this time conceiving of lists only in terms of the iterators we build for them.

Topics: A simple list interface. The java.util.List interface. The java.util.ListIterator interace.

Apr 5
class 27

Doubly-linked lists

We explore more sophisticated versions of the linked-list data structure

Topics: Linked lists, reviewed. Doubly-linked lists. Circularly-linked lists. Other list issues.

Week 10 : Miscellaneous
Apr 8
class 28

Array-based lists

We return to the list ADT and explore how to implement lists using arrays.

  • No reading

Apr 10
class 29

Sorting competition

We compare the sorting algorithms from the latest homework.

Apr 12
class 30

Ethical considerations

We consider our responsibilities as programming professionals.

Topics: Professional ethics..

  • No lab
  • MP 7 Post-reflection
  • MP 8 Pre-reflection
Week 11 : Binary search trees
Apr 15
class 31

A Dictionary ADT

We introduce the Dictionary (a.k.a. Map) abstract data type and some simple implementations.

Topics: Maps and dictionaries. Designing a Dictionary ADT. Associative arrays. Association lists.

  • No reading
  • No lab

Apr 17
class 32

Trees and tree traversal

We introduce the tree structure and mechanisms for iterating trees.

Topics: Representing hierarchical information. Tree terminology. Depth-first and breadth-first traversal. Recursive depth-first traversal. Iterative breadth-first traversal. Iterative depth-first traversal. Pre-order, in-order, and post-order traversals.

Apr 19
class 33

Binary search trees

We consider binary search trees, one of the standard implementations of the Map abstract data type.

Topics: The structure of binary search trees. Organizing binary search trees. Adding elements to BSTs.

  • No reading
  • MP 8 Post-reflection
  • MP 9 Pre-reflection
Week 12 : Hash tables
Apr 22
class 34

Hash tables

We consider hash tables, one of the most efficient implementations of the Map abstract data type. We also explore the issue of hash functions.

Topics: Integer maps. From objects to integers. Handling collisions. Rebuilding hash tables. Hash functions.

  • No lab

Apr 24
class 35

Probing in hash tables

We explore one of the two primary collision-resolution mechansims in hash tables.

Topics: Collisions. Linear probing. Quadratic probing.

Apr 26
class 36

Chaining in hash tables

We explore the second of two primary collision-resolution mechanisms in hash tables.

Topics: Buckets and chaining.

  • No reading
  • MP 9 Post-reflection
  • MP 10 Pre-reflection
Week 13 : Graphs
Apr 29
class 37

Priority queues, heaps, and heap sort

We return to the subject of priority queues and consider heaps, one of the more efficient ways to represent priority queues.

Topics: Priority queues, revisited. The heap structure. Adding elements to heaps. Removing elements from heaps. Storing trees in arrays.

  • No lab

May 1
class 38


We pause to continue our exploration of heaps, to discuss LAs, and more.

  • No reading
  • No lab

May 3
class 39

A graph ADT

We consider a graph abstract data type and some common implementations of graphs.

Topics: Modeling problems with graphs. Graph terminology. Weighted graphs. Directed graphs. Implementing graphs with adjacency matrices. Implementing graphs with adjacency lists. Implementing graphs with edge tables.

  • No lab
Week 14 : Wrapup
May 6
class 40

Traversing graphs

We consider the problem of visiting all the nodes in a graph, expanding the approaches we used for trees.

Topics: Review of tree traversal. Breadth-first traversal. Depth-first traversal. The shortest-path problem. Dijkstra’s algorithm.

May 8
class 41

Minimum spanning trees

We consider how to build minimum spanning trees in graphs

Topics: Minimum spanning trees. Strategies for building minimum spanning trees. Kruskal’s algorithm. Prim’s algorithm. Greed as an approach to algorithm design.

May 10
class 42


We conclude the course.

Topics: The subject matter(s) of the course. Debrief. Course evaluation.

  • No reading
  • No lab
Finals Week