Arriving back in Champaign-Urbana after three months sabbatizing in France, I quickly wandered the hall soaking up various bits of intra-departmental gossip. None of which is any of your business. But several rumors put together strongly suggest that next fall, I'm going to be teaching The World's Largest Algorithms Class. Again.

Lemme splain. My computer science department has an algorithms course that is required for every undergraduate major *and* every graduate student. (Technically, the degree requirements allow students to take a course on automata theory to satisfy this requirement, instead of algorithms, but the fraction of students who take that option is insignificant.) I've taught this class five times in the last six years. I usually do it pretty well. With one exception, every time I've taught the class, I've had significantly more students than the previous time.

In Fall 2002, the class ended with a whopping 320 students—200 undergrads, 100 on-campus grads, and 20 internet-only grads. Despite trying to make the course harder, in a completely transparent attempt to drive students away, the number of final exams was exactly equal to the enrollment limit imposed by the ~~university~~ fire marshall. There was a *long* waiting list at the beginning of the semester. I taught the class in one big lecture hall, which was always full. The lectures were videotaped and shown live in another lecture hall, which was always empty (thanks in part to a few students who just would not shut up). The video was also put on the course web site, along with my lecture notes. That's how the online students saw the lectures, but the on-campus students had access to them as well. I had six teaching assistants and six homework graders. We had six written homeworks, two midterms, and a final exam. You can see what we did here.

I called it **The World's Largest Algorithms Class, Ever!** You should imagine it written in a cartoony font, like the top of a Richard Scarry children's book. (That's not entirely a joke. It was certainly the largest algorithms class ever taught at UIUC, by a factor of 1.6. I've never heard of a larger algorithms class anywhere else.)

Logistically, it was a nightmare. I was overwhelmed with administrivia, largely because I hadn't (and still haven't) mastered the art of delegation. It took forever for the graders to get the massive volume of homework back to the students. (I can't really blame the graders, though. Each homework assignment had five questions, and a typical question took 2-5 pages to answer well (and even more to answer badly). So even with students turning in team solutions, that meant the graders had to read somewhere between 10,000 and 20,000 pages of homework.) Exams were slightly easier, if only because each question only required a single page. A lot of my time was spent dealing with the 1% Rule: In an average week, 1% of your class will have an emergency that requires your attention. (Typical emergencies involve lost homework or exams, scheduling conflicts, plagiarism, and suicidal roommates.) The 1% Rule isn't a big problem for a class of 30 students, but for a class of 300+ it means an emergency every other day.

Pedagogically, it was a nightmare. I was supposed to teach essentially the same material to two completely different audiences—undergraduates and graduate students. It's just not possible. Half of the graduate students have already taken an undergrad algorithms course, and all of them are self-selected for their interest and ability in computer science. So most of the basic material is a waste of their time. On the other hand, the advanced material that necessarily makes up the bulk of a graduate-level course is completely over most undergrads' heads. The really good undergrads learn to drink foom the firehose, but (judging by their answers on exams) most of them just get wet.

It didn't go so well.

Sadly, the educational problems didn't seem to concern the department much, until the logistics became untenable. After all, every other required graduate computer science course is also a required undergrad course. Mixing grads and undergrads in the same classes is standard practice in my department. Fortunately, after/because I'd taught TWLACE, the department was finally willing to split the grads into one section and the undergrads into another, with two separate instructors. When I taught the undergrad section last spring, with “only” 190 students, it was almost sane.

This fall, the department welcomed about 110 new graduate students. (This is much higher than normal.) All of them have to pass the algorithms class by the end of their second year. Despite a recent drop in freshman enrollment, we still have over 1000 undergraduate CS majors. All of them have to pass the algorithms class before they graduate.

I'm on sabbatical this year. And because I'm on sabbatical, the theory group is short-staffed. So my department decided, in its infinite wisdom (and over the objections of the theory faculty), to temporarily recombine the graduate and undergraduate algorithms classes into a single section, just for this fall semester.

First warning sign: Apparently, less than 80 students are registered this semester.

Second warning sign: Next fall, when I'm back from sabbatical, one of the other theory faculty is planning to take a (well-deserved) teaching leave. So once again, we're going to be short-staffed. (Maybe we'll be lucky enough to hire more theory faculty, but new professors always teach special-topics classes their first semester, so that won't help me.)

So... I'm expecting to be assigned a combined algorithms class again next fall. And I'm expecting the enrollment to be *gargantufrickinormous*.

Help!! **How do people effectively teach multi-hundred student classes without going insane?**

## Recent Comments