This was a big week for Computer Science at Whitman:
- On Saturday, I learned that Personnel Committee is recommending me for tenure.
- Yesterday, the faculty voted to approve the creation of a new Computer Science major.
Getting tenure the second time is not as exciting as the first time, but it’s still a relief. Giving up tenure at Grinnell to come to Whitman was hard, though I understood why Whitman did not offer tenure at hiring. It’s also important for Computer Science at Whitman. It’s hard to see how the program would go on if I had to leave at this early stage. I’ve long thought that chairing a new program (or any program, really) is no job for an untenured faculty member.
I was much more worried about the major proposal. In five rounds of review, I don’t think we got the same question twice. I had no idea what the faculty meeting yesterday would bring.
The deadline to change the course catalog is not until February. We brought the proposal forward early in case revisions were required. It was a pleasant surprise that the proposal passed the Science Division, Curriculum Committee, and the faculty as a whole, all on the first vote, with no opposition. We also had momentum from summer discussions and from mid-October meetings that led us to finish a draft of the major proposal in October, much sooner than I thought we would. Finally, we were aware that juniors and sophomores want to declare the major and would benefit from more certainty about the future.
The Registrar will start accepting CS major declaration forms after spring break, although they will not be entered in the computer system until summer.
Now that the proposal has been passed, I can talk about its contents.
I think it makes sense to talk about our course offerings before the major requirements. Andy drew up this handy diagram:
Reading top to bottom and left to right:
CS 167, Introduction to Computational Problem Solving, is our first course in CS. Taught in Python, we emphasize applications across a range of disciplines, as well as basic components of algorithms, use of basic data structures, and basic principles of algorithm design and analysis. Textbook: Discovering Computer Science by Jessen Havill.
CS 220, Discrete Math & Functional Programming, teaches proof techniques as applied to sets, relations, and functions, along with the basics of functional programming in SML. We wanted a discrete math course to serve as prerequisite to both CS 320 and CS 327, and given the choice to teach CS 167 in Python (not Scheme like at Grinnell), this is where functional programming seemed to fit best in our curriculum. I’m teaching this course for the first time this fall; it’s something I never dreamed I would teach. The unexpected gem is the open-ended data modeling project. Textbook: Discrete Mathematics & Functional Programming by Thomas VanDrunen.
CS 270, Data Structures, is the cornerstone of the CS curriculum and a prerequisite to every 300-level course. Textbook: Data Structures & Algorithms in C++ by Goodrich, Tamassia, and Mount (for now; we’ll gladly take recommendations).
CS 210, Computer Systems Fundamentals, lets students build a simulated computer system from digital logic up to a standard library. I describe the system as both “like a 1980s game console” and “the simplest thing that works.” There is a heavy emphasis on layering abstractions. Programming is in a model hardware definition language, a model assembly language, a model high-level language, and Python. Textbook: Elements of Computing Systems (AKA Nand to Tetris) by Nisan and Schocken.
CS 267, Human-Computer Interaction, teaches principles and practices of user experience design. We draw heavily on principles of cognitive psychology; we also apply ethnographic methods to learn about use contents and perform informal experiments to evaluate designs. In the future, I’d like to add offer an elective on Value Sensitive Design, which will include some similar methods but draw more on ethics and other humanist perspectives.
CS 320, Theory of Computation, develops increasingly powerful mathematical models of computation and explores the problems that can and cannot be solved under these models. Andy persuaded me during his job interview that this course should be required, both for the beauty of the subject matter and for the practical uses of state machines, regular expressions, and pushdown automata. Textbook: Sipser, I assume.
CS 327, Algorithm Design and Analysis, is in my view the heart of a computer science curriculum. Like Theory of Computation, it’s a fairly standard course. After much debate, we are tentatively requiring two semesters of calculus as prerequisite for their coverage of limits, sequences, and series, in addition to learning proof techniques Discrete Math or Intro to Higher Math. We look forward to students transferring the equivalents of CS 320 and 327 from AIT-Budapest. Textbook: Algorithms by Dasgupta, Papadimitriou, and Vazirani (a much slimmer volume than CLRS).
CS 370, Software Design, will teach principles and patterns of object-oriented design in Java, as well as use of a professional-grade IDE (Eclipse) and version control system (Git), through iterative development of a medium-sized project with evolving requirements. I’m teaching this course for the first time in the spring. I presented my colleagues with three possible versions of an upper-level software engineering course, and this is the one that I got John excited about teaching. (One of my principles of curriculum design is that we should not have a required course that only one person wants to teach—especially if that one person is me.) Textbook: Object Oriented Design Using Java by Dale Skrien.
CS 310, Computer Systems Programming, will complement CS 210 by focusing on the abstractions that enable sharing of resources amongst processes, threads, and users. It will span many of the topics typically split between a course on Computer Organization and Architecture course and a course on Operating Systems. Programming will be in the C programming language (the language of systems). I suggested it to Andy and he responded enthusiastically; he served as TA for a course using the textbook five times at U. Minnesota. Textbook: Computer Systems: A Programmer’s Perspective by Bryant and O’Hallaron.
CS 350, Artificial Intelligence, and CS 357, Natural Language Processing, are Andy’s two electives which we currently plan to alternate. Enrollments are strong and include students with independent majors in Cognitive Science.
CS 317, Software Performance Optimization, is John’s first elective. He is also developing a 200-level course on simulation methods.
Math 350, Mathematical Modeling, Math 337, Operations Research, and Math 467, Numerical Analysis, are courses we’ve decided to cross-list in CS because of their significant algorithmic content.
CS 495, 496, and 498 constitute our Capstone and Honors Project. Whitman requires that we offer an honors project or thesis, and many majors require a senior thesis or project of all students. The faculty will take turns designing and supervising year-long, team capstone projects. I believe Psychology is the only other major at Whitman where students do senior projects in teams; it was important to us not just as a way of managing unknown enrollments but because teamwork is typical of the discipline. The Honors Project will be an individual extension of the student’s team project. We intend this to be an integrative experience where students will apply what they’ve learned throughout their studies of computer science—and students will learn something about project management, as well.
I list textbooks and languages for core courses because they may help to provide a deeper sense of the content and tone of each course. Electives are up to the individual instructors. I don’t have a single textbook for HCI, and I know that John didn’t have a single textbook for CS 317.
You may note that there isn’t a Programming Languages requirement. At Grinnell, we dropped this requirement from the major after observing that we did not agree on the learning goals for the course, and that the introductory sequence satisfied a typical goal goal for a Programming Languages requirement: exposing students to multiple languages and paradigms. I hope that our “right language for the job” approach at Whitman will serve a similar function. In addition, CS 210 (core) includes implementation of basic parsing and compilation techniques, while CS 317 (elective) includes study of compiler optimizations.
My lingering regret is that we did not find a good place to include database design and SQL. It fit nicely into my software development course at Grinnell, but that was a different course that focused on Web applications. I would be interested in developing a course on information management, kind of like this one, but it ended up not fitting. My current best hope is for CS 370, but it would be a digression, and I doubt there will be time for it. As I plan the course this winter, I’ll see what I can do.
I will confess that we haven’t formally analyzed our curriculum according to the Computer Science Curricula 2013 learning outcomes, thought I’m confident we have reasonable coverage. Such analysis may be a project for this summer—or next summer, after we’ve taught all the classes at least once. One of my quotes to live by is Voltaire’s: “The best is the enemy of the good.” It seemed important to get a curriculum up and running so that we have something we can incrementally improve.
With the courses in place, here are the major requirements, with a bit of explanation:
The Computer Science major: Thirty-one credits in Computer Science at the 200 level or higher, including CS 310, 320, 327, 370, 495, and 496.
We decided not to count CS 167 towards the major because students vary so much in their background. Given two students who are both ready to take Data Structures, one may have AP credit and another may be self-taught. We want to discourage students with significant prior experience from taking CS 167 and intimidating real beginners.
We opted not to explicitly require 200-level courses. The main motivation was that Math 260, Introduction to Higher Math, has significant overlap with CS 220, Discrete Math & Functional Programming. Students may take either as a prerequisite to CS 320 and 327, but a student who took Math 260 and did well should not necessarily take CS 220. Students must also take CS 210 and 270 (or equivalents) as prerequisites to required 300-level courses.
Program planning: A Computer Science major entering with no prior experience in computer science will typically take CS 167 (4cr), 210 (3cr), 220 (3cr), and 270 (4cr) as prerequisites to the explicitly required courses (totaling 16 credits), along with six additional elective credits at the 200 level or higher, for a total of 36 credits. Students granted advanced placement may proceed directly to coursework at the 200 level. Students without advanced placement in mathematics will also take MATH 125 and 126 (totaling 6 credits) as prerequisites to CS 327.
The addendum above, inspired by the catalog description of the Physics major, clarifies a typical path through the curriculum.
Whitman majors cannot require more than 36 credits in a single department. (As long as CS and Math remain one department, we may technically be in violation of this policy.)
P-D-F and independent study credits may NOT be used to fulfill major or minor credit or course requirements in Computer Science. Courses taken P-D-F prior to the declaration of the major or minor may be applied to the major or minor.
This was a suggestion from one of the CS Steering Committee members. Given we are so uncertain about enrollments, we do not want to be swamped with requests for independent studies. Of course we want students to take major courses for a grade, but we do not want to preclude late major declarations.
Senior assessment: The senior assessment consists of the capstone project (CS 495 and 496), a one-hour oral examination, and satisfactory performance on the written Major Field Test. The oral examination will address topics from Data Structures and the 300-level CS core; the student’s capstone project may be considered as context for some questions.
The last things we decided on were the senior assessment and honors requirements (not reproduced here).
We learned during a CCSC-NW panel on assessment that many other CS programs that require a written exam use the Major Field Test (MFT). We also learned during a Whitman Center for Teaching and Learning lunch (organized at my request) that some other departments such as Psychology use the MFT to assess their majors. The MFT will serve as a program assessment in that we can compare the overall performance of students in our program with that of students at other institutions. We also do not have to write or score the exam.
Whitman’s graduation requirements include an oral examination in the major. When I raised the question at the Liberal Arts Computer Science Consortium meeting last summer, here’s the first response I got: “How committed are Whitman faculty to the oral exam?” Of the institutions represented, only Amherst requires an oral exam. We considered many models and finally decided on the description above, which will need to be fleshed out in its details this spring so we can advise our first 3 (or so) rising seniors on how to prepare for their senior exams.
I worked through three rounds of curriculum revisions with my colleagues at Grinnell. This experience taught me it is important to demonstrate you have realistic plans for instructors, ensuring courses are taught on a regular basis, and realistic sample plans for students, showing how the major can be completed. Here’s what we wrote in the proposal:
We anticipate that some students will arrive at Whitman with prior computer science experience, but many will not. A student who arrives at Whitman with a strong interest in computer science can readily complete the major requirements in four years, including both early preparation for summer research or internships and a semester of off-campus study not including computer science, even if they are not granted advanced placement in CS or mathematics:
|1||CS 167, MATH 125||7||CS 270, MATH 126||7|
|2||CS 220, elective||6||CS 210, 327||6|
|3||CS 310, elective||7||Off-campus study||0|
|4||CS 320, 495||5||CS 370, 496||4|
However, a student who discovers computer science after their arrival at Whitman can still complete all major requirements by the end of the eighth semester, even if they do not commit to the major until the end of the fourth semester:
|2||CS 167||4||CS 270||4|
|3||CS 220, elective||6||CS 210, 370, Math 126||9|
|4||CS 310, 320, 495||9||CS 327, 496, elective||7|
Thus far, student demand supports offering four sections of CS 167 per year and two sections of CS 270.
I’m already afraid we might need more course offerings to accommodate demand at the 100- and 200-level.
To maximize flexibility for students and to accommodate as many majors as possible, we aim to offer all required courses and their prerequisites on an annual basis.
At Grinnell, one of my advisees observed that upper-level courses taught every other year were not nearly as well taught as lower-level courses offered every year. It is difficult to improve a course if you don’t teach it regularly.
Electives will be offered on a rotating basis. To provide students with choices, and to permit students to take all 6 elective credits during their senior year if necessary, we aim to offer two electives per year, one in the fall and one in the spring.
Therefore, we plan the following annual teaching load, summing to 15 sections per year.
|Fall courses||Teaching credits||Spring courses||Teaching credits|
|CS 167||2||CS 167||2|
|CS 270||1||CS 270||1|
|CS/MATH 220||1*||CS 210||1|
|CS 320||1||CS 327||1|
|CS 310||1||CS 370||1|
|CS 495||0.5**||CS 496, 498||0.5**|
* David Guichard has expressed interest in teaching CS/MATH 220 when available. This would allow us to teach an additional CS elective on occasion.
In fact, David sat in on my course throughout this entire semester, which was terrific.
** CS 495 is a 2-credit class; CS 496 and 498 are 1-credit classes. For the purpose of calculating teaching load, we consider them to add up to one full course.
We are already looking at diverging from this schedule for next year. In particular, we hope to shift CS 320 from fall to spring so that Andy doesn’t teach three new upper level classes (CS 310, 320, and 495) at the same time. We are consulting our juniors and sophomores to make sure they won’t be adversely affected (in fact, it might help).
This is way too long, though still much shorter than the CS major proposal. Thanks to those who read either in full.