So, it will likely be posted as a sessional (contract) instructor position. We have had sessionals do the course in the past, but I reckon I can make things a little more interesting: there’s a good web development community in Vancouver, and there a lot of people who would do a good job with the course. There is also an increasingly-large group of CMPT 470 alumni who have been out there in the world for a few years getting some experience: some of them would be good at this too.

I just have to find somebody and get them to actually apply. So, I’m putting the call out: anybody interested or know anybody who’d be good?

The course (as I approach it) is a survey of web development topics: markup and style, HTTP, server-side programming, client-side programming, architecture/speed/backend stuff, and whatever else I feel like talking about that semester. The big piece of work for the students is a group-based project which makes up a big chunk of their final mark.

Officially the appointment requires a masters degree, but a case can be made for somebody with industrial (and even better, teaching) experience. The course is scheduled in the evenings (Mondays 5:30-8:30) on the Burnaby campus, so shouldn’t interfere too directly with a day job. Pay is around $8500 plus benefits.

Of course, anybody teaching the course is welcome to my lecture notes, assignments, web materials, and anything else I have that would be useful. There’s no official posting yet, but I figure it’s a good time for people to start thinking about it. I’m happy to talk to anybody about the course.

Edit: I should point out that I’m not the one making the hiring decisions. I’m just an interested third party.

Given those things, I have had this idea: It would make perfectly good sense for each of those things (every student in a course; every group in a course) to have a version control repository automatically created for them. The instructor and TAs would also have access, but wouldn’t have to set anything up. Students could use the repositories even in courses where the instructor doesn’t know what technology is.

I have used Subversion repositories for the project groups in CMPT 470 for years. The benefits from my point of view:

1. Groups can collaborate in that way that version control systems allow.
2. Students can work on code (even individually) in multiple locations and with versions kept.
3. All of their code is safely backed-up on a server that we kind of trust.
4. I can review what members of the group contributed what code.
5. It’s a nice and easy way to submit code: just give me the SVN URL.

When contemplating technologies to implement my scheme, I went first to GIT (or possibly some other distributed version control system, since they’re all the rage). GIT also has a pile of nice management tools like gitolite that make creating thousands of repositories surprisingly easy.

But while experimenting, I realized that GIT inherently trusted the user-provided information about who they are. If I claim to be “Barack Obama <president @whitehouse.gov>” in my commits, then GIT lets me push those commits just fine, no matter who I have authenticated as at the central server. So, I pretty much lose benefit (4) in the worst cases (which are the cases I’m usually concerned with), which is pretty much a deal-breaker by itself.

The “distributed” nature of any DVCS gets me this problem one way or another—anybody could push the whole group’s work since they could be working for weeks without touching the central server. And having made that realization, I have to admit that (3) also disappears: they don’t have to push to the server very often, so a crash on their end could lose a lot of work.

Finally, knowing students the way I do, (5) is gone too. I’d give a lot to not have this conversation five times a semester: “I got a zero.” “You didn’t submit any code.” “Yes, I committed it.” “You committed it, but did you push it to the server?” “Yes, I pushed it.” “You typed the command ‘git push’?” “No, I use ‘git commit’. That puts the code on the server.” “No it doesn’t. You didn’t put any code on the server where I can get it.” “Yes I did… I committed it.”

Also, it’s my understanding that it’s not possible to give a URL to a subtree of a GIT repository: the only URL is to the project itself. That makes submitting with GIT much harder.

So, I’m left with this: distributed version control is at least as good for developers, but it’s very bad for instructors.

According to Wikipedia’s comparison of revision control software, the only open source, “actively-developed”, “client-server” VCS is Subversion. So it looks like I’m back to the totally-uncool and old-fashioned SVN?

Does anybody want to refute any of that?

On the basis of Peter Norvig’s excellent essay “Teach Yourself Programming in Ten Years“, I extrapolate that in the past ten years, I must have learned how to do this thing that I claim to be my profession.

Because I like Norvig’s examples, I will add my own: Queen formed in 1971, and played the Queen Rock Montreal show in 1981. Just look at that performance, just look at it! I’m convinced Freedie was an alien from the planet of excellent stage performers and was exiled for making everyone else look bad.

While I’m not Freddie Mercury, I think I’m doing okay. I have felt my lecturing style change, even within the last year. It’s somehow just easier; more comfortable. I’m more likely to leave a lecture and think “anybody that thinks they could have done that any better can go fuck themselves,” usually on days when I have coffee, which does funny things to my brain.

I still think of myself as a better course designer than actual “lecturer”, but that’s another story.

By the numbers: (all values as close as I can figure without really looking that hard)

• Students taught on campus: 4900
• Students supervised in distance sections: 2200
• Time spent lecturing: 1600 hours, or two straight months
• Time spent watching exams: 220 hours, or one icepick lobotomy
• Sections of CMPT 120: 4
• Sections of CMPT 165: 14 on campus, 17 distance
• Sections of CMPT 470: 13, with 153 project groups
• Projects supervised: 9 (capstone, directed studies, etc.)
• TAs supervised: 125
• Emails sent and received: 150,000 (wild guess)

Okay… I’m tired just looking at that. Must be getting old.

But now I’m taking a good hard look at the course. I still like the overall flow, but there are some things I want to change.

I did a survey of the current students to get some feedback, but they lack perspective, having just finished the course. I figure I can get some eyeballs from course alumni here and am looking for some more meaningful feedback.

Question 1: Weekly Exercises and Grading Scheme

When I did CMPT 383, I gave weekly exercises, thinking that they might feel a little bit hand-holdey for an upper-division course. Much to my surprise, they worked better there than they do in 120 and 165: more-senior students are in a much better position to appreciate the micro-lessons that the exercises encapsulate and better understand why they are helpful. It’s also a chance to give problems on everything, not just a few things in major assignments.

I have realized that I want to do weekly exercises in CMPT 470, replacing the three assignments. The problem is: the assignments are worth 30% of the course. The weekly exercises would receive minimal marking and feedback (likely marking scheme: 2=most/everything correct, 1=some stuff done, 0=little/nothing done). With that little “grading”, 30% is too much to give to them: 20% is more reasonable.

So, I have 10% of the final grade to reallocate somewhere. Any suggestions about where an extra 10% of weight should be distributed? (The old grading scheme is online.)

[To give you an idea, I'm imagining that some of the exercises will be like "learn these three important CSS techniques and use each to style this sample page"; "find security holes in this sample mini-app I have created for you"; "pick Rails/Django/whatever and do the tutorial on their site"; "deploy your tutorial code on your group's web server"; "do something with jQuery"]

Question 2: Content

I have certainly done my best to keep with the times, and talk about new web-related topics as they have become relevant. But like I said before: the overall backbone of the course has remained the same.

Are there things that I should have spent more lecture time on than I did? Things that took up too much time?

I definitely want to move JavaScript stuff a little earlier in the course: it deserves to be at least a little more front-and-centre than it has been.

Question 3: Other Stuff?

I have a few other smaller tweaks in mind, and am open to other feedback.

In particular, I plan to (explicitly) open the technology evaluation to a wider array of technologies: JavaScript frameworks, databases. This past semester, I started to realize that the server-side frameworks (Django, Rails, Cake, …) are all fundamentally the same (at the depth that’s possible in the techeval). There are other pieces of technology that are more interesting choices at this point, and they might as well evaluate those.

I’m happy to take any half-baked thoughts on any of this here, or by email.

I had forgotten how much work a new course prep is, particularly as I am anal-retentive enough to not be able to make much use of any other instructor’s course materials. Other instructors just do things… wrong. The only way for a course to feel right is to do it my way, for myself. Giving lectures from somebody else’s notes is like wearing somebody else’s underwear: technically probably just fine, but you just feel dirty.

That’s not to say other people who teach the same courses I do do a bad job: they are generally excellent instructors teaching excellent courses. They just do it wrong, is all.

But, looking at my plan for 383, I came in pretty close to the plan. The final balance of topics was more like 6 weeks, 4 weeks, 3 weeks, but that’s astonishingly close for somebody who usually just stops somewhere around the midterm and thinks “does that feel like about half of the material? Okay good.”

Overall, I’m very happy with it. First offerings of a course are supposed to be bumpy and full of things that you wish you could have done better. Honestly, this was one of my favourite course offerings ever: there are tweaks I’d do for my next offering, but all are fairly minor.

Specifics:

• The weekly exercises were (to my mind, at least) a total win. My goal throughout was basically to say “remember that thing I talked about this week? Practice it” and I think it worked for the students. I liked them to the point that I’m planning that every course I teach from now on will have weekly exercises, including 470. (More on 470 in a later post.)
• Some of the more involved examples I put together were among my favourite learning objects ever. (God, I can’t believe I just used the term “learning objects“. I have become everything I hate.)
• I think I actually convinced them that Haskell was practical. Was that irresponsible?
• Prolog sucks, but I’m still convinced it’s a worthwhile exercise.
• The “language concepts” section felt a bit like a laundry list of topics. I don’t know that there’s really any way around that. Maybe I could re-order things a bit so they flow together better.
• The project was interesting for all concerned. I’d probably cut down to three or four language choices in the future, just to keep the TA from losing his mind.
• I’m not particularly happy with the exams, but I’m never happy with my exams.
• Ted was an invaluable sounding board throughout the semester, taking time he didn’t have to listen to my meanderings on the course. Thanks be to Ted, who will do an excellent job teaching the course in the fall. (Excellent, but wrong.)

The feedback I have had from the student side has been very good so far (with the real teaching evaluations still outstanding). I have never before had so many students who had nothing to do with a course talk to me about it. Random students in the hall thought my project was a good idea; everybody and their dog knew about my first assignment; people with friends in the course want to know when I’m teaching it again.

I’ll take that as creating a “buzz” and call it a good thing.

I was there for the rise of the MVC frameworks and greeted them with open arms. I watched Web 2.0 proclaim “screw it, everything is JavaScript now” and listed with suspicion, but interest. I am currently watching HTML5/CSS3 develop with excitement but wondering why nobody is asking whether IE will support any of it before the sun burns out.

There’s another thing on the horizon that is causing me great confusion: NoSQL.

The NoSQL idea is basically that relational databases (MySQL, Oracle, MSSQL, etc.) are not the best solution to every problem, and that there is a lot more to the data-storage landscape. I can get behind that.

But then, the NoSQL aficionados keep talking. “Relational databases are slow” they say. “You should never JOIN.” “Relational databases can’t scale.” These things sound suspicious. Relational databases have a long history of being very good at their job: these are big assertions that should be accompanied by equally-big evidence.

So, I’m going to try to talk some of this through. Let’s start with the non-relational database types. (I’ll stick to the ones getting a lot of NoSQL-related attention.)

Key-value stores

(e.g. Cassandra, Memcachedb) A key-value store sounds simple enough: it’s a collection of keys (that you lookup with) and each key has an associated value (which is the data you want). For Memcachedb, that’s exactly what you get: keys (strings) and values (strings/binary blobs that you interpret to your whim).

Cassandra add another layer of indirection: each “value” can itself be a dictionary of key-value pairs. So, the “value” associated with the key “ggbaker” might be {"fname":"Greg", "mi":"G", "lname":"Baker"}. Each of those sub-key-values is called a “column”. So, the record “ggbaker” has a column with name “fname” and value “Greg” (with a timestamp). Each record can have whatever set of columns are appropriate.

Document stores

(e.g. CouchDB, MongoDB) The idea here is that each “row” of your data is basically a collection of key-value pairs. For example, one record might be {"fname":"Greg", "mi":"G", "lname":"Baker"}. Some other records might be missing the middle initial, or have a phone number added: there is no fixed schema, just rows storing properties. I choose to think of this as a “collection of JSON objects that you can query” (but of course the internal data format is probably not JSON).

Mongo has a useful SQL to Mongo chart that summarizes things nicely.

Tabular

(e.g. BigTable, Hbase) The big difference here seems to be that the tabular databases use a fixed schema. So, I have to declare ahead of time that I will have a “people” table and entries in there can have columns “fname”, “lname”, and “mi”. Not every column has to be filled for each row, but there’s a fixed set.

There are typically many of these “tables”, each with their own schema.

Summary: There’s a lot of similarity here. Things aren’t as different as I thought. In fact, the big common thread is certainly less-structured data (compared to the relational style of foreign keys and rigid data definition). Of course, I haven’t gotten into how you can actually query this data, but that’s a whole other thing.

Let’s see if I can summarize this (with Haskell-ish type notation, since that’s fresh in my head).

data Key,Data = String
memcacheDB :: Map Key Data
data CassandraRecord = Map Key (Data, Timestamp)
cassandraDB :: Map Key CassandraRecord

data JSON = Map Key (String | Number | … | JSON)
mongoDB,couchDB :: [JSON]

data Schema = [Key]
data BigTable = (Schema, [Map Key Data]) -- where only keys from Schema are allowed in the map
bigTableDB :: Map Key BigTable -- key here is table name

The documentation for these projects is generally somewhere between poor and non-existent: there are a lot of claims of speed and efficiency and how they are totally faster than MySQL. What’s in short supply are examples/descriptions of how to actually get things done. (For example, somewhere in my searching, I saw the phrase “for examples of usage, see the unit tests.”)

That’s a good start. Hopefully I can get back to this and say something else useful on the topic.

I do my best to give interesting, informative, and entertaining lectures. I’m successful enough that most students come most of the time, and that’s awesome.

Sometimes students don’t come to lecture. They don’t need a good reason, and they don’t have to tell me about it. I’m okay with that too: part of being at university is being responsible about that kind of thing and I’m happy to assume that whatever reason they have is a good one.

But what really annoys me is when students feel the need to email me, tell me the stupid reason they didn’t come to lecture, and then ask me to tell them what I covered.

I already spent an hour (or three hours) of my time giving the lecture and they had an opportunity to attend. I put a great deal of time and effort into explaining the material in the best way I can and pointing out the things that I think are important. I did all of this because I think I can actually do a decent job of getting material across in the lecture format and I think the material I’m talking about is important.

These emails leave me with two choices: (1) reduce a carefully-prepared lecture to a pointless list of topics and thus implying that I might as well have read them the textbook, or (2) spending another hour repeating the lecture in email form. Neither one of those is very attractive, but there’s also the third option that I have started to avail myself of: telling the students to shove off.

I’ll say here what I said to my CMPT 165 class last semester: if you miss a lecture, you ask a friend in the class for their notes. If you don’t have a friend in the class, ask the person sitting beside you; if at all possible, try to do this when you are sitting beside someone who you find attractive and offer to buy them coffee in return.

Seriously… do I have to explain everything?

cf. entitlement generation.

But, I’m on-deck to teach it in the summer. The class is full; the waiting list is full; must be time to plan a course. After much soul-searching, I have decided there will be three main topics in the course and they will be covered in this order:

Functional programming (and Haskell)

This will be most students’ first introduction to a non-imperative programming paradigm (and associated language). Every little while I think this won’t take long, then I remember the list of things that have to be introduced to get anywhere with Haskell: being really good at recursion, list comprehensions, lazy evaluation, type inference, higher-order functions, and other stuff to be discovered as I try to teach the language.

From my perspective, there are two reasons to be talking about functional programming. First, it’s finding some relevance, probably because people want to parallelize things (e.g. CouchDB). Second, there are important lessons from functional programming that can be transferred to OO programming.

“Language Features”

This section contains the big concepts of the course: type systems (static/dynamic, strong/weak, type coercion, duck-typing, late/early binding, …), interpreted vs compiled, pointers vs references, memory management, reflection, runtime environments, first-class functions, objects, exceptions, mutable/immutable objects, ….

The basic question here is: what are the real differences between the programming languages you have to choose from? How might they affect your choice of language for a project?

Logic programming (and Prolog)

As much as I am aware that Prolog is pretty much confined to old school AI researchers, I still think there’s some value in being exposed to logic programming. It should be possible to translate back to the OO world the idea of expressing a problem as a series of constraints and then looking to satisfy those constraints.

To be fair, this is the chunk I am most unsure of. Part of the reason it comes last is that if anything should fall off the end of a full semester, it’s this.

The exact balance of the topics remains to be seen. I’ll guess 5 weeks, 5 weeks, 3 weeks.

As for getting marks, I am as far as:

• Lab exercises: weekly hour-or-two chances to practice the concrete skills.
• Assignments: like… two of them? One Haskell, one Prolog?
• Project: pick a somewhat obscure language from a list I provide. Explore it by writing a report and some programs with it.
• A midterm and a final exam.

No idea what I’ll ask on the exams. Maybe Warren has some old ones I can look at.

So there it is. Unless I change my mind.

Six hours is too goddamn long to be in exams. I can think of no way to describe the day other than a list of happenings:

[tl;dr Go for 2b, 3ab, 4b.]

1. Pre exam:
   1. The first exams start at 8:30. At 7:45, not one but two of my colleagues were still trying to photocopy their exams for big sections. Office photocopier was jamming every two seconds; grad photocopier was down.
   2. Critical mobile phone usage #1: realizing Amanda would already be in her office, I phoned her and got one colleague into the photocopier in the Dean’s Office.
   3. “Wait… did I tell that student she could start a half hour early? Where was she going to meet me?” Send TA running to the room with an exam paper, just in case. (No student.)
2. On campus section:
   1. Before the exam, a girl flagged me down and told me she “had cancer before” and had been feeling lightheaded this morning. If she had to leave during the exam, that was why. I tried to get her to Health Services right away, but she insisted on staying. At the end of the exam, I convinced her to at least go and get her blood pressure taken or something.
   2. Two minutes into the exam, after sitting there for three or four minutes before it started, looking at the exam cover sheet (which says “CMPT 165″) and me, a student put up his hand and said “this isn’t CMPT 120″ and left.
   3. Freakin’ piles of questions, including “can you give me a hint” and “what time does the exam end”. Many more questions than the distance section.
3. Distance ed section:
   1. About 10 minutes into an exam, one of the kids that had run in a few minutes late flagged a TA over and said “I feel like I might pass out.” I talked to him for a few seconds and he was not entirely conscious: able to answer yes or no questions, but that’s about it. He probably couldn’t have walked out of the room at that point.
   2. Critical mobile phone usage #2: phoned SFU security for a medical emergency. To the credit of security: they came quickly and handled it quietly and with a minimum amount to spectacle to distract everybody else. They took the student to Health Services.
   3. After all this, I start to realize that I have been getting lightheaded when standing up: I’m hungry and totally dehydrated from four hours running up and down hot lecture halls. A litre of water and snack later, I’m feeling much better.
   4. A guy came in 45 minutes late after “car problems”. A girl came in about 1:15 late after a car accident on the way from Abbotsford.
   5. With an hour left in the exam, passed-out student came back! He wanted to finish his exam and was pretty sure he could get it done. I took this as a sign of not yet being fully capable of making decisions and sent him to the distance ed office to schedule an alternate time.
   6. Critical mobile phone usage #3: phoned distance ed and told them the story so they’d deal with this kid appropriately. Apparently he wrote the exam later in the afternoon anyway (but at least he had the full three hours).
4. After the exams:
   1. I’m barely standing at this point.
   2. I was talking to Anne, and told her the story of my day. Anne is preparing to teach a course like 165 in Uruguay (since she is currently on study leave). She was translating the course outline to Spanish and kept asking me things like “what wording do you like better?” I must have said three times: “Anne… you know I don’t speak Spanish, right?!”
   3. I might have eventually just wandered out of her office while she was still talking. I don’t really remember.

There was probably more. That’s all that’s coming to mind at the moment.

I’m going to be supervising a group of students on the technical side of their project. Since I’m me, the plan is to do a web project. I thought about this for about 8 seconds before I realized what I must do… there’s an obvious set of web projects that I understand, students understand, and need to me done.

We have some very old and clunky web tools around the School that work, but aren’t pretty and don’t have much hope of improving in the future. Students will know our gradebook and assignment submission tools, but there are a bunch more that aren’t student-facing.

My plan: replace as much as possible with modern, integrated, functional tools. The plan goes (or at least start) like this:

• Global: Unified CAS authentication. A useful “dashboard” for everybody displaying recent activity relevant to them (upcoming due dates, recently posted grades, recent assignment submissions, etc). Instructors should be able to copy an old offering to a new one (copying grading info, due dates, etc).
• Gradebook: the basics as currently implemented, with calculated columns, released/unreleased columns, AJAX-y sorting and display of class lists, email notification of new grades (?).
• Submission: Per-assignment configuration (e.g. assignment 1 requires submission of a text file for part 1, and a .java file for part 2; both are submitted as distinct files).
• Marking: Instructor sets up a marking key for TAs; TAs give grades and comments; info returned to students and grades automatically put into gradebook.

Additional functionality suggestions welcome. I have some cool “maybe” features to throw in if things go well.

I’m going to be treating whatever group I have as a development team, not a class. So, I’ll be whipping them much more to get good-quality code, not a class project.

There’s certainly a possibility of catastrophic failure, but I’d say a reasonable chance of success. We’ll see what happens.