Teaching Statement

I love computer science. I love the expressive elegance of computing languages, I love the many, sometimes surprising, connections to mathematics, I love the wizardry in controlling the behavior of a machine, I love that the field of computer science changes quickly and continuously, and I love that computing applications can be used to improve the world.
I love it all, and so of course, I want students to love it, too.

I have taught data structures and algorithms courses for many years. I feel very fortunate to teach this particular material—to oversee students’ intellectual growth at exactly the point they begin to broaden their view of programming into a topic for deep and analytical contemplation, as a tool for technical communication, and as an instrument for mathematical expression. My teaching, via course materials and direct instruction, is intended to illustrate clarity, challenge, and fun—the things students value as they learn.

Underlying my contributions to all student interactions is an unflagging belief in constructivism—student understanding is most effectively achieved if they build it themselves (Piaget, Papert). As enrollments have grown, I have become more deliberate about the techniques I use to nurture discovery. These strategies lie at the heart of all course content design, from classroom activities, to programming assignments, to summative assessments.

1. Contextual inference—We elicit relevant, foundational principles via Socratic dialogue, and then we pose learning goals as puzzles whose solutions depend on that context. Students employ iterative problem solving protocols (a la Polya) to support their exploration. For example, if students have already mastered the breadth first traversal of a graph, and if they have also already studied priority queues, then we can ask them to design an algorithm that finds the shortest path between pairs of vertices in a weighted graph. In solving the problem, they design Dijkstra’s Shortest Path algorithm.

2. Metaphor—Models of computation and algorithm execution have close parallels in the physical and social domains that are familiar to students. We exploit the similarities with consistent and deliberate spatial representations of memory, by modeling algorithm execution kinesthetically and temporally, and by connecting structures and algorithms to the world of the students. For example, in one classroom exercise, I show an example of the worlds largest human pyramid, and I ask students which data structure it most nearly resembles, and why. This approach is suggested by the work of G. Lakoff and M. Johnson in “Metaphors we live by,” 1980.

3. Story-telling—The learning goals of my courses include mathematical analysis and justification. Before embarking on rigorous evaluation of a structure or algorithm, I ask students how they feel about it. This conversation builds a narrative around the quality of their designs that they later mold into a formal proof. The intent of the story approach is to build reflection into the design process, and it is a standard part of most classroom exercises. We also include this reflective process in summative assessment with questions like, “Suppose your best friend boasts that they have implemented a sorting algorithm that runs in time $\Omega(n)$. What is your response? a) That’s impossible. The claim holds for no sorting algorithm, b) That’s boring. The claim holds for all sorting algorithms, c) That’s interesting. The claim holds for some, but not others.” The goal of the story-telling is to evoke an emotional and empathetic response to the content. Cognitive psychologists, David Ausubel and Donald Norman, showed that such a connection with the information improves recall, over rote learning.

My typical course organization is simple and traditional, with a balance of autograded programming projects, written homeworks, collaborative lab assignments, and frequent low-stakes exams.

CPSC221: Basic Data Structures and Algorithms

This course teaches a variety of mechanisms for storing collections of data in support of computation, and discusses the advantages and disadvantages associated with the different methods. It also serves as students’ first glimpse at algorithms that lie at the heart of Computer Science. Students learn how to implement various data-storage structures and algorithms, and they learn how to evaluate their design choices. The combined arts of design, analysis, and justification are the substance of the class. While the course uses C++ for all implementation, the learning outcomes are language agnostic.

Since coming to UBC I have taught 9 sections over 3 years. Sections average 150 students.

Course Learning Outcomes:

I redesigned the course learning outcomes in Summer, 2019. They have since been refined by Will Evans and Alice Campbell.

1. Define and articulate the functionality of classic data structures such as Stacks, Queues, Dictionaries, Priority Queues, etc. by their Abstract Data Type (ADT).
2. Design algorithms and structures to implement novel ADTs based on properties of the data and intended use of the data.
3. Implement classic and novel data structures in modern C++, including arrays, linked lists, AVL trees, hash tables, etc.
4. Analyze the efficiency (time and space) of algorithms and data structures using asymptotic notation.
5. Justify algorithmic choices using iterative and recursive proofs of correctness.
6. Evaluate asymptotic time and space tradeoffs between implementation options.
7. Identify the structures and algorithms necessary for solving complex problems.
8. Synthesize and apply algorithmic and analytical design choices to form complete software solutions of classic problems.

Example Course Content

All course content was authored collaboratively with Will Evans and Geoffrey Tien.

Website: CPSC221 Basic Data Structures and Algorithms (Sadly, the course is now locked within the campus LMS.) Typical Syllabus

Assessments (archival–now delivered via PrairieLearn): Exam 1, Exam 2, Final

Programming Assignments (PAs): The design of these assignments is perhaps my favorite contribution to the course. Our department culture demands that assignments not be reused from semester to semester, which means we are responsible for delivering a unique collection of assignments every term. I made this process sustainable by designing programming assignment templates which we just instantiate anew each term. For example, in PA1, an image is partitioned into blocks, the blocks are stored in a linked list, the linked list is manipulated, and finally, the blocks are reassembled into a different resulting image, often with fascinating effect. Each stage of this assignment design lends itself to adaptation: partitions can be columns, rows, squares, or rectangles; the linked list can be singly or doubly linked, with or without sentinels, circular or not, etc.; linked list manipulation can include many varied twists. Our authoring task is simply to write the variation for each part of the template–the problem scope, decomposition, and much of the specification, is constant. Each of the assignments is templatized in this way. PA1, PA2, PA3

Written Homework: These assignments are also somewhat templated, but to a much lesser extent than the programming projects. HW1, HW2, HW3

Innovations

My contributions toward course design for CPSC221 are succintly described as “modernization.” I have pushed for timely updates to many of the course features, a few of which are:

• Reworked and repositioned 10 lab exercises, including test suite and autograder development (with student Lynn Zhang).
• Devised sustainable programming assignment templates that simplify the process of authoring unique assignments each term.
• Built a course autograder using Catch2 (modern, open-source testing framework for C++), originally deployed on Gradescope, and recently migrated to PrairieLearn.
• Developed and executed video media for a C++ minicourse deployed at the start of each term.
• Piloted a “creative component” in a single programming assignment, wherein students devised a novel and artistic flood-fill pattern and submitted it publicly through the course forum.
• Designed algorithm visualizations to support instruction (with student Noa Heyl supported by a UBC Open Education Resources Grant).
• Developed and piloted html5-based interactive annotated lecture slides (since abandoned, based on student feedback).

OnLine Instruction

Our course migration to emergency online instruction occurred over a March weekend in 2019W2. Our basic strategy was to maintain normalcy, and as such, we continued active, sychronous class meetings via livestream video. We reduced student stress by relaxing all deadlines. Together with my co-instructor Andy Roth, I spent a lot of time and creative energy designing a final exam using PrairieLearn. Many of the questions from that exam will be used in perpetuity.

I happened to also teach the summer version of the course, 2020S, to 185 students, and without a co-instructor. I embraced the responsibility of evolving from emergency online instruction to a more deliberate design for remote teaching centered on student engagement. The summer course maintained the content and student deliverables described above. Our adaptations were exclusively in the domain of class meetings, and assessments.

Class meetings in the summer term are scheduled as three, 2.5hr blocks (MWF, 1300-1530). I absolutely could NOT envision livestreaming content delivery for 2.5 hours, no matter how delightful the material! My solution was to start the week with a live 1hr meeting, to follow up with approximately 2hr of post-pre-class video (in ~25min segments) and then to complete the week’s instruction via a 1hr class meeting on Wednesday. Friday’s 2.5 hour class block was broken into two segments: 1) a half-hour meeting of purely joyful content–puzzles, jokes, stories, etc. followed by a one hour break, and then 2) a one hour exam. Lessons and observations:

• Contributions in the chat window during live instruction were from many and diverse students. I deployed lots of interactive gimmicks, including, for example, querying the chat with prompts like, “when i see the correct answer 20 times, we can move on…” or “someone with name starting with R should say the answer…” It was sometimes silly, and always quite fun.
• A lecture TA to monitor the chat, deploy polls, and to provide banter was a critically important feature of our class meetings. We also had a student in the role of class DJ, playing music for the intro and outro of each day.
• Some students prefer watching videos asyncronously, and others prefer the interactivity of live class. I think a 50/50 balance is about right.
• Attendance at class meetings hovered around 70%, which is quite low, but not much lower than in-person, if at all. Viewership of video media was nearly 100%.

We replaced the 2 large midterm exams, together worth 30% of the course score, with 5 shorter, weekly examlets, together worth 50% of the course score. To support student learning, and to familiarize students with the examlet format, we released substantial practice problems at the start of every week. Many of the practice problems allowed for unlimited randomized repetition, so student could use the problems to achieve mastery. The final exam, while still cumulative, was reduced from 30% to 18% of the overall score. Exams themselves were highly and carefully randomized, which we believe disincentivizes inappropriate collaboration. Lessons and observations:

• Small, frequent exams are a fantastic tool for both students and instructors. Student preparation is focussed and efficient, and they have a better view of their incremental progress through the course. Instructors receive more substantial data on student performance, earlier in the term. I will never go back to monolithic exams.
• Over 90% of students took advantage of practice exam opportunities, spending an average of 2.5 hours per week. We gave no credit for practice problem completion.
• Each examlet was approximately 16 familiar problems plus two novel problems that students had not seen within the practice sets. A few of the problems we used had also appeared on the previous semester’s final exam, so we could compare scores across terms. In every case, students from the summer term outscored their spring peers. We hypothesize that the refined exam schedule helped students maintain consistent engagement, which improved their learning.
• Exam problem design is important and should be considered an investment in the basic course content. Nearly all the questions we have developed can be re-used in future terms, because of the high degree of randomness in the design.

Student feedback for the summer instance of the course were among the highest I have received in my career (4.8 overall effectiveness, of 5), and it was not because the course was easy, since the lowest score (3.9, of 5) was attached to “The workload for this course was appropriate.” Select student comments (I have chosen examples that comment on the course organization, rather than me, personally):

The instructor was very comprehensive and competent to deliver the course material. Despite facing the significant challenge of transforming a typically in–class course to a completely online one in a very limited time, they conveyed the course material with utmost clarity and was easily available to address student queries and concerns by having ample online office hours. The lecture delivery style is conducive to learning and the instructor genuinely made efforts to create an inclusive environment. Compared to the other courses I have taken so far (including those that work on reverse class room model such as CPSC 210 etc.), the format of having an exam every Friday compelled me to learn more efficiently and did not allow me to postpone learning and studying. I believe that if in future, online delivery of course work is the way forward, then this is the format that every course should adopt. Moreover, I believe that my grade will more truly represent my dexterity in the course work. In conclusion, I am very satisfied.

Her assessment policy and use of PrairieLearn showed a clear understanding of the difficulties in our situation. Thanks for that!

I really loved Cinda’s teaching style and I enjoyed every lecture (too bad it is all online). Algorithms are hard to understand, but with Cinda’s help I think I swallowed a lot of them. One suggestion for online teaching is that I think it would be better to put more content in lecture as oppose to pre/post–lecture videos. Personally I felt I learned more in real–time lectures.

I think this was a wonderful course! I absolutely loved the material, it was so exciting to learn about the different applications of the material. I think the online format was great for summer. I could catch up when I had the time, instead of going to classes. I think the TA’s hours were abundant and we had plenty of support. I think the course load was a bit heavy. i only took one course this term, but I belive if I had taken 2 instead, it would’ve been too overwhelming.

Showed great interest in what she taught which made the content more fun. I very much enjoyed the shortened lectures and more videos so that I could focus and learn content in short bursts rather than an extended amount of time.

Courses Taught

Since arriving at UBC in 2017 I have taught the following courses:

• CPSC320 Intermediate Algorithm Design and Analysis (2017W1)
• CPSC221 Basic Algorithms and Data Structures (2017W1, 2017W2, 2018W1, 2018W2, 2019S, 2019W1, 2019W2, 2020S)
• CPSC203 Programming, Problem Solving, and Algorithms (2019W1)
• CPSC121 Models of Computation (2018S, 2018W1, 2018W2)

Prior to moving to UBC, I taught a similar menu of courses at the University of Illinois, Urbana-Champaign. Then, as now, my primary focus was the data structures course.

Awards

• UBC Killam Teaching Prize, 2020.
• University of Illinois 150 for 150 – celebrating the accomplishments of women at the University of Illinois. March, 2018.