Home > Lectures > That’s, Uh, Pretty Ambitious

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

  1. 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.
  2. 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.
  3. 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 Tags:
  1. July 6th, 2010 at 13:52 | #1

    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.

  2. July 6th, 2010 at 16:42 | #2

    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.

  3. Steve Monk
    July 6th, 2010 at 19:26 | #3

    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).

  4. July 7th, 2010 at 03:44 | #4

    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.

  5. Greg Wilson
    July 7th, 2010 at 17:07 | #5

    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 :-) .

  1. July 8th, 2010 at 19:28 | #1