That’s, Uh, Pretty Ambitious
The title of this post is taken from the reaction of the first person I showed this course schedule to. If we’re really going to teach Software Carpentry in one university term (12-13 weeks), this is the pace we’ll have to move at. What do you think? Is it crazy, or just nuts? And what, if anything, can be done about it?
Notes
- This course is designed for graduate students in science and engineering and their professional peers, which allows a faster pace than would otherwise be possible.
- All problem sets are due one week after being assigned; their due dates aren’t marked to avoid cluttering the table. Based on past experience, each problem set is 4-6 hours of work.
- There is no midterm or final examination.
| Date | Topics | Events |
|---|---|---|
| 2010-09-07 | Introduction to course | Post single-paragraph professional biography to course web site |
| 2010-09-09 | Associative data structures: sets; dictionaries | Problem set #1 (sets & dictionaries) |
| 2010-09-14 | Tracking down bugs: visual debuggers; breakpoints; watchpoints; debugging strategies | |
| 2010-09-16 | Read text files: data processing patterns; incremental development | Problem set #2 (parsing); in-lab practical exam on debuggers and debugging |
| 2010-09-21 | Quality assurance: data processing patterns; incremental de | Problem set #3 (designing tests) |
| 2010-09-23 | Regular expressions: patterns; groups; operators; anchors; finite state machines | Problem set #4 (regular expressions) |
| 2010-09-28 | Iterative program design: choosing data structures; refactoring; tuning | In-lab “live design” exercise |
| 2010-09-30 | First-class functions: functions as objects; apply; map; reduce | Problem set #5 (functional programming) |
| 2010-10-05 | Coding style: cognitive concerns; style rules; refactoring revisited | Problem set #6 (code reviews); in-lab code review |
| 2010-10-07 | File systems programming: directories as files; permissions; properties | Problem set #7 (finding duplicate files) |
| 2010-10-12 | Version control: motivating problems; update/commit; merge | In-lab setup and practice with Subversion or Mercurial |
| 2010-09-14 | Image processing: image representation; operators; recursion | Problem set #8 (image transformations) |
| 2010-10-19 | Data parallelism: array operations; shape operations; masking | Problem set #9 (numerical linear algebra and cellular automata) |
| 2010-10-21 | Performance: algorithmic vs. actual efficiency; profiling; tuning | Problem set #10 (profiling and speeding up small programs) |
| 2010-10-26 | Task automation: dependencies; dependency graphs; rules | Problem set #11 (using Make/SCons for data provenance) |
| 2010-10-28 | Spreadsheets: data representation; unitary operations; aggregation; visualization | Problem set #12 (data analysis using Excel or Calc); in-lab discussion of data visualization |
| 2010-11-02 | Databases: simple queries; filtering; aggregation; sub-queries | Problem set #13 (data analysis using SQL) |
| 2010-11-04 | XML: elements vs. attributes; syntax; recursion | Problem set #14 (extracting information from XML documents) |
| 2010-11-09 | Object-oriented programming: classes vs. instances; defining methods; constructors; data hiding | |
| 2010-11-11 | Object-oriented programming (cont.): polymorphism; inheritance; operator overloading | Problem set #15 (rewriting previous examples using classes) |
| 2010-11-16 | Information architecture: data modeling; entity-relationship analysis; class diagrams | Problem set #16 (designing data representations); in-lab design of data representations for simple problems |
| 2010-11-18 | User interfaces: reactive programming; basic GUI components | In-lab demonstration of GUI toolkit |
| 2010-11-23 | User interfaces (cont.): model-view-controller; design guidelines | Problem set #17 (constructing GUI controllers for previous example programs) |
| 2010-11-25 | Web programming: HTTP request cycle; passing parameters; special characters; fetching data | Problem set #18 (downloading and analyzing data) |
| 2010-11-30 | Web programming (cont.): providing data; maintaining state; security concerns | Problem set #19 (a simple data server); in-lab guest lecture on information security |
| 2010-12-02 | Parallel programming: task and data decomposition; Amdahl’s Law | |
| 2010-12-07 | Parallel programming (cont.): map/reduce | Problem set #20 (map/reduce parallelization of previous example) |
| 2010-12-09 | Teamwork: key empirical results in software engineering | |
| 2010-12-14 | Teamwork (cont.): SCRUM; teamware | In-lab demonstration of Trac and Google Code |
| 2010-12-16 | Review |
Categories: Lectures

1) You’ll never really know for sure until you teach it.
2) I’m a big fan of absurdly aggressive course schedules and syllabii. Students will do their best to live up to or down to whatever expectections you set. Aim high.
3) The only danger in aiming too high is if you have insufficiently frequent ways of assessing how well the students are doing with the material. With 20 problem sets, you really don’t have that issue.
4) 2&3 work best if you have a plan to adaptively scale down if need be. You hopefully won’t need it, but it’ll make your life less stressfull to have the contigency planned out. In mid-October, if you saw it was clear that you’d have to lose 2-3 classes and 1-2 problem sets, do you have a sense for which ones you’d cut?
5) What is “too much”, especially for a graduate course, depends a *lot* on context, as in later years of the program there’s a lot more flexibility as to how the students spend their time. I’m guessing that this course (a) isn’t part of the core, so only students who want to take it will, and (b) is a 2nd or so year course that students will take after their (hugely time-consuming) core coursework is done. Is that true? If so, I think you’re fine. The students will feel like it’s a lot of work for a non-core course, but the ones who wanted to take it will learn a lot. You might lose a few students who were only marginally interested in the first week or two, but sadly you can’t make them want to learn this stuff.
seems too aggressive to me. In order to do this course, the students should have followed an introductory course on programming first. In the second lesson you already explain what sets and dictionaries are, but remember that the average student don’t have an idea of: what a programming language is, how to install it on your computer, where to write programs and run them, what a variable is.
To me, this seems the program for two advanced courses on bioinformatics, let’s say Advanced Bioinformatics I and II.
Moreover, consider that if this was an european-bologna style course, you would need to calculate two hours of time to study for each hours of lesson. So if this course is composed by 30 lessons of ~5 hours each, then an average student will have to study 300 hours in order to pass the exam with full votes.
How long is a single class?
I’ve found while watching the videos posted so far I would semi-regularly pause them to read the material on-screen and make sure I understood it. Otherwise it was on occasion moving too quickly for me to contemplate the examples. This is as someone with a BS in computer science working full-time for >5 years with software (though not a full-time developer). Admittedly Python is somewhat new for me having read examples in places but never having programmed with it. So I feel I am quite a bit more familiar with the concepts than your intended audience.
Considering that in a classroom this pacing will be slowed down either due to questions or further explanation by the instructor, if each class is 50-55 minutes you are going to be tight in places. If you have 60 or 75 minutes you are probably comfortable.
For example, with 50 minutes the database lecture looks reasonable with ~37 minutes of videos, but regular expressions looks a bit on the long side with ~38 minutes + episode 5 (which doesn’t seem to load up now so I can’t check the length).
How long would you expect it to take an excellent, experienced individual to move through the material and complete the associated assignments? Multiply that time by a factor of ten to obtain an estimate of how long it would take a merely passable programmer to do the same tasks (given the order of magnitude difference between great and okay software folks on common work). Then further multiply by whatever learning fudge factor you expect to be associated with reasonable skill acquisition for a motivated member of the target audience.
I suspect your target audience can absorb one-half to one-sixth of the material you’ve outlined on the given schedule. That may sound pessimistic, but compare the “acquisition factor” against drop out rates for undergraduate C.S. majors faced with core classes during their freshman and sophomore years.
To mitigate, clearly separate your course’s main line content from enrichment learning goals and activities. Measure success against only those core learning objectives. Teaching to only the core objectives will keep the slower folks engaged and motivated while letting the plus-one-stddev crew really soak it in.
Thanks to everyone for comments. One thing I should have made clearer: I expect students will watch the videos we’re preparing on their own time (2-3 hours/week), then use the lecture time (another 2 hours/week) for in-class Q&A. I therefore think 4-6 hours per problem set is reasonable. All in, that’s an average of 15 hours/week, which is roughly what grad students in CS invest at the University of Toronto (at least, that’s what they tell us
.