Archive for the ‘Alberta’ Category
Today was the last day of the course, so we spent the morning talking about what had gone well and what had not. The high and low points were:
- The course was fun.
- The TAs were fantastic.
- The format (one hour of lecture plus two hours of lab, twice a day) worked well.
- Enjoyed the parts where the instructors programmed live.
- Liked the emphasis on working practices that complement coding.
- Liked the spread of topics, and the variability of things that are useful in all the different fields.
- Liked the pair programming.
- Welcomed exposure to standard libraries that weren’t necessarily covered in the course.
- Liked the pre-arrival questions about what people knew, were doing, and wanted from the course.
- The examples were good.
- So were the donuts.
- Three weeks is too long.
- Some of the later topics were not as useful.
- Would have preferred to use standard libraries for the image processing lecture and exercises instead of simplified libraries.
- Too little coverage of too many subjects.
- The formatting of the slides leaves much to be desired.
- Too many lectures ran over time (which was particularly hard in afternoon sessions).
- Divided attention in FriendFeed is a problem.
- The less applied stuff (e.g., computational complexity) wasn’t as useful or as interesting.
- Students weren’t given enough time to work on their own projects.
- Didn’t feel encouraged to make suggestions or provide feedback.
- Not enough on shell programming.
- Too much shell programming.
- A/V between Toronto and Edmonton was crude by modern standards.
- More on object-oriented programming.
- More feedback on the students’ solutions to the exercises—they didn’t get the equivalent of grading.
- Put the exercises up before the class, so that students know what the lecture’s going to be leading them to.
It’s been a good three weeks—I enjoyed getting to know the students, and look forward to seeing what they do with what they’ve learned.
Today (Thursday) was the second-to-last of the course. It’s been a long haul, but we hope a rewarding one. In the morning, the students had an hour-long overview of results from empirical studies of real-world software engineering; in the afternoon, we looked at how traditional and agile development processes are responses to those facts. Tomorrow morning, we’ll spend an hour talking about what’s gone right and what’s gone wrong, then head out for a farewell lunch.
And in late-breaking news, one of the students, Mark Tovey, has started a blog on open source cognitive science. Thinking about it now, we should have required all of the students to start and maintain blogs during the course; here’s hoping some will do it now of their own accord (hint, hint).
Yesterday afternoon, the students and ninety other guests were treated to six engaging talks about Science 2.0 from Titus Brown, Cameron Neylon, Victoria Stodden, David Rich, Michael Nielsen, and Jon Udell. We’ll post slides and video here as soon as we get them; until then, you can catch up on what happened in the FriendFeed room or by reading Steve Easterbrook’s real-time blog of the event.
Our thanks once again to everyone who made the day possible:
- MaRS for the space,
- MITACS and Cybera for funding,
- SciNet, Steve Easterbrook, and an anonymous donor for additional sponsorship,
- our student volunteers for taking care of all the little things, and most especially
- Jennifer Dodd for organizing it all.
- Andrew Louis has posted some pictures; we’d be grateful for pointers to more.
- Joey deVilla’s notes and photos from Titus Brown’s opening talk.
- …and from Cameron Neylon’s talk on open notebook science (which are echoed at the MSDN Developer Connection blog)…
- …and from Victoria Stodden’s (which are ditto).
- Jon Udell has some thoughts about LaTeX-in-the-web and user innovation.
- Cameron Neylon discusses both the undergrad student demos he saw in the morning, and the Science 2.0 talks from the afternoon.
- Titus Brown’s impressions.
- Andrew Petersen thinks it’ll be a long time coming.
…but today is bigger than most: after lectures yesterday on server-side web programming and building GUIs, students will spend this morning exploring ways to apply what they’ve learned in the course to their own research problems. This afternoon, we have a stellar line up of speakers from 1:00 to 6:00 pm at the MaRS Centre to talk about how the web is changing the way science is done. We’ll post video of the talks as soon as we can, but if you’d like to follow along in real time, we are:
- Twitter tag: #tosci20
- Friendfeed: Toronto Science 2.0 (http://friendfeed.com/toronto-science-2-0)
Yesterday (Monday) morning we covered the basics of handling binary data, including bit twiddling and the use of Python’s struct module to pack and unpack binary representations of objects. The afternoon was a lightning introduction to how the web works: a simple socket example (just to show students the plumbing) was followed by a description of HTTP’s requests and responses, then a look at urllib. Today is going to be devoted to the absolute bare bones of server-side programming, with GUI programming using Tkinter as a follow-up. “Fast paced” doesn’t even touch it, but I hope students will come away with an idea of what’s possible, and where to look for more information.
XML in the morning, regular expressions in the afternoon—it’s been a long week, but a productive one (I hope). We’re going to shuffle some of the material around so that we can do binary data processing, web client and server programming, and GUI programming next week. The highlight, of course, will be the guest speakers on Wednesday afternoon. I hope the students have a restful weekend; I’m looking forward to the last lap.
I meant to write this post yesterday, but we’re watching Torchwood: Children of Earth, and, well, you know how it goes. We spent two sessions looking at the basics of SQL and relational databases, which almost every scientist is going to encounter at some point in their career. The morning exercises were obviously too easy—students completed them in a little over and hour—but the afternoon seemed to go at the right pace. This morning we’re going to look at XML, and this afternoon at text processing with regular expressions.
This morning’s lecture was a high-level look at software testing, with a long-ish detour into exceptions; this afternoon was an introduction to Python’s unittest framework, with some handwaving about testing that functions throw the right kinds of exceptions, replacing files and other slow objects with mock equivalents, and how you decide what tests to write first. It felt like it went better than yesterday’s lectures on object-oriented programming, which I think left some students a little bewildered. We’re spending tomorrow looking at databases, which means I have to brush up on my SQL tonight…
We took a detour from the notes yesterday morning and built some classes to represent matrices. One reason was to show students how to break a problem down into pieces and solve them one by one; another was to introduce the notions of encapsulation, polymorphism, and inheritance. Aran Donohue (one of the TAs here in Toronto) thinks that inheritance is over-taught, and taught too early—he may be right, but it’s also hard to avoid, since so many libraries and frameworks (and tutorials, but that’s a circular argument) expect familiarity with it.
We looked at operator overloading and (very briefly) at design patterns in the afternoon, then did a modeling exercise. What classes would you create if you were writing a program to simulate solar systems? What would those classes’ responsibilities be, and which classes would collaborate with which others? The most creative solution included Santa Claus; the most complete took collisions and explosions into account.
We started Week 2 with a morning of theory: Francois Pitt, a senior lecturer in U of T’s Computer Science department, gave students a crash course in algorithmic complexity. It’s not something they’ll use every day (or even every week), but if they ever have a conversation with a computer scientist about making something go faster, the odds are good it’ll come up.
The afternoon’s material—the basics of classes and objects and Python—was more immediately practical. As always, I struggled with the fact that you have to know several things before any of them are useful: constructors don’t make sense until you know what objects are, but you can’t build objects without constructors (at least, not cleanly). The students spent the afternoon building simple classes to represent molecules; we’ll spend tomorrow building more classes, then move on to testing and QA on Wednesday.