Hal Perkins
Last edited 5/7/2000
This note proposes changes to the introductory programming courses CSE 142 and CSE 143 for the 2000-01 academic year. The principle goal is to update these courses for the first time in several years, to take advantage of and reflect current programming technology, and to streamline the presentation. A significant part of the proposed change is to switch to the Java programming language, because this appears to be the best environment currently available that will meet the needs of the students in these courses. The remainder of this note outlines the proposed changes and their implications in greater detail.
The introductory programming sequence at UW has evolved over the years to keep pace with changes in the field, advances in technology, and interests of the many constituencies with a stake in these courses. The last major change occurred more than 6 years ago, and included a switch from Ada to the C (in CSE 142) and C++ (in CSE 143) programming languages. These courses are not about any particular programming language - although they are sometimes perceived that way - but the choice of language is an important decision that affects how the courses are taught and, to some extent, what is taught in them.
The current versions of CSE 142 and CSE 143 are quite successful, measured both by enrollment demand and by student and other evaluations. But there is definitely room for improvement. In spite of language changes over the years, both courses are essentially the same as the ones taught years ago using Pascal and Modula. The software world has changed dramatically since then (particularly the pervasive use of object-oriented programming and software libraries), but this change is not reflected in our introductory courses, particularly CSE 142. Furthermore, after more than 6 years, with new instructors inserting their variations every quarter, the course materials, particularly lecture slides, are in need of substantial editing and trimming.
We propose to revamp these courses starting with a revised version of CSE 142 in Fall quarter 2000, followed by a revised version of CSE 143 in Winter quarter 2001. As part of these changes, we propose switching to the Java programming language in both courses. It certainly would be possible to make many of the proposed changes while retaining C++ and possibly C, but this is not the best we can do. Java is clearly superior to C and C++ as a language for teaching introductory programming (see next section for more details). Furthermore, a switch to Java makes a clean break with the past, and gives us a better chance to move forward, discarding bad habits accumulated over the years.
The changes we are proposing deal with the following problems in these courses:
Refreshing CSE 142 and CSE 143 and switching to Java will improve the current situation, but will not solve all of the problems with these courses. This proposal does not attempt to treat the following issues.
These are all legitimate issues, but we risk doing nothing if we try to do everything at once. The changes proposed here make solid improvements in the introductory courses that will serve us well as a foundation for further changes and improvements.
This section highlights the major changes proposed for both courses. There is some shifting of content between CSE 142 and CSE 143, but the overall coverage remains comparable to the current courses, although with a different balance between language features and programming concepts and skills. The use of Java does have some effect on the distribution of topics.
The major change in the content of CSE 142 will be introducing the basics of classes and objects at the very beginning of the course. This is required if we are to use Java in an idiomatic way. (The alternative is to abuse Java to create C/C++/Pascal-like programs, which seems wrong. If we try to avoid classes at the beginning of CSE 142, then somewhere along the way we have to tell the students to abandon the mental model they have built up about Java programs in order to do things the "right" way.) While we need to introduce classes early, all that is appropriate is a basic sketch of how to use classes to organize programs. The full implications of inheritance and various features of object-oriented programming should remain in CSE 143.
Along with early introduction of classes, we also want to introduce functions (methods) early in the CSE 142. This makes it possible to use simple graphics to create more compelling early assignments. It also evens out the conceptual load in CSE 142, putting some interesting and non-trivial concepts at the beginning of the course. That should make the course more interesting for students with some previous programming background, as well as help other students better calibrate the workload and difficulty of CSE 142.
Including classes and objects adds new topics to CSE 142. On the other hand, we won't need to spend course time discussing details of C pointers, C quirks like "0 is false, every other number is true", and so forth. On balance, the amount of material in the course should be roughly the same. The remainder of the course will include topics currently covered: assignment and expressions, conditional execution, iteration, arrays and classes (not structs), basics of input/output, basic software design, and so forth
Gries2, Arnow & Weiss, Lewis & Loftus, Horstmann, Savitch, Stein
CSE 143 should switch to Java the quarter following the switch in CSE 142. While it is possible to switch CSE 143 earlier or later, doing it the quarter after CSE 142 provides the smoothest transition for students and minimizes the amount of reworking that needs to be done to accommodate changes in CSE 142.
The biggest issue for CSE 143 will be dealing with incoming students who did not have a solid introduction to Java in their first course. Dropping the C to C++ transition at the beginning of the course will leave room for a review of the CSE 142 Java subset. We should also plan on using sections during the first week of the quarter as a high-speed bootcamp for students who have not seen Java previously. Students who have some programming experience, but who find this introduction to Java to be too intense, would be well advised to take CSE 142 instead. With the changes in that course, it is more likely that they would find CSE 142 a worthwhile use of their time.
Dealing with students who have taken a non-Java CSE 142 is not a one-time event that will happen only when we switch to Java. The problem will be more pronounced for the first few quarters after the switch, but we will always have students entering UW after having taken an introductory course elsewhere.
Beyond the background issue, CSE 143 will remain quite similar to the current course. The basic topics will remain object-oriented design and use of class hierarchies, basic data structures, recursion, and so forth. We might want to take a couple of lectures at the end of the course to introduce the basics of C/C++, particularly the memory model, which is the key difference for Java programmers encountering C/C++ for the first time. It is much easier to explain this after students are familiar with data structures in a cleaner (Java) setting.
Making major changes to these courses offers the opportunity to make a fresh start on various issues, but also presents some potential pitfalls. In particular, we should watch out for these.
There are many supporting details that need to be resolved to make the changes proposed here. This section outlines these issues and how to address them.
Paradoxically, adopting Java will cause some complications for CSE 142, while making it easier to find faculty to teach CSE 143. From the perspective of CSE 143, Java has a much less steep learning curve than C++, and more faculty are already familiar with it.
In the case of CSE 142, the course has been substantially the same for many years, even though the programming language syntax has changed. Modernizing the course will create a learning curve for some faculty compared to the work needed to teach the course as it currently exists.
For the first several quarters after updating the course we can avoid any problems by assigning senior faculty to the course who are already familiar with Java and the approach to programming it entails. But it will be an issue over the long term. Currently all n senior faculty members teach the course 1/n of the times it is offered. We should think seriously about whether this is the best model. The course might be better served by having fewer faculty members rotate through it more frequently, which would improve continuity and be an incentive for those faculty members to invest effort into the course. Obviously this would have to be accompanied by some reward mechanism to compensate for the additional effort it takes to teach a large course. This is not a new issue for the department, but the proposed changes to the introductory courses provide a reason to revisit it.
Current Teaching Assistants seem to be in favor of switching to Java and the related changes that would bring to both courses. Most of the TAs either know Java already, or could pick it up quickly since they are likely to be familiar with the concepts involved.
The main issues with TAs are creating a consistent experience for students regardless of who their TA is, assignment and section preparation, and amount of work required as a TA. These are not new problems, and an overhaul of both courses presents an opportunity to break from old patterns and make appropriate changes.
One potential issue is that for the first few quarters, at least, it will be important for TAs to attend lectures so they can stay in sync with the courses as they evolve. CSE 143 currently has a tradition that TAs attend lectures regularly, but this is not the case with CSE 142, both because the material is familiar, and because of scheduling conflicts with courses that TAs are taking. We have to keep the need for lecture attendance in mind when making TA assignments.
The lab consultants are CSE majors, which means most of them have some exposure to Java (via CSE 341), or would find it in their interests to learn the language. So, as with the TAs, the language shift should not be a major technical issue.
The biggest problems with consulting are spotty coverage and consultants' uneven familiarity with assignments and course content. Again, these are not new issues, and overhauling the courses gives us a chance to reset expectations of what is expected from consultants..
We will need to schedule some orientation and training sessions for the course staff outside of regular staff meeting times. This should include orientation to the new organization of CSE142/143, how Java is being used in the courses, and hands-on experience in the lab with the software environment for the course.
Java is Java, right? (sortof) Basic attitude: any environment you want to use is ok, but turnin server compiles using Sun JDK, and student programs should work with that system.
GUIs:
Sun JDK: free, command-line based. No debugger. If we use this, probably want to site-license a decent editor (textpad?) or else rely on emacs. Is this the right way to go?
Work over Su00
Biggest issue: where do students pick up enough C++ culture for later courses. Options:
Effects on other courses
Need to coordinate with the college and other departments. We already have an evaluation piece that needs to be put in place for the former ENGR 142, so the Java change creates no new continuing obligations. We need to get the sign-off from appropriate folks before making that transition.
Becomes more appropriate for students with a less-than-stellar prior course.
Issue of how to deal with students who have a good first course. Need to provide some sort of transition.
Winter 2001: If we have the resources, it would be useful to offer a "last" C++ version of CSE 143 in parallel with the first Java version. Gives former CSE 142 students more options.
Short-term issue: how to deal with CC transfers, particularly those with CSE142 credits
Long term. Presumably the CCs would follow our lead and move to Java for their intro courses. How do we make this work smoothly?