Two Semesters Teaching CS2 With C++ and Java

As you may recall, I have been experimenting with a CS2 design that teaches both C++ and Java in a single semester.  I previously reported on the success of the design after teaching a section of majors and non-majors in the off-term.  This semester, we used an iteration of the design with two large sections taught by myself and another instructor.  Most students this semester took CS2 immediately after taking CS1 last semester.

The grades for my section are shown above (the other section's distribution was similar).  As you can see, students generally either "got it" or they didn't.  The average of all final exams in the two sections was about 70%, as was the average final grade (I expected worse for both measures).  No concessions were made to massage grades other than to drop marks for one of eleven assignments (dropping one tutorial mark of eleven and one quiz mark of three was always planned).

Aside from better preparing students for our second year courses, a major goal of the redesign was to ensure that students who do not master the concepts don't continue.  My hope is that the grade distribution above indicates this will happen.  Certainly my design has enabled me to assess deeper understanding of concepts that serve as a foundation to what comes next; such concepts were not prominent (or even existent) in previous designs.

Much of the course design was stable from last term, with some improvements in sequencing and in class code examples.  The topics now progress rather nicely from a low level procedural view of problem solving, all the way up to advanced object-oriented programming.  The new topic list follows.

• Introduction
• Introduction to problem solving
• Introduction to C++
• Pure puzzles
• Solving Problems With Arrays (C++)
• Arrays and structs  (including memory models)
• Solving problems with arrays
• Solving Problems With Dynamic Memory (C++)
• Stack and heap
• Pointers
• Dynamic memory
• Object-Oriented Basics
• Introduction to objects (including memory models)
• Introduction to Java
• Object behaviour (constructors, methods)
• References and linked lists in Java
• Shallow vs deep copying in Java
• Solving Problems With Classes (Java)
• Goals of class use (encapsulation, information hiding, etc)
• Complex reference structures
• Separated presentation design
• Abstract data types
• Advanced Object-Oriented Programming (Java)
• Class hierarchies and inheritance
• Polymorphism
• Abstract classes and interfaces
• Event-Driven Programming (Java)
• Introduction to Processing
• Model-view-controller
• Polymorphism you can see
• Solving Problems With Recursion (Java)

My slides and code examples (other than code directly from our textbook, Think Like a Programmer) can be found on GitHub.

This summer, the course will be taught according to the current design, and so far it seems the plan is to continue with it next year to give time to evaluate how well students were prepared for second year.  It will be interesting to see whether it will be used long term, and if so, how it will evolve.