University of Toronto on The Carpentries

Workshop Summary: Gerstein Science Information Centre, University of Toronto

Fri, 14 Nov 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Last week we ran a Python-based SWC workshop at the University of Toronto's Gerstein Science Information Centre. The advertised audience was graduate students, post-docs and other researchers in science, engineering and medicine at the University of Toronto.

The workshop had about 20 learners. Most were grad students or postdocs in life sciences. The pre-workshop assessment said that about three-quarters of learners had some programming experience with about half of those having some Python; maybe half of the total had some familiarity with the command line. Almost none had experience with version control or SQL. The instructors were Pauline Barmby, Greg Wilson, and Thomas Guignard; helpers were Sahar Rahmani, Luke Johnston, Daiva Nielsen, Tom Wright, and Fei Xu. Our host was Erica Lenton.

First Homework for Indiana Students (and a few from Ontario)

Thu, 15 Mar 2012 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We ran our first online tutorial yesterday for students from our recent bootcamp in Indiana (plus a few from Toronto). Despite some technical difficulties with web conferencing, we managed to get through some basic image processing. The learners all now have homework for next week (shown below); considering that most of them have little prior programming experience, and only a half day of Python, it's pretty cool that they're able to do things like this.

Toronto Bootcamp February 2012: How We Did

Thu, 01 Mar 2012 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Last week's bootcamp at the University of Toronto was not the most successful one we've ever done: quite a few registrants didn't show up, and based on feedback from the instructors, we tried to cover too much, too fast. That said, the learners who stuck with us all the way through to Friday afternoon came away knowing a lot of useful things (or at least knowing that those things existed). We'll gear back a bit for next week's workshop at Indiana U. and see how that goes.

Successful Bootcamp

Fri, 11 Nov 2011 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Our 2011 Software Carpentry bootcamp, hosted with help by The Hacker Within and Scinet, was a huge success. We hosted 25 students for two very full days of hands on introductions to Python, The Shell, Nose tests, SVN, and sqlite.

So what did we learn? We're still waiting on participant feedback, but a few things come to mind.

First, wow, how did we screw software installation up so very badly? Most of our technical problems can from inconsistencies between various Python builds. Some students installed numpy separately from python and ran into version mismatches. The demo packages were missing from some people's iPython installations (including my own!) That doesn't even mention Cygwin. We got by thanks to the help of the wonderful volunteers who were able to sort out most of the problems, but it's hard to pitch a produce that is that difficult to get up and running. Imagine if we tried to publish papers as inaccessible as our code.

Nirvana on Monday Night

Sun, 06 Nov 2011 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We are running a two-day bootcamp at the University of Toronto tomorrow and Tuesday (Nov 7-8). As part of that, we'll be heading to Nirvana, at 434 College Street (just east of Bathurst) around 6:00 pm on Monday for pints, good food, and conversation. You're all welcome to join us.

2011 Software Carpentry Bootcamp Sold Out!

Tue, 04 Oct 2011 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Software Carpentry is teaming up with The Hacker Within to offer a 2 day bootcamp for scientific programmers on November 7-8. Forty tickets and ten faculty observer slots filled up within two weeks of announcing the workshop on campus.

So what are we going to cover? From what we know, the participants are a diverse group. They include Industrial Engineers, Physicists, Psychologists, and many other departments on campus. One thing they all deal with is data, and often lots of it. Data analysts need a place to store data, so we'll introduce databases using SQLite and version control with Subversion. Data analysts also need programming tools to reformat, clean, and analyze their input. We will spend over half of the time introducing Python, and we'll also introduce the shell.

The Spring 2011 Course Begins

Mon, 10 Jan 2011 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

The spring (or, if you'd rather, winter) run of the Software Carpentry course has started. We have 86 students currently registered. Here is the welcome email we sent out to the students late last week:

Hello,

Welcome to Software Carpentry. I'm Jon, one of the teaching assistants for this course, and I'm joined by TAs Orion Buske, Tommy Guy, Luis Zarrabeitia, and the course creator, Greg Wilson. In this email I'll tell you a bit about how the course is organised.

Feedback and Boundaries

Sun, 04 Apr 2010 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Thanks to the initiative of Dominique Vuvan (who took Software Carpentry last summer), we ran a semi-formal version of the course from last November through to this past week for grad students in Psychology, Linguistics, and a few other disciplines at the University of Toronto. Weekly tutorials were offered in both Python and MATLAB by graduate teaching assistants from Computer Science, covering roughly half of the existing material.

Thanks, Jamie

Sat, 28 Nov 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

The warmup tutorials for our grassroots Software Carpentry course started this week, and we'd like to send a "thank you" to Jamie Winter at The MathWorks, who has provided students with temporary licenses for MATLAB. It's all been very last minute, and we're grateful to Jamie for pulling this off on such short notice.

Tutorials Start This Week

Tue, 24 Nov 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

After a lot of hard work from Dominique and Jon, we're kicking off warmup tutorials for Software Carpentry this week. 65 students from Psychology, Linguistics, Chemical Engineering, and a couple of other departments will get three weeks of review on basic programming, then start the regular material in January. Our thanks to MITACS, the MathWorks, SciNet, and DCS for their support.

Our Target Audience

Sun, 01 Nov 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Some graduate students at the University of Toronto have asked us to run the course for them later this fall or during the winter. There's an obvious selection bias (if they were expert programmers, they wouldn't need this course), but I think they're pretty representative of scientists at their level:

01.	Name	39/39	100%
02.	Email address	39/39	100%
03.	Level of study
	MSc	12/39	30%
	PhD	27/39	70%
04.	Primary programming language
	MATLAB	16/39	41%
	Python	2/39	5%
	Other	6/39	15%
	None	15/39	39%
05.	Knowledge of primary language
	Don't know how to use it	28/39	72%
	Understand basic commands	10/39	26%
	Can program competently	1/39	2%
	Expert	0/30	0%
06.	What other languages do you know?
	HTML	11/27	41%
	R	4/27	15%
	Other (VB, Java, Perl, etc.)	10/27	37%
	No answer	12/39
07.	Would you like pre-class tutorial on
	programming basics (loops, files, if/else)?
	Yes	36/39	92%
	No	3/39	8%
08.	Do you have a laptop?
	Yes	39/39	100%
	No	0/39	0%
09.	Preferred OS
	Windows XP	14/39	36%
	Windows Vista	12/39	31%
	Mac OS X	7/39	18%
	Linux/Unix	9/30	0%
10.	Do you have a MATLAB license?
	Yes	9/39	23%
	No	30/30	77%
11.	Which topics are you interested in?
	Databases	16/39	47%
	Functions and Modules	14/39	41%
	Debugging	10/39	29%
	Image Processing	10/39	30%
	Object-Oriented Programming	10/39	30%
	Web Application Programming	9/39	26%
	GUI Programming	8/39	23%
	Web Client Programming	7/39	21%
	Computational Complexity	6/39	18%
	How Web Servers Work	6/39	18%
	Regular Expressions	6/39	18%
	XML	6/39	18%
	Automated Builds	5/39	15%
	Sets and Dictionaries	5/39	15%
	Unix Shell Scripting	5/39	15%
	Binary Data	3/39	9%
	Empirical Software Engineering	3/39	9%
	Quality Assurance	3/39	9%
	Unit Testing	3/39	9%
	Version Control	3/39	9%
	Software Development Lifecycles	1/39	3%
	Other (please specify)	10/39	30%

Post-Mortem

Sat, 01 Aug 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

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:

Good

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.

Bad

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.

Changes

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.

A Good Afternoon

Fri, 31 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

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:

Day[-2]

Fri, 31 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

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.

Every Day Is a Big Day...

Wed, 29 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

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

Day 11 and Day 12

Tue, 28 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

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.

Day 10 Done - and With It, Week 2

Fri, 24 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

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.

Day 9

Fri, 24 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

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.

Day 7: Lots More Objects

Wed, 22 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

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.

Day 8: Getting It Right

Wed, 22 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

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

Day 6: Theory and Practice

Tue, 21 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

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.

Day 5

Sun, 19 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Day 5 of the course: Paul Lu gave a lecture on Make in the morning, and students had a chance to work on problems of their choice in the afternoon. Of all the tools we teach in this course, Make is the least satisfying (at least to me): the basic concept is simple, and I wouldn't run a project without some automating repetitive tasks, but Make's syntax and limitations are repellant.

Day 4

Fri, 17 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Today was all about the Unix shell: Karen Reid covered a wide range of topics, often using live examples. Some of the students had never used a command-line prompt before, so all of the material was new; others already knew their way around pretty well, but Karen's explanations filled in some gaps and made sense out of what had, for some of them, seemed like arbitrary magic.

Day 3

Thu, 16 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Day 3 of the course—we did sets and dictionaries in the morning (glossing over the handwaving in the notes about computational complexity, since Francois Pitt is going to cover that properly later), and then Paul Gries showed students some basic image processing. Students found the morning exercise challenging, but seemed to be getting lots out of it. The visit to the pub this evening was still quite welcome, though :-). Tomorrow, Karen Reid is introducing them to the Unix shell; we'll let you know how it goes.

Day 2

Wed, 15 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

After three Python lectures yesterday, we slowed down a bit today and looked at a pair of tools every professional programmer relies on: symbolic debuggers and version control systems. Paul Lu covered the former topic using WingIDE; Ken Bauer covered the latter using the SmartSVN GUI for Subversion. Working in pairs seems to agree with the students, though as is so often the case, installing and configuring tools is often more work than actually using them. We'll look at Python's sets and dictionaries tomorrow morning, then Paul Gries will give a quick introduction to image processing in the afternoon.

Aaaand They're Off!

Mon, 13 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We had our first lecture this morning, and the students are working on their first exercises right now in pairs. You can follow progress at http://friendfeed.com/softwarecarpentryjuly2009.

See You Monday!

Fri, 10 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We're all set up and ready to roll! We decided in the end not to record audio or video for this set of lectures, but we'll be posting updates to the lecture notes as we go along. I look forward to meeting our students on Monday...

Registration for July 29 Talks is Now Open

Sat, 04 Jul 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

As part of this summer's run of the course, we have organized an afternoon of public talks from a stellar lineup of speakers. The event is free, but registration is required, and you can now sign up at http://science20.eventbrite.com/. The talks will run 1-6 pm on Wednesday, July 29, and will be followed by a wine and cheese. For details, including speaker bios and abstracts for their talks, see the "Guest Speakers" page.

Topics and Schedule

Wed, 24 Jun 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

A draft schedule for the July 13-31 offering of the course is now available. We'd welcome your feedback: does this order make sense, are there topics we've included that you don't care about, have we left out anything really important (and if so, what should we drop to make room for it), etc.

Note: the draft schedule has been retired. Please see the course outline instead.

Two Spots Left in Toronto

Tue, 02 Jun 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

There are only two spots left for the Toronto offering of the course July 13-31. As announced earlier, graduate students from anywhere in Canada are welcome to aplply, and we can provide up to $1500 in support for travel and accommodation costs for out-of-town students. If you are interested, please contact us.

Topics and Schedule Posted

Wed, 06 May 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We've put up a list of the topics we intend to cover, and the order in which we intend to cover them. It's very provisional; we'll update it regularly, and your comments would be very welcome.

Note: the topics page has been retired. Please see the course outline instead.

Entrance Requirements

Mon, 04 May 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Our rough guide to what students should know before taking this course is now on the prerequisites page. If you don't feel confident you know this material, but still want to take the course in July, please let us know: we're organizing some tutorial sessions in May and June.

Note: the prerequisites page has been retired. Please see the target audience page instead.

We've Started a FAQ

Wed, 08 Apr 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We have started a FAQ [no longer online] for the July 2009 offerings of the course in Edmonton and Toronto. Please let us know if you have any questions that it doesn't answer yet.

Software Carpentry in Toronto July 13-31 2009

Wed, 01 Apr 2009 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Thanks to a grant from MITACS, the University of Toronto will offer the Software Carpentry course as a condensed three-week bootcamp this summer from July 13-31, 2009. This course is an accelerated introduction to software development aimed at graduate students in science and engineering; its goal is to give them the tools and skills they need to use computers more effectively in their research. 16 spaces are available to students registered in full-time graduate programs in Canada; the fee for the course is $500, but grants of up to $1500 for students from outside the Greater Toronto Area are available to help offset travel and accommodation costs. If you wish to attend the course, or would like more information on content, schedule, prerequisites, eligibility, or other details, please contact Greg Wilson by email at {{site.contact}}. Please also subscribe to the new Software Carpentry blog at http://software-carpentry.org/blog/ for updates.

How I'm Doing

Tue, 07 Aug 2007 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

I wasn't happy with the two courses I taught this past winter — too many distractions, too little preparation. The feedback on the Software Carpentry course was therefore a pleasant surprise: I've heard second-hand that several of the Computer Science grad students were disappointed by its slow pace, but overall I did better than I expected. On a 1-5 scale:

Background required to successfully complete the course: 2.0
How easy to obtain details/background to supplement lecture material: 2.0
Did term work increase understanding: 3.7
Material was presented too slow/fast: 2.0
Material was too broad/specialized: 2.9
Workload was too light/heavy: 2.9
How well organized was the lecturer: 4.0 (no idea whose class they were in...)
How satisfied: 4.5
Overall rating: 4.2

The most common positive comments were that the course was practical and pragmatic, and that the collaborative projects were worthwhile. Negatives include the assignment being distributed and marked very late, not enough examples of what good programs actually look like, the course being slow for CS students, a lack of depth in some areas (particularly security), and my jokes being corny.