A few observations after three weeks of class:

  1. A mix of Buckley's cough syrup and jalapeno peppers clears sinus congestion better than either on its own.
  2. Lecturing under the influence of such a mixture is a bad idea: I made of mess of both the first lecture on testing, and the spec for exercise 2. I'm also worried that some students are being left behind, but it seems that these are mostly people with no prior programming experience. As much as I'd like the course to be accessible to them, trying to cater to both complete newcomers, and people looking for a second-level course on software construction, will leave both unsatisfied.
  3. That said, the course seems to be going reasonably well: 66 students submitted solutions to Exercise 1, and of those, 48 of the 55 based in Toronto got 80% or better. The graphics are coming along (as soon as I figure out how to stop the backgrounds coming out black when you print from Firefox, I'll post a fresh set of PDFs), and:
  4. The folks at Prince have donated a license for their PDF generation tool, so that I can produce PDFs as part of my regular build of the course notes (rather than having to load pages individually into Firefox, and convert them one by one). I'd owe particular thanks to Michael Day, who helped me straighten out my CSS stylesheets so that the online and print versions would look the same.
  5. DrProject is up and running in CSC408 (Software Engineering), CSC488 (Compilers), and CSC494/495 (the project course). Karen Reid and I were very pleased to discover that a significant number of students were creating wiki pages, filing tickets, and generally doing all the things we wanted them to, without being told they had to. We might just be on to something here...
  6. October's Toronto Java Users Group meeting will be held on campus (7:00 Tuesday, Bahen 1180). Hywel Evans will talk about techniques for high performance Java applications; students are welcome to attend. (Remember, you can't ever have too many contacts when you're looking for a job...)
  7. Several dozen students have submitted articles about their Google Summer of Code projects to the series I organized for Doctor Dobb's Journal. The first ones should appear in next month's issue. I'm floored by how cool some of them are, and by how today's undergraduates take globalization as a matter of course. Those of you still ranting about the evils of offshoring, take note: the next generation simply doesn't care.
  8. And speaking of DDJ, the magazine has run two more opinion pieces I wrote (yes, I get paid for having opinions---why else would I have so many?). The first explains why JavaScript may be the dominant scripting language of 2010; the other, why XML configuration files are the Achilles' heel of Java, C#, and other sturdy languages.

In other news, Todd Veldhuizen (who is one of the smartest nice guys, and nicest smart guys, I know) has finally finished his paper on Software Libraries and Their Reuse: Entropy, Kolmogorov Complexity, and Zipf's Law. The abstract says:

We analyze software reuse from the perspective of information theory and Kolmogorov complexity, assessing our ability to "compress" programs by expressing them in terms of software components reused from libraries. A common theme in the software reuse literature is that if we can only get the right environment in place---the right tools, the right generalizations, economic incentives, a "culture of reuse"---then reuse of software will soar, with consequent improvements in productivity and software quality. The analysis developed in this paper paints a different picture: the extent to which software reuse can occur is an intrinsic property of a problem domain, and better tools and culture can have only marginal impact on reuse rates if the domain is inherently resistant to reuse. We define an entropy parameter H::[0,1] of problem domains that measures program diversity, and deduce from this upper bounds on code reuse and the scale of components with which we may work. For "low entropy" domains with H near 0, programs are highly similar to one another and the domain is amenable to the Component-Based Software Engineering (CBSE) dream of programming by composing large-scale components. For problem domains with H near 1, programs require substantial quantities of new code, with only a modest proportion of an application comprised of reused, small-scale components. Preliminary empirical results from Unix platforms support some of the predictions of our model.

There's a lot of math, but it's always fun to watch Todd play fireworks with ideas.