Guide to New Curriculum

At the end of the 2002-2003 academic year, the WPI faculty approved an overhaul of the 1000 - and 2000-level courses in the CS department. These changes will take effect in A-term of 2004. This page explains why we changed the curriculum, what the new courses will look like, and how students will transition between the curricula.

Why Did CS Change the Curriculum?

The CS faculty observed several problems with the current sequence of 1000 - and 2000-level programming courses:

The courses lacked sufficient emphasis on program design (as opposed to just programming). Program design skills are increasingly important both on the job and for MQPs, especially those done for project centers and external sponsors.
CS1005 has not been as accessible or interesting to novice programmers and non-majors as we would like.
The ideal path to courses like 3733 was too long, leading many students to jump to 3000-level courses after 2005. While this was fine for some students, many lacked the programming skills for the 3000-level courses after just 2005.
Many students taking upper level CS courses struggle with using pointers and other C/C++ features effectively. Often, the students in this situation had been novice programmers in 1005, so they spent more time in 1005/2005 worrying about data structures and programming, and didn't adequately master pointers (which weren't covered again in other 2000-level courses).

To address these concerns, we decided to adopt two main principles:

Focus on program design from the very first course.
Order the languages used in the programming sequence to cover languages with fewer core concepts before those with more complicated core concepts.

Summary of New Curriculum

The resulting set of courses addresses these concerns (the next section provides the detailed course descriptions). For a novice programmer who wants to major in CS, the sequence of courses will be:

CS 1101: Introduction to Program Design (in Scheme)
CS 2102: Object-Oriented Design Concepts (in Java)
CS 2303: Systems Programming Concepts (in C++)

A student coming in with prior programming experience would replace CS 1101 with CS 1102: Accelerated Introduction to Program Design; this course will strongly resemble the recent offerings (C03 and A03) of CS2135. The Java course will assume students have had either CS1101 or CS1102. Unlike 1005/1006, CS 1101 and CS 1102 will count towards the 5 units required for the CS major.

Non-majors who want to take the systems courses have an alternate path that skips the Java/OO Design course. After CS1101 (or CS1102), a non-major can take CS 2301: Systems Programming for Non-Majors. This course will give students the C-skills they need to take courses such as CS 3013.

Non-majors who want to take CS 3733 (software engineering) but not the systems courses can skip the systems programming courses and go directly to 3733 after CS 2102. This shortens the preferred path to 3733 to two courses (1101/2-2102) from the current three (1005-2005-2136), while the emphasis on design allows the 3733 instructors to assume all students have OO programming skills in Java coming into the course.

The other new course is a 4000-level course in programming languages. The current CS 2135 was intended to cover both functional programming and programming languages. A good languages course requires more than 2 terms of programming background, though, so we moved this topic into a 4000-level course.

Overall, the material covered in the current curriculum is in the new curriculum, but moved around quite a bit (the exception is Prolog, which may move into the languages course but will not be in the 1000- or 2000-level courses). The new curriculum streamlines this material though, so that students can reach the upper level courses that interest them more quickly and with better preparation for those courses.

The remaining 2000-level courses, such as CS 2022, CS 2223, and CS 2011 remain unchanged (though CS 2011 may include slightly different material and will follow the systems programming courses).

Course Descriptions for New Courses

CS 1101 : Introduction to Program Design (Cat I)

This course introduces principles of computation and programming with an emphasis on program design. Topics include design and implementation of programs that use a variety of data structures (such as records, lists, and trees), functions, conditionals, and recursion. Students will be expected to design, implement, and debug programs in a functional programming language.

Intended audience: students desiring an introduction to programming and program design.

Recommended background: none. Either CS 1101 or CS 1102 provide sufficient background for further courses in the CS department. Undergraduate credit may not be earned for both this course and CS 1102. Undergraduate credit may not be earned both for this course and for CS 2135.

CS 1102 : Accelerated Introduction to Program Design (Cat I)

This course provides an accelerated introduction to design and implementation of functional programs. The course presents the material from CS 1101 at a fast pace (so students can migrate their programming experience to functional languages), then covers several advanced topics in functional programming (potential topics include macros, lazy programming with streams, and programming with higher-order functions). Students will be expected to design, implement, and debug programs in a functional programming language.

Intended audience: students starting with substantial previous programming background.

Recommended background: prior programming background covering lists, trees, functions, and recursion. Undergraduate credit may not be earned for both this course and CS 1101. Undergraduate credit may not be earned both for this course and for CS 2135.

CS 2102: Object-Oriented Design Concepts (Cat I)

This course introduces students to an object-oriented model of programming. Building from the design methodology covered in CS 1101/CS 1102, this course shows how programs can be decomposed into classes and objects. By emphasizing design, this course shows how to implement small defect-free programs and evaluate design decisions to select an optimal design under specific assumptions. Topics include inheritance, exceptions, interface, design by contract, basic design patterns, and reuse. Students will be expected to design, implement, and debug object-oriented programs composed of multiple classes and over a variety of data structures.

Intended audience: students with prior program design experience who desire to learn object-oriented design.

Recommended background: CS 1101 or CS 1102. Undergraduate credit may not be earned both for this course and for CS 2136.

CS 2303: Systems Programming Concepts (Cat I)

This course introduces students to a model of programming where the programming language exposes details of how the hardware stores and executes software. Building from the design concepts covered in CS 2102, this course covers manual memory management, pointers, the machine stack, and input/output mechanisms. The course will involve large-scale programming exercises and will be designed to help students confront issues of safe programming with system-level constructs. The course will cover several tools that assist programmers in these tasks. Students will be expected to design, implement, and debug programs in C++ and C.

Intended audience: computer science and computer engineering students with substantial prior object-oriented programming experience.

Recommended background: CS 2102.

CS 2301: Systems Programming for Non-Majors (Cat I)

This course helps students with prior program design experience migrate their skills to a model of programming where the programming language exposes details of how the hardware stores and executes software. Building from the design concepts covered in CS 1101/CS 1102, this course covers manual memory management, pointers, the machine stack, and input/output mechanisms. Students will be expected to design, implement, and debug programs in C.

Intended audience: non-computer science majors who wish to take upper-level courses in the systems area of the computer science curriculum.

Recommended background: CS 1101 or CS 1102. CS majors and other students wishing to prepare for upper-level CS courses in both systems and software engineering should take CS 2303 instead of CS 2301. Students who have credit for CS 2303 may not receive subsequent credit for CS 2301. Undergraduate credit may not be earned both for this course and for CS 2005.

CS 4536 : Programming Languages (Cat II)

This course covers the design and implementation of programming languages. Topics include data structures for representing programming languages, implementing control structures (such as functions, recursion, and exceptions), garbage collection, and type systems. Students will be expected to implement several small languages using a functional programming language.

Intended audience: CS majors and minors interested in understanding how programming languages work and how to implement their own small languages.

Recommended background: CS 2303, CS 3133, and experience programming in a functional language (as provided by CS 1101 or CS 1102). Undergraduate credit may not be earned for both this course and CS 536.

Which Courses are Being Removed?

The following courses will not be offered again after this academic year (2003-2004):

Students who have completed all of these courses by the end of D-term 04 will not be affected by the new curriculum. Students who have completed some, but not all, of these courses should refer to the next section on transitioning between the curricula.

What's the Transition Between Curricula?

The following table shows how students will transition into the new curriculum:

Student Has Taken	But Not Taken	Should Take
CS 1005/1006	CS 2005	new curriculum starting from CS 1101 or CS 1102
CS 1005/6 and CS 2005	CS 2135	CS 1102 and CS 2102; can skip CS 2303
CS 2005 and CS 2135	CS 2136	CS 2102; can skip CS 2303
CS 2005 and CS 2135, CS2136		no courses needed in new curriculum

As CS 1102 counts towards the CS degree, students who take this in lieu of 2135 will not have problems satisfying degree requirements.

Recommendations

Our strongest recommendation is that students who plan to major in CS be through CS 2005 by the end of this academic year.

We prefer that current students who have not taken 2135 and 2136 try to do so by the end of this year, to avoid overenrollments in the new courses next year (as they accommodate students from both curricula). However, you will not hurt your academic progress by transitioning according to the above table (assuming you have finished 2005): the number of courses you take remains the same, as do your degree requirements.

The only caveat if you choose to wait is that the transition course for students who have not taken 2135 (CS 1102) will be offered only once a year, in A-term. The transition course for 2136 will be offered in both B and D terms. See the next section on scheduling.

Scheduling

The anticipated schedule of courses in the new curriculum is as follows. We may adjust the number of sections based on enrollments, but this shows the terms in which each course will be offered. There will be one last offering of 2005 in B-term 2004, but that will be open to non-majors only.

A-term	B-term	C-term	D-term
1101		1101
1102

	2102		2102
2022		2022
	2223		2223
2303	2301	2303
	2011		2011

FAQ

(To be updated throughout the year, as needed)

Should I take 2135/2136 now or wait for the new and improved courses?: CS 2135 and CS 1102 will be very similar, so you gain nothing by waiting (and the scheduling is more restricted next year). CS 2136 and CS 2102 will be a bit different from one another: CS 2102 will not cover Prolog, and it will cover a bit more OO design material. Overall, the focus in CS 2102 will be more on design. Either course will prepare you for the upper-level CS courses.