UCOSP

Undergraduate Capstone Open Source Projects

Theory AND Practice

Posted by Greg Wilson on 2009/10/29

There’s nothing like a bit of controversy to push up readership—and blood pressure. I inadvertently started it by describing UCOSP to Joel Spolsky at DevDays in Toronto last Friday. He thought that having undergrads work on capstone projects in distributed teams was cool—cool enough that he’s willing to sponsor the program and have one of his employees mentor a Mercurial project next term.

Browsing our blog, he came across my post “A Rational Response to an Irrational Environment“. It starts by explaining that it’s rational for students to leave assignments to the last minute, since (a) focusing on one thing for a day is more productive than timeslicing five things for a week and (b) the spec is likely to have settled down by then. It then speculated that students in self-managed project courses tend to push work off because there aren’t the same looming deadlines and fixed grading schemes.

Joel used that post as a launchpad for his own post “Capstone projects and time management“, which is a critique of university computer science programs. In it, he asks, “Where are students supposed to learn about version control, bug tracking, working on teams, scheduling, estimating, debugging, usability testing, and documentation?” and says that, “Many universities have managed to convince themselves that the more irrelevant the curriculum is to the real world, the more elite they are.”

A lot of poeple didn’t like that. In “Joel Spolsky, Snake-Oil Salesman“, for example, Mark Dennehy challenges #2: “…what Joel hasn’t mentioned—and what [CS] lecturers can tell you because they’ve been debating it for decades, writing papers on it, holding conferences and have published peer-reviewed journals on the topic…—are that there are very specific and very good reasons why CS … undergraduate courses don’t get to cover all the industry tools Joel uses.” Some of his claims are questionable (team projects are actually as useful for beginners as they are for more experienced students) and some are straw men, but two are spot on: it’s impossible to put everything into a four year degree, and “university courses are for [teaching] the fundamentals so that the students can pick up specific skills far more rapidly and evaluate tools according to their proposed use.”.

The basic problem is a circle that many disciplines (not just CS) struggle to square. On the one hand, we’re here to teach students the fundamentals of particular subjects—stuff that will still be relevant a decade from now, and that will allow them to innovate, and to digest others’ innovations. On the other hand, most of those students are going to enter the workforce once they graduate rather than pursue research careers, and most employers care more about debugging C++ than about NP completeness. It isn’t an either/or choice—understanding the big picture helps you understand why certain things work, and knowing how to apply concepts helps you understand them—but there are only about 4500 hours in a typical four-year undergrad program, so something has to give.

My position used to be very close to Joel Spolsky’s—in fact, one of the reasons I started supervising capstone projects back in 2002 was my frustration with new graduates’ lack of practical skills. I believe passionately that the better your are at programming, the deeper your appreciation for the theory of computer science will be, but it’s taken me a while to appreciate just how many practical skills universities do teach. Think about it: many first-year students have never programmed. You can argue that they should have in high school—or even that it should be mandatory—but we have to work with the reality we’ve got. By second year, those same students are malloc’ing memory and doing pointer arithmetic; in third year, they’re writing fork and exec, and in fourth year, they’re programming robots to play soccer and building Rails applications that are robust enough for real-world use. Can you imagine math departments trying to get people from “this is a fraction” to “this is a tensor” in those same four years?

Could our students get even further if we taught them less theory? It depends what you mean by “further”. Take out statistics, and they wouldn’t be able to analyze the performance of computer networks. Take out the semantics of programming languages, and they wouldn’t be able to understand what an optimizing compiler does. You could ask, “How many will ever need to?” but the point is we don’t know, so we have to try to cover as many bases as we can.

Technical colleges used to offer a more immediately practical alternative for those who wanted it (not just in computing). Sadly, over the past 25 years most have re-made themselves in the image of universities, primarily because of the higher social standing associated with a university degree. This leaves students who aren’t interested in the big picture nowhere else to go, and employers nowhere else to recruit.

Splitting computer science departments in two is not a solution. Even if we had departments and programs for “pure” computer science and others for “applied”, in the same way that there are separate departments for chemistry and chemical engineering, both sides would still have to decide how much time to invest where. And if you talk to professors in chemical or civil engineering, they’ll tell you they get the same complaints as CS.

Making undergrad degrees longer isn’t a solution either: even a five- or six-year program wouldn’t be able to do more than scratch the surface of an increasingly diverse discipline. And as useful as work terms are, they just bring forward the point at which students and employers run into the problem that we’re teaching red/black trees instead of C# delegates.

Spolsky’s praise for our cross-country capstone projects is immediately followed by the claim that, “…student projects, while laudatory, frequently fail to deliver anything useful.” In fact, about a quarter of the 129 student projects I’ve helped supervise since 2002 have delivered software that clients actually used, and the rest have produced something just as useful: experience. I think our students can be proud of that record, especially when you consider that a one-term course is equivalent to just three weeks of full-time work.

UCOSP is just one experiment of many—embedding students in ongoing open source projects, as David Humphrey describes in “Who are your peers?, also holds tremendous promise, as do the dozens of other ideas that people are trying out all over the world. The challenge now is to figure out how to scale these ideas up without heroic effort from either instructors or students. We’d welcome your suggestions.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

 
%d bloggers like this: