The Third Bit

I posted a ninety-five second explanation of Software Carpentry on YouTube today. Feedback would be very welcome.

Software Carpentry

Over the next few months, I want to experiment with at least four new learning formats for Software Carpentry. The baseline is what we have now: each topic is covered in 6-10 lessons, each of which has its own page. Most of those pages have a voice-over-slideshow video lasting 5 to 10 minutes and the slides themselves as PNG images in parallel with a transcript of the voiceover; the exceptions are the lessons on spreadsheets, databases, and debugging, which are actual screencasts of the appropriate tools in action. Only a handful of topics have exercises, and the only way to give feedback is to comment on the page.

Here’s what I want instead:

Superficially, it isn’t much different from what we have The “Slideshow” area shows the current diagram, code snippet, or whatever. The “Continuous Controls” (the usual forward, pause, and rewind) control the synchronized slideshow and audio track, while the “Stepping Controls” allow users to move forward and back a slide at a time, and the “Pointmarks” show where slide transitions take place. Finally, the “Transcript” is, as its name suggests, a transcript of the audio that accompanies the current slide.

The big difference doesn’t show up in this diagram. In this version, the slides are not PNG images, an MP4 video, or any other paint-by-pixel format. Instead, they are SVGs stored right in the body of the web page, so that their content is visible to search engines, and can be copied and pasted in sensible ways. This means that if the current “slide” is showing some code, the user can pause the show, select that text, and paste it into her own editor. She can do similar things with the diagrams, i.e., select a cloud, shift-select the caption, and paste them both into her favorite image tool, rather than having to select a rectangular block of anti-aliased pixels that happen to look like lines and letters to a human eye.

I haven’t built this yet, but I think it should be fairly straightforward: each “slide” is a div with a unique ID containing an image and a block of text. The audio is linked from the page; a data-* attribute in each slide div has its start time, and a bit of Javascript shows the right slide at the right time. Marking start times will be a bit tedious—I think it’ll have to be done by hand, at least for now—but it should be easy to allow people to add and view comments and questions in place, instead of tacking them all onto the bottom of the page. And displaying an all-in-one view of the slides with appropriate bits of transcript for printing (or for people who just want to browse) will be easy.

This is just a start, of course. I haven’t said anything about (self-)assessment, which is crucial to real learning, or about accessibility (although I think that having all the code and captions in the page as first-class text will help a lot). I also haven’t thought yet about whether I can build this in just one week, which is about as much time as I have, because there’s one question I should ask first:

If so, I’d be very grateful for a pointer.

Software Carpentry, Teaching

I’m very pleased to announce that the Sloan Foundation has generously agreed to fund six months of work by Software Carpentry and the Mozilla Foundation. You can read more on the Software Carpentry blog; it’s going to be a lot of work, but I’m looking forward to it.

Announcements, Software Carpentry

I’ve spent some time in the last two weeks thinking about what I’ve learned from Software Carpentry, and how to move it forward. I think a lot of the ideas apply to online learning in general; I hope you find them useful.

1. What I’ve Learned So Far
2. Organizing Instruction and Study to Improve Student Learning
3. What Success Looks Like Five Years Out
4. Fork, Merge, and Share
5. Some Responses to Some Comments
6. The Fire Last Time
7. Settings Our Sights a Little Bit Lower

Software Carpentry, Teaching

We all know it’s not true, but it’s still a useful story: if you put a frog in hot water, it will jump out, but if you put it in cool water and slowly boil it, it’ll just sit there, because there’s never a moment when it says, “Wow, this is hot!”

As with frogs, so with computing education. This post on “The Collapse of Computing Education in English Schools” could just as well have been written about Canada, the US, or almost anywhere else. It’s been a crisis now for so long that many of us have stopped really noticing how much trouble we’re in—certainly, I see no sign that the people with the power to change things have this on their “must fix” list.

Which makes this post by Mark Guzdial all the more poignant. iPads in the classroom? It’s the kind of thing that gets someone headlines, but if teaching methods don’t change—radically—it will have just as much (i.e., just as little) impact as all the other tech-in-the-classroom wizardry that has failed us over the past century.

We’re about to start another online run of the Software Carpentry course with almost 100 participants from half a dozen countries. A lot of things didn’t work in last fall’s run; we’re hoping to fix some of those this time around, or at least make different mistakes, so that we can learn a little more about how teaching and the web can be adapted to one another. It may not give school trustees a pile of boxes to stand beside at a photo op, but changing practices is a lot more important than any number of shiny new toys—and a lot harder.

Software Carpentry, Teaching

Details on the Software Carpentry blog, but basically I need a simple folding display for code to do faded examples.

Software Carpentry

Another week, another bunch of posts on t’other site — including a short survey to help us prioritize future lectures, and a plea for help from anyone with graphic design skills who loves isometric game art as much as I do:

• HPC and Programmability
• What Topics are Most Important to You?
• An interview with Michigan State’s Titus Brown (during which no goats were tested)
• A shorter version of the Sets & Tuples episode (for the benefit of those who don’t want the gory details in the longer version posted last week)
• Some web stats
• An interview with Indiana University’s Andrew Lumsdaine
• The last two episodes of the Sets & Dictionaries lecture
• Preliminary survey results (short version: version control, task automation, and data visualization are your top three picks)
• A plea for help with clip art

Software Carpentry

Apologies for falling behind on these updates:

1. An interview with Microsoft’s David Rich
2. The third episode of the regular expressions lecture
3. The fourth episode of ditto
4. A job posting in London, England
5. A three-and-a-half-minute pitch for Software Carpentry
6. A link to a fascinating lecture on genomics by Eric Lander
7. Some musings on small-p patterns
8. A SIAM News article about Software Carpentry
9. The fifth and final episode of the regular expressions lecture
10. The last episode of the lecture on sets & dictionaries (just to mix things up a bit)
11. The violas of programming
12. A pointer to a post by Titus Brown discussing how to combine material from Software Carpentry with other courses — comments would be greatly appreciated
13. A schedule for a one-term run of the course this fall
14. A discussion of the science of learning, and how it impacts the design of the course
15. The first and second episode of the lecture on sets & dictionaries (introducing sets and hash tables respectively)
16. An interview with SciNet’s Daniel Gruner

Software Carpentry

For those who aren’t following along:

1. Testing invasion percolation (June 7)
2. Making invasion percolation faster (June 8 )
3. Reorganizing content (June 9)
4. Interview with Scimatic and a new version of the concept map (June 10)
5. Our introductory database lecture in 8 episodes (also June 10)
6. Thoughts on teaching simple design patterns (June 11)
7. Interviews with SHARCNET and the UK Met Office (also June 11)
8. Measuring the usability of parallel programming systems (June 12)
9. Interview with Queen Mary University of London (June 14)
10. Glossary and license go online (June 15)
11. The first lecture on regular expressions, which is really “is live coding worth it?” (June 16)
12. A question about self-assessment (also June 16)
13. A second try at introducing regular expressions (June 17)
14. The first four episodes of our lecture on spreadsheets (June 18)
15. Our first few self-assessment exercises (also June 18)
16. People you don’t want on your team (June 18 again)
17. Our second lecture on regular expressions (June 19)

Enjoy!

Software Carpentry

The reason this blog has been quiet lately is that I’ve been focusing on getting some Software Carpentry lectures online. I’m pleased to say that the first nine episodes of a lecture on program design are now up, and I’d appreciate your feedback:

1. Introduction
2. The Grid
3. Aliasing
4. Randomness
5. Finding Neighbors
6. Resolving Ties
7. Assembling the Program
8. Bugs
9. Refactoring

I’ve also posted a first draft of a concept map for computational thinking. I’ve complained before that everyone who uses the term means something different by it [1]; this is my attempt to pin down what I mean. Feedback would once again be greatly appreciated.

[1] See, for example, this report on a workshop held earlier this year.

Software Carpentry