Before reading on, you may want to go read about the course design. In particular, have a look at the progression of topics at the end (my lecture slides are attached as well, if you're interested).
After introducing problem solving strategies that I wanted students to use throughout the course, I started with C++ basics. I began talking about how simple data appeared in memory. The next topic, solving problems with arrays, allowed me to build on both the problem solving strategies and the memory model. Once we introduced classes, I brought Java into the mix. Then we covered dynamic memory in C++ and compared that with Java's memory model. We talked about linked lists and a branching story app in Java to get used to programs with more complex reference structures. At this point, we were able to leave C++ behind and move on to more advanced OOP with Java. Later I showed them how to use the Processing library in Java to make a program where you could "see" polymorphism at play with various related objects on the screen. I also showed how to set up a simple model-view-controller design with Processing. Finally, we covered recursion with a focus on recursive data structures.
In the middle of the term, I conducted an informal, anonymous survey to find out how well the new design was working (or, more accurately, whether doing C++ and Java together was a bad idea). Although the reviews were mixed, there were definitely more positive responses than I would have guessed. It was also very interesting to learn that more students found Java more difficult than C++.
When I met with two fellow instructors and one of my TAs to decide whether we would continue this course design next term, we discussed one very promising phenomenon: students were finally asking conceptual questions instead of just syntax. My TA had worked with this course three times in a row with three different instructors, each with a different approach. He noted that this was the first time he had heard so many interesting, in-depth questions. Students were talking about things like the stack and the heap for the first time, for example, even though these topics were technically covered in previous offerings. Getting students to go beyond syntax has been one of the faculty's major goals for a while now, and it seems that we may have finally figured out how to make that happen.
Ever since the midterm survey, students have been telling me in person and over email how much they appreciate this course design. Some tell me that they understand Java so much better than they had previously (either from taking this class before, or learning Java elsewhere). Others tell me they have found the class interesting and useful. One or two complained about the difficulty, but they seemed to appreciate what we were going for when we discussed it.
Of course, there are a number of students who are struggling. But it seems these are the students who would be struggling regardless of whether we included C++. We know this because many of these students are the ones who miss all or most lectures, who don't go to (or work during) tutorials, who don't complete assignments, and who don't come to ask for help. These students are the ones who would be unlikely to pass even if the course was all Java.
Indeed, ensuring that only those who truly understand the material move on is another goal of the redesign. We don't want students who have no hope of passing our systems programming class to be able to move on from this course. An added bonus of including Java has been better assessment tools. I've been able to ask much more pointed questions about how Java works thanks to the ability to compare to C++. So those who pass should truly understand what we want them to.
Regardless of those who are struggling, the verdict has been clear: C++ and Java together are definitely not a disaster. Now we shall see how the next iteration of the design fares next semester when we have quadruple the students taking the course, and even more importantly, when these students move on to second year.