Teaching on The Carpentries

Our tips and tricks for online workshop teaching

Tue, 01 Mar 2022 00:00:00 +0000

Who we are

We are Alessia, Flavia and Stefania, part of the King’s College London Carpentries Instructor Team. We run regular Carpentries-like workshops on Unix and Git (8 so far, more to come!) and we are here to share some tips and tricks with the community!

Background

Some background first. We teach our workshops online: we started doing so during the pandemic, but we found that the format suited our personal needs, so we are planning to keep them online for the foreseeable future. This also seems to widen accessibility for our participants, allowing extra flexibility (e.g., working from home, childcare, etc.). The Unix workshop is structured in 3 half-day sessions (3 hours each), plus an optional short exercise session (~1 hour); the Git workshop counts 2 half-day sessions plus an optional exercise session. Workshops are normally open to internal participants from King’s College London and the NHS trust, however, we allow external participants in some instances (e.g., Global South collaborations). We aim for about 15-20 participants per workshop (as we have found this to be a manageable number for online sessions), with the three of us instructing plus one or two helpers, if available. We take turns for leading the session (we all have favourite sessions/topics), but we can be flexible to cover for each other should the need arise. The instructors who are not teaching at a given time take care of breakout rooms (for individual help to participants), of questions in the chat, and of taking notes.

Back to the future: Online Carpentries Workshops now and in 2021

Mon, 14 Dec 2020 00:00:00 +0000

On 13 July The Carpentries released a second version of the Official Guidelines for Taking Your Carpentries Workshop Online. The Carpentries Core Team has since then undertaken various initiatives to support remote versions of all Data Carpentry, Library Carpentry, and Software Carpentry workshops.

The quarter in review

The Infrastructure and Curriculum Development teams collaborated in creating an online infrastructure to serve as scaffolds or safety nets for learners who were unable to install software onto their computers using cloud services from MyBinder and RStudio. The workshop website template was also adapted to facilitate workshops scheduled to take place over more than two days which includes a custom schedule file.

Lessons Learned - Data Carpentries Workshop for SADiLaR (August 31, 2020)

Wed, 07 Oct 2020 00:00:00 +0000

Introduction

The call went out for instructors and helpers to cover the Data Carpentries Workshop from 31 August to 4 September 2020. Five instructors and two helpers were selected. We had two instructors from England (Jannetta and Varshita), one from France (Samuel), one from Kenya (Benson), one from Japan (Maggi), and two from South Africa (Marissa and Lactatia).

Preparation for the workshop

The workshop was organised by Angelique Trusler, the Regional Consultant for Southern Africa. Attendees were sent instructions in an email on how to download and install the data and software required. A couple of weeks before the workshop the instructors and helpers were put into contact with one another via email to decide who would do what during the workshop. We used a shared online spreadsheet to indicate which parts we would like to teach and who would be able to act as helpers on what days.

Report from the Mega-Coderefinery workshop

Wed, 26 Aug 2020 00:00:00 +0000

This blog post was originally posted on the CodeRefinery website. In the CodeRefinery project we teach research software engineering tools and workflows, using the Carpentries style.

In May/June 2020, CodeRefinery ran a large online workshop with about 100 learners in attendance. We overcame the challenges with some clever strategies, and we feel the learning outcomes were similar to that of in-person workshops of around 30-40 participants.

After that workshop, some of the same staff held an even larger “High-performance computing (HPC) Kickstart” workshop (180 learners, more than four universities). This provided another perspective and reinforced some of the lessons learned during the large online CodeRefinery workshop.

Geospatial Data Carpentry Videos

Wed, 19 Aug 2020 00:00:00 +0000

TL;DR

Instructors at the University of Wisconsin (at both Madison and Milwaukee) recorded videos of the Geospatial Data Carpentry Workshop They then held discussion sessions over the course of a week to discuss the videos the learners had watched Learners really enjoyed this setup and gave really good feedback. Instructors are still working on setting expectations about the setup better.

The Setup

Since mid-March, when the University of Wisconsin-Madison campus announced it would be temporarily closing, exploring methods for successfully teaching interactive coding workshops has been a continual discussion among our local community of Carpentries instructors. As The Carpentries staff like to say, the transition to online workshops has been a “chopportunity” (challenge-opportunity).

Lessons Learned - Teaching Carpentries Workshop Online UCLA Spring 2020

Tue, 16 Jun 2020 00:00:00 +0000

This blog post was originally posted on the UCLA Library website. As a member of the Carpentries, we offer Carpentries and Carpentries-styled workshops.

Introduction

Between April 10 and May 1, the UCLA Library Data Science Center offered four online 3-hour sections in R programming from Software Carpentry’s R for Reproducible Scientific Analysis. Our usual in-person workshops have a capacity of 30 learners and a typical waitlist of 20. Our attendance for the online course ranged from 30-50 with a waitlist of 250. Our learners primarily consisted of UCLA graduate students in business analytics and social sciences.

Having a Great Online Learning Experience: A Guide for Students

Fri, 24 Apr 2020 00:00:00 +0000

This blog post was originally posted on the Sydney Informatics Hub/Darya Vanichkina’s blog.

With the advent of COVID-19 we’re all having to do the unthinkable, which for an instructor like me means moving hands-on, practical coding workshops online. In this post, I’ll outline a few key things you can do as a learner to have what is hopefully the best possible experience attending synchronous online training.

Mapping & Planning a Live Coding Workshop for Digital Delivery

Thu, 23 Apr 2020 00:00:00 +0000

This series of two blog posts was originally posted on the Sydney Informatics Hub blog here & here, and at Darya Vanichkina’s blog here & here. These posts were written in preparation for an ARDC Community call, where I shared my experience adapting our team’s training for online delivery at short notice. This is what I wanted to get out on the page and not talk about, because in my talk I instead focus on the “bigger picture” aspects of the training (pedagogy, design, on-stage activity and feedback), and on the personal experiences of my team and I. The video/slides of that talk are also available online.

Running University College London's First Online Git Workshop

Tue, 21 Apr 2020 00:00:00 +0000

This blog post was originally posted on University College London’s blog.

Tl;dr: We successfully ran a 3-hour workshop for 11 learners with one instructor and five helpers. We used Blackboard Collaborate as our main tool and shellshare to “look over the shoulders” of the learners.

Our team has been running training workshops since its start. Enabling researchers to make better software is one of our core goals. Most of our training benefited from The Carpentries’ methodology and material. We were early adopters and supporters of those - UCL became one of the first affiliate institutions of the Software Carpentry Foundation.

Lessons Learned from Running Code Refinery's First Online Workshop

Mon, 20 Apr 2020 00:00:00 +0000

This blog post was originally posted on the CodeRefinery website. In the CodeRefinery project we teach research software engineering tools and workflows, using the Carpentries style.

April 7-8, 2020, we gave our first online workshop on introduction to Git (2 x 3 hours) with 22 participants and we plan to deliver many more such workshops on a number of topics based on our lessons.

The workshop went well. Online feels slower, but has a different set of advantages (we discussed later whether we actually covered significantly less than during an in-person workshop and we were not sure the pace was actually slower).

Official Guidelines (V1) for Taking Your Carpentries Workshop Online

Tue, 07 Apr 2020 00:00:00 +0000

On March 17, The Carpentries convened a Task Force to address the urgent demand for remote Carpentries workshops as communities have shifted to distance work across the globe. The Task Force concluded on April 1, with an initial set of guidelines for teaching, supporting, and communicating about fully remote versions of all Data Carpentry, Library Carpentry, and Software Carpentry workshops.

Task force members:

Angelique Trusler (Task Force Lead)
SherAaron Hurt (Workshop Administration Team Lead)
Serah Njambi Kiburu (Community Development Team Lead)
Karen Word (Instructor Training Team Lead)
Juan Steyn (Executive Council Liaison)
Elizabeth Wickes (Secondary Executive Council Liaison)

The guidelines for teaching these pilot-phase workshops now have a home on [The Carpentries website]({{ site.url }}{{ site.baseurl }}/online-workshop-recommendations/). We expect to update these guidelines regularly, and will announce major changes to the community. We also plan to host themed Discussion sessions and, ultimately, to offer short training opportunities for current Instructors who wish to advance their teaching skills online. We do not yet know whether online instruction will become a permanent addition to The Carpentries’ supported workshop offerings – this will be evaluated in view of the feedback we receive once in-person workshops become possible again.

More Community-Contributed Tips for Teaching Online

Mon, 30 Mar 2020 00:00:00 +0000

We recently published a first round on community-contributed tips for teaching online. Today, we are publishing the second and final round of tips from our community members.

As communicated by Omar Khan on TopicBox on 26 March, The Carpentries has now set up a COVID-19 Response Task Force, and a more elaborate set of recommendations will be shared by its members in the coming weeks.

This post has been made possible by contributions from Julie Vecchio, Hanna Varachkina, Darya Vanichkina, Angelique Trusler and two anonymous contributors. Thank you!

Tips for Teaching Online from The Carpentries Community

Thu, 19 Mar 2020 00:00:00 +0000

In The Carpentries #general Slack channel on Friday, 13 March 2020, several community members were discussing different approaches to employ in collaborating online, and specifically around curriculum development and teaching workshops. Lex Nederbragt and Laura Acion had a great thought to consolidate experiences in teaching and learning online from members of The Carpentries community, and share this in a more accessible space for others to read and adapt them for their needs. In the wake of COVID-19 and due to stringent measures taken to help curb its spread around the world, remote teaching and learning is quickly becoming a priority for institutions around the world. Acting on Lex’s and Laura’s suggestions, we put out a call asking The Carpentries community to share from their extensive experience in teaching and learning online.

Incentives and Benefits of Getting Involved in Teaching Researchers

Tue, 18 Feb 2020 00:00:00 +0000

The Software Sustainability Institute believes in the benefits of open development, sharing and collaborating with a community as well as best practices in openness, crediting, citing and developing research software. What are the benefits for instructors of getting involved in teaching computational research skills and these best practices? And why should institutions allow staff to use some of their time to teach their colleagues and get involved in communities such as The Carpentries?

Teaching Tech Together

Mon, 28 Oct 2019 00:00:00 +0000

When I left the University of Toronto in 2010, I needed some way to pay the bills while I figured out what I was going to do next. I had enjoyed teaching programming to scientists ever since the first workshop that Brent Gorda and I taught at Los Alamos in 1998, and if people were willing to fund me to do it again, it seemed like as good an idea as any.

Teaching Statistics in the 21st Century

Tue, 09 Jan 2018 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

The late 1980s saw a wave of new undergraduate programs launched in computational physics, as the advent of affordable workstations and PCs made the power to compute and simulate more accessible. A decade later, though, many of those programs had drastically scaled back their ambitions or quietly wound down. The problem wasn’t the programming: the problem was that whenever a curriculum is designed as “X plus some Y”, it’s the Y that gets cut when time runs short, budgets are squeezed, or tough hiring decisions need to be made. “Computational physics” became “the physics we’ve always taught, but with assignments on computers” and then just “the physics we’ve always taught”.

Fourteen and Counting - People's Favorite Tools

Mon, 08 Jan 2018 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Thank you to all the people who have sent in short posts about their favourite tools. We are up to fourteen now, and the variety of tools is great to see. Finding out what other people use - and possibly more importantly - why they use it, and for what, is a great shortcut for researchers. There are a bewildering number of research tools around. Getting a tip from someone in your discipline, or from someone who is doing a similar task to you, can really help.

People's Favorite Tools

Wed, 29 Nov 2017 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

A big thank you to everyone who has responded so far to the call for short posts about their favourite tools.

So far we have had Paula Martinez on R, with Bianca Peterson enthusiastically seconding, Jeff Oliver sharing his love of Git and GitHub, Kellie Ottoboni talking up IPython, and Thomas Arildsen on how the Jupyter Notebook facilitates his teaching. Juliane Schneider weighed in on the wonders of OpenRefine. Clifton Franklund likes RStudio, while Francesco Montanari is a fan of emacs.

My Favourite Tool: Jupyter Notebook

Sat, 28 Oct 2017 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

My favorite tool is … the Jupyter Notebook.

One of my favourite tools is the Jupyter notebook. I use it for teaching my students scientific computing with Python.

Why I like it:

Using Jupyter with the plugin RISE, I can create presentations including code cells that I can edit and execute live during the presentation to demonstrate the various aspects of Python that I introduce. It is a very good compromise between running scripts and typing in the command prompt on the projector screen vs. just showing static slides with code.

HPC in a day?

Tue, 20 Jun 2017 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Preface

In today’s scientific landscape, computational methods or efficient use thereof can be at the heart of the race for new insights, if not at the heart of the race with the academic competition. Learning how to automate tasks from data analysis to data preprocessing as taught by the carpentries provides the technical concepts to enter this race with an advantage.

If you just graduated a software/data carpentry boot camp and want to go beyond your laptop’s capabilities, the next step in academia is typically to approached the data center of your university or alike. There, a user account application has to be filed for the High Performance Computing (HPC) facilities. After some more formalities, storage and computing time is awarded and you can successfully log into the cluster. And then? Then either our carpenter is given a link to the wiki of the local cluster and how to use it. Sometimes there can be a short course on the mechanics of the HPC cluster and how to use tools that are installed on the cluster. That’s it and good luck.

Instructor Training at Macquarie University

Tue, 20 Jun 2017 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Software Carpentry Executive Director Jonah Duckles and I ran instructor training for new member institution Macquarie University in Sydney on 19-20 June.

There were a few firsts at this workshop - Jonah’s first time as an instructor trainer, my first day in the job as the new Community Development Lead for Software and Data Carpentry, and Macquarie’s first-ever instructor training event.

We may also have had the biggest-ever workshop etherpad, coming in at 1400+ lines, but that would be a tough claim to substantiate. Certainly the eventual size of the etherpad mirrored the deep engagement of attendees, who all worked very hard.

What is the reward for empowering others?

Sun, 14 May 2017 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Following a few round-table discussions with Software Carpentry instructors, I gained some insight into what drives so many of us to volunteer our time so enthusiastically. I came to the conclusion that many of us share a sense of accomplishment when we empower others through mentoring and education. Software Carpentry gives us a fountain-full of opportunities to contibute through community developed lessons, community supported workshops, and world-wide community conversations. We start out volunteering a little when there is time, but we soon carve out more and more space in our schedule for Software Carpentry events and activities that provide the opportunity to empower others.

Plans for Windows Installer

Thu, 04 May 2017 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

In March, we had two email threads on our discuss mailing list related to nano on Windows machines The first thread was about “nano not found”, a bug on our installer that we never managed to trace. The second thread was about some “misbehaviour” of nano on Windows, and the suggestion to use Atom as the default text editor. The suggestion to use Atom started a long discussion where instructors described their reasons to use nano and why Atom is inadequate which lead us to start investigating ways to install nano properly on Windows. On May 3rd, Kate Hertweck, Maneesha Sane, Naupaka Zimmerman, Rémi Emonet and I met online to draft a plan—taking into consideration all of the feedback that was provided in the past month—to solve the problem with nano on Windows.

Software tools for unix shell: Survey and April community call

Fri, 14 Apr 2017 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

The Software Carpentry Code of Conduct includes a somewhat tongue-in-cheek reference to nondiscrimination based on “choice of text editor.” While a choice of software may seem trivial, this particular discussion has led to more than one heated exchange among programmers. In fact, the Discuss list in March was very active concerning issues with the Windows installer, which provides access to the nano text editor through Git for Windows (used in both the Software Carpentry Shell and Git lessons). That discussion eventually transitioned to consideration of alternative software tools we might consider using and moved over to GitHub, where you can read more about the opinions and options voiced by participants.

Teaching Programming to the Blind

Fri, 23 Sep 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Andreas Stefik (who discusses what we know about the usability of programming languages in this entertaining podcast) has worked extensively on computing education and programming tools for the visually impaired. When asked earlier this week how to teach programming to the blind, he sent the response below. We’re grateful for his comments, and for Evan Williamson’s recent pull request to improve the accessibility of our lessons.

Teaching at the Board

Tue, 20 Sep 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

This post originally appeared on Chris Hamm’s personal blog.

Software Carpentry is a non-profit organization that teaches basic computer skills. The lessons for these courses assume no prior knowledge among the learners. I am a certified instructor for Software Carpentry and its sister organization, Data Carpentry.

I have taught two Software Carpentry workshops at the Federal Reserve Board in Washington, DC and they were very different from one another. Both workshops were successful but for very different reasons. This post explores the reasons why (I think) they were so different.

The Discussion Book

Sat, 10 Sep 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Hot on the heels of Small Teaching (which we reviewed last week) comes Brookfield and Preskill’s The Discussion Book. Its subtitle is “50 great ways to get people talking”, and that’s exactly what it delivers: one succinct description after another of techniques you can use in classes or meetings to get everyone talking productively. Each one is covered in three or four pages with the headings “Purposes”, “How It Works”, “Where and When It Works Well”, “What Users Appreciate”, “What to Watch Out For”, and “Questions Suited to This Technique”.

Small Teaching

Mon, 05 Sep 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Elizabeth Green’s Building a Better Teacher changed how I think about teaching, and sparked some good discussion in our community. Therese Huston’s Teaching What You Don’t Know had a similar impact a few years earlier, and now there is James Lang’s Small Teaching.

As its title suggests, Lang’s book focuses on little things that teachers can do right now to improve their teaching, rather than on big, systemic changes that might have larger impact, but which require larger effort (and probably buy-in from other people). To be included, a practice had to:

Ten Ways to Turn Off Learners

Fri, 19 Aug 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

PLOS has published a very useful set of articles called Ten Simple Rules that covers everything from effective statistical practice to winning a Nobel Prize. I’m just as interested in what not to do and what mistakes to avoid, so as part of our instructor training course, I’d like to put together a list of ten simple ways you can turn off your learners. My first five are listed below; if you’d like to add your own, comments would be very welcome.

Showing Changes When Teaching

Mon, 25 Jul 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

A key - but challenging - part of learning to program is moving from writing technically-correct code “that works” to writing high-quality code that is sensibly decomposed into functions, generically-applicable and generally “good”. Indeed, you could say that this is exactly what Software Carpentry is about - taking you from someone bodging together a few bits of wood in the shed, to a skilled carpenter. As well as being challenging to learn, this is also challenging to teach: how should you show the progression from “working” to “good” code in a teaching context?

Teaching Python to undergraduate geoscientists: A summary of our approaches and experiences over the years

Sat, 18 Jun 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

In 2010, a new course commenced at Imperial College London that aimed to teach undergraduate geoscience students how to program in Python. Over the course of five years (2010 to 2014 inclusive) our teaching methodology evolved significantly in response to student feedback and examination performance. The course lecturers (Gerard Gorman and myself, Christian Jacobs) along with several of our Teaching Assistants also undertook Software Carpentry instructor training which offered a fantastic pedagogical insight into how to effectively teach novices how to program. As a result, many of our teaching techniques were influenced by this which helped to greatly improve our course. In this blog post we summarise what we changed throughout the five years and why, in the hope that this will benefit other instructors currently offering, or planning to offer, an undergraduate computer programming course.

Designing a New Novice Python Lesson

Sun, 10 Apr 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Last November, I volunteered to pull together a new full-day lesson on Python suitable for people with no previous programming experience. It has taken longer to come together than I expected, but that’s partly because I saw it as an opportunity to create a full-length example of the “backward” lesson design method we teach in the instructor training class.

What we have so far is in this GitHub repository, which is rendered at this site. We would be very grateful for input: if you think crucial topics have been left out, please say so, while if there’s stuff that could be removed or re-ordered, please say that as well.

Context when teaching Numerical Methods

Thu, 11 Feb 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

As a director of the [Centre for Doctoral Training in Next Generation Computational Modelling](http://ngcm.soton.ac.uk/) I spend plenty of time thinking about, working with, and particularly teaching Numerical Methods. The [general intro course](https://github.com/IanHawke/NumericalMethods) I give is Maths focussed, has around 100 participants, has about 50 contact hours over 12 weeks, and gets a range of interested students from Maths, Physics and Engineering.

The past two weeks I’ve been teaching Numerical Methods for the Centre for Doctoral Training in New and Sustainable Photovoltaics. With around a dozen participants, many of whom had minimal theory or coding background, and only 10 hours available, some changes in the teaching were required. Most of these followed Software Carpentry approaches: live coding, Jupyter notebooks, sticky notes, and a set of “authentic” examples to train underpinning principles.

Correlations

Mon, 08 Feb 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We've run instructor training both online and in person for several years, so it's time to look at how they compare. The raw data shows:

the event's start date
its unique identifier (which we call a "slug")
whether it was online
how many people took part
how many completed training after this course (both as an absolute number and as a percentage)
how many completed after taking a later course (in both forms)
how many have never completed
how many have taught at least once since taking the course

The plot below then shows completion rates and follow-through teaching rates (as percentages) versus cohort size, tagged by whether the training event was online or in person, for all events that took place at least one year ago. (I've used that cutoff to give participants a fair chance to teach after completing their training.) It also shows the absolute number of participants and the follow-through teaching percentage by date.

Come a Long Way, Got a Long Way to Go

Sun, 07 Feb 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

[Simon Oxenham recently reported](http://bigthink.com/neurobonkers/we-need-to-rewrite-the-textbook-on-how-to-teach) on [a new report](http://www.nctq.org/dmsStage/Learning_About_Learning_Report) from the National Council on Teacher Quality that examined how well teacher training courses and textbooks convey evidence-based teaching practices. The sad answer is, hardly at all:

The report finds that out of 48 texts used in teacher-training programs none accurately described fundamental evidence-based teaching strategies comprehensively. Only 15 percent had more than a single page devoted to evidence-based practices; the remainder contained either zero or only a few sentences on methods that have been backed up by the decades of scientific findings that exist in the field of educational psychology.

Software Carpentry as a University Course

Fri, 05 Feb 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

The inaugural Software Carpentry and Data Carpentry Instructor and Helper Retreat is over! It was a long day, packed with tutorials, demos, and discussions. I (Daniel Chen) led a round table discussion with Tiffany Timbers and Jenny Bryan. You can watch the discussion and/or read the notes on etherpad.

18 Months of Progress

Fri, 15 Jan 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

[My talk at SciPy](https://youtu.be/1e26rp6qPbA?t=1748) in 2014 quoted one of our instructors as saying:

The most frustrating things for me are

people are more willing to submit new material…that to improve existing material or review another person’s PR and 2) instructors teaching bootcamps using other lesson material. This experiment in collaborative lesson development is doomed to fail if

people don’t make iterative changes to lesson material and 2) the end product isn’t used in live bootcamps.

18 months later, I’m very pleased by how much better we’re doing. Almost all of our instructors are now using our lessons rather than legacy material of their own. just as importantly, dozens of people have submitted pull requests in the last couple of months alone. Some of those are exercises required to complete instructor training, but others range from minor bug fixes to major refactorings.

A New Book from Mark Guzdial

Wed, 13 Jan 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Regular readers will know that I am a huge fan of Mark Guzdial, a professor at Georgia Tech whose group does world-class work on computing education, and who [blogs about it](https://computinged.wordpress.com/) regularly and incisively. Mark has just [released a new book](https://computinged.wordpress.com/2015/12/23/book-released-learner-centered-design-of-computing-education-research-on-computing-for-everyone/); you can [preview the contents](https://dl.dropboxusercontent.com/u/2635522/LCD-CE-TOC-Preface-Dec2015.pdf) if you want, or just head straight to [Amazon](http://www.amazon.com/Learner-Centered-Design-Computing-Education-Human-Centered/dp/1627053514/) and order a copy.

In it, Mark asks what it means to talk about teaching everyone to program, and whether we should we have the same goals for a mass audience as we do for professional software developers. If not (and he makes the “not” case pretty convincingly), then how do we design computing education that works for graphic designers, high school teachers, and everyone else? His answers are based on both his own experience and his comprehensive knowledge of CS Ed research, and is a solid, readable, and purposeful introduction to the latter. It’s definitely going to be on the reading list for future instructor training classes…

Online Workshops from UC Davis

Tue, 12 Jan 2016 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We have been experimenting with half-day workshops on specialized topics that are broadcast over the web. They have been [going very well](http://ivory.idyll.org/blog/2015-d3.js-annoc.html), so we are planning to do more in the first half of 2016, with about half of them broadcast this way. The tentative schedule is below; all workshops will run 9:15am-12:15pm, Pacific Time. If you would like to present something yourself in one of the open slots, please [file an issue](https://github.com/dib-lab/dib-training/issues) or leave a comment on [this post](http://ivory.idyll.org/blog/2015-training-for-q12-2016.html) --- we think this could be a really good way to field-test new material that Data Carpentry and Software Carpentry instructors could use for more advanced audiences.

2016-01-20: Camille Scott, pydoit - local+remote
2016-01-27: Raniere Silva, advanced git - local+remote
2016-02-17: Tiffany Timbers, regular expressions and Python - local+remote
2016-02-19: Ariel Rokem, scipy.optimize - local+remote
2016-02-29: Adelaide Rhodes, sphinx + webhooks + bitbucket - local+remote
2016-03-07: Titus Brown, Amazon Web Services - local+remote
2016-03-28: Titus Brown, Short-read trimming and quality eval - local+remote
2016-04-06: Daniel Chen, intro git (SWC lesson on git) - local+remote
2016-04-08: Daniel Chen, advanced git (branching and merging, etc.) - local+remote
2016-04-11: open
2016-04-13: Titus Brown, TBD
2016-04-18: Titus Brown, TBD
2016-04-27: Meeta Mistry, TBD
2016-05-11: Marian Schmidt, Rmarkdown - local+remote
2016-05-13: Ted Hart, TBD - local+remote
2016-05-18: Heer group on VEGA - local+remote
2016-06-06: Titus Brown, TBD
2016-06-10: Titus Brown, TBD
2016-06-13: open
2016-06-15: open
2016-06-22: Titus Brown, TBD
2016-06-29: Titus Brown, TBD

Teaching For Loops

Thu, 10 Dec 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

A few days ago, Karin Lagesen asked people what metaphors they use when teaching for loops. It kicked off an entertaining thread. When we talk about pedagogical content knowledge (PCK) in instructor training, this is exactly the kind of thing we mean:

The Morea Framework

Fri, 20 Nov 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

I first met Philip Johnson, a professor of Computer Science at the University of Hawaii, through shared interests in empirical software engineering research and Google Summer of Code. He has recently been developed the Morea Framework for creating structured course websites using GitHub and Jekyll. "Morea" stands for "Modules, Outcomes, Readings, Experiences, and Assessments", which are the five main elements the framework supports. As you can see from the project gallery, it's much more structured than our lessons. It also requires more tooling—Morea Framework sites are built using custom Jekyll plugins, and the source relies much more heavily on include files than our template—and it's geared very strongly toward traditional semester-long courses.

Data Carpentry Instructor Certification for Software Carpentry Instructors

Thu, 12 Nov 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Re-posted from the Data Carpentry blog.

Data Carpentry has been growing over the last year, and now with the addition of Maneesha Sane as Program Coordinator, we have the chance to run even more workshops in more domains. To date, we have used some great instructors from the Software Carpentry community as teachers; what we would like to do now is put that on a more regular footing.

We want to update the instructor records to see who’s interested and qualified to teach Data Carpentry, so we’ve created a Data Carpentry Instructor FastTrack certification. If you have already taught a Data Carpentry workshop, you’re registered as a Data Carpentry instructor and don’t need to go through the FastTrack certification process. If you are currently a Software Carpentry instructor and would like to teach core data wrangling skills to people who are new to computing, this program is for you!

Teaching Bimodal Workshops with a Large Range

Thu, 05 Nov 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Teaching a technical class always has its challenges. Teaching a technical workshop covering 3 or more topics over the span of 2 days is what makes us Software Carpentry instructors.

A common observation instructors have is the class demographics are bimodal/multimodal. There are students who attend the workshop with little to no experience, some have been using the tools we teach but want a more formal course, and finally, a student may know some of the tools, but use the workshop to learn Git or Python, for example. How do we as instructors deal with workshops where the range of student skills is extremely high?

This post is a case study of my most recent workshop and a call for help and discussion about we should do to make our workshops enjoyable for everyone. In many ways it is a complement to Peter and Cam's post Pulling In Those Left Behind.

Thinking About Teaching

Mon, 28 Sep 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

A little over a year ago, we blogged about jugyokenkyu, or "lesson study", a bucket of practices that Japanese teachers use to hone their craft, from observing each other at work to discussing the lesson afterward to studying curriculum materials with colleagues. Getting the Software Carpentry Foundation up and running almost immediately pushed that aside, but now that the SCF is up and running, it's time to return to the subject. Discussion of how teaching practices are transferred is part of that; so are two other developments this week.

Teaching to the Workflow

Tue, 15 Sep 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

"Teaching to the test" has a deservedly bad reputation, but what about "teaching to the workflow"? A group of us came together at the NCEAS Open Science Codefest last year and put together a paper on open science in ecology. In it, we sketch three examples of possible open science workflows (Figure 2 in the paper). In response, I was asked what Software Carpentry should teach to prepare people for working in those ways. My top three things are (in order):

Not Quite Lesson Material

Mon, 14 Sep 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Originally posted on the author's blog.

Lesson plans are a funny thing. The Software Carpentry lessons are an odd balance of a lesson to be read (like a textbook) and a lesson plan for instructors, where they bring the text to life via speaking, live coding, and doing exercises.

This text format doesn't lend itself well to a few activities I've used in Software Carpentry workshops. So I'm going to throw them up here for other instructors to look at - feel free to add your own activities in the comments, or submit another blog post!

How Teaching Knowledge Is Transferred

Sun, 13 Sep 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

I hesitate to say so, but I believe that we pedagogues tend to exaggerate greatly the amount of change in educational practice that results from reading what other people say should be done...

— Stephen Corey, 1951

Being back in Edinburgh thirty years on has occasioned much reflection upon lessons learned. This has occasioned a re-reading of some papers by Prof. Sally Fincher, whose research group at the University of Kent studies the teaching and learning of computer science. In particular, I have been looking at what they have discovered about how educators share teaching practices. I hope these excerpts and reflections are of interest. (Note: section titles link to papers.)

Running a Code Retreat

Wed, 02 Sep 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

I recently attended a scholarship retreat run by Google with about 40 other students. We spent one day doing a "code retreat" and I wanted to share my experience and what I learned about programming.

Better Teaching Practices

Tue, 01 Sep 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

It wasn't part of our original plan, but over time Software Carpentry has come to be about better teaching as much as it is about better computing. In aid of that, I would like to offer the following:

Improving RStudio as a Teaching Tool

Thu, 20 Aug 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

On Twitter, the RStudio support team requested suggestions for how to make RStudio better as a teaching tool. So I've started an issue on their support site for instructors to chime in with ideas. Go ahead and let them know what would make teaching with RStudio easier and better!

Top 10 Myths about Teaching CS

Sat, 18 Jul 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Mark Guzdial (whose blog has been a frequent inspiration) recently wrote an article title Top 10 Myths about Teaching Computer Science:

The lack of women in Computer Science is just like all the other STEM fields.
To get more women in CS, we need more female CS faculty.
A good CS teacher is a good lecturer.
Clickers and the like are an add-on for a good teacher
Student evaluations are the best way to evaluate teaching.
Good teachers personalize education for students' learning styles.
High schools just can't teach CS well, so they shouldn't do it at all.
The real problem is to get more CS curriculum out into the hands of teachers.
All I need to do to be a good CS teacher is model good software development practice, because my job is to produce excellent software engineers.
Some people are just born to program.

Teaching at Monsanto

Sun, 07 Jun 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

As we discussed in April, the Steering Committee decided to run a small number of workshops for companies this year in order to see how our material would work for them, and whether they'd be willing to pay a higher administration fee that we could then use to underwrite workshops for people who might not otherwise be able to host one. The first of these workshops was held at Monsanto, and seems to have gone well: experience reports from two of the instructors are included below, and we hope to repeat the experiment for other companies in the coming months. (If you know a firm that would like our help, please do introduce us.)

Teaching Biocomputing at UT

Wed, 03 Jun 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Becca Tarvin has just posted an article about her experiences teaching biocomputing at the University of Texas. Like last month's report on teaching geoscientists, it's a welcome chance to compare what Software Carpentry does with what's possible in more conventional academic settings. As Becca says in summary:

From student surveys we note that students benefit greatly from our online resources, including cheatsheets, markdown lessons, and example code, and they like live-coding more than PowerPoint presentations. Although it's difficult to keep attendance up over the semester, the students that attend/use the online resources greatly improve their coding abilities. We are working to improve the accessibility of our course to all levels of programmers by offering additional resources including Open Coding Hour and by creating an online forum.

Experiences with Geoscientists

Thu, 21 May 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Christian Jacobs, Gerard Gorman, and Lorraine Craig have written a paper titled "Experiences with efficient methodologies for teaching computer programming to geoscientists" that describes how their intro to computing course has changed over the last few years. It includes discussion of ideas they've borrowed from Software Carpentry, and some data on hwo students have responded. It's a good read, and we'd welcome more experience reports of this kind.

New Members of the Team

Sat, 16 May 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

It's been several months since we last welcomed new instructors to the team. A lot of people have finished training since then, so please say hello to:

The Paradox of Learning Objects

Wed, 22 Apr 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Warren Code recently forwarded this post by David Wiley, a serial innovator in open education and educational reform. In it, he recapitulates the history of "learning objects" and the paradox at the core of the idea of remixing and reusing teaching material. Since Software Carpentry is (sort of) trying to do exactly that, I think everyone who's currently teaching for us or helping us meet our first publication deadline should look it over.

And Now We Are Three

Tue, 17 Mar 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

The four core topics that every Software Carpentry workshop is supposed to teach are automating tasks using the Unix shell, structured programming in Python, R, or MATLAB, version control using Git or Mercurial, and data management using SQL. In practice, many workshops omit the fourth, either because instructors want to put more time into the first three, or because they don't think SQL is relevant to their learners.

The Steering Committee has therefore voted to take SQL out of the core. This doesn't mean that it can't or shouldn't be taught: it's still useful for many researchers to know, and the best way we've found to introduce key ideas in data management like atomic values, keys, and how to handle missing information. However, if instructors and learners would rather cover something else, they can do so.

Teaching Tips

Sun, 15 Mar 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Last week's post on what's in your bag generated so many useful comments that we'd like to follow it up with another: what tips do you have for new instructors? The ones we've collected so far are listed below; please tell us what else we should tell people who are about to teach for the first time (and what else we should remind experienced instructors about).

What's In Your Bag?

Wed, 11 Mar 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

What do you have in your knapsack when you travel to teach a workshop? My list is:

Ten More Instructors

Mon, 02 Mar 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

It's a pleasure to welcome another ten instructors from the Southern Hemisphere to our team:

Eleven New Instructors

Sat, 28 Feb 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

It's a pleasure to welcome another eleven instructors to our team:

Improving Instruction

Fri, 27 Feb 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

It's been quite a year for Software Carpentry instructor training: we had a great session at UC Davis (see also this excellent post from Rayna Harris) and another at the Research Bazaar kickoff in Melbourne. We've also started the twelfth round of online instructor training with 75 participants, making it our largest yet.

All of this has led to a flurry of activity in our GitHub repositories. The comments and pull requests are very welcome, but we need to keep three things in mind:

We already have more material than we can cover in two days.
We are not our learners.
No lesson survives its first presentation intact.

Welcome Our Newest Instructors

Tue, 03 Feb 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

It's a pleasure to welcome another eight instructors to our team:

Nouns and Verbs

Mon, 02 Feb 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

I've spoken and written many times about how puzzled I am that massive, open collaboration on lessons is so rare in the age of Wikipedia and open source software development. Hundreds of people have helped build the Wikipedia articles on Marvel Comics and the planet Mars, and hundreds more have helped build things like the Django web programming framework; why then are teachers still writing all their own slides and handouts?

As is frequently the case, the answer might be that I've been asking the wrong question. When I brought this up last week in an online call organized by the Open Knowledge Foundation, Phil Barker said:

"One difference between Wikipedia and OER [open educational resources] is that editing Wikipedia is about moving to consensus on facts, [but] editing teaching material is about tailoring it to specific local requirements (different teaching styles, different students, different curriculum standards)."

The Other Ninety Percent

Sat, 24 Jan 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Ninety percent or more of learning a skill takes place outside formal lessons as people try things out for themselves and turn attention into habit. This works best if a mentor is on hand to answer questions and provide feedback, but our workshop format doesn't lend itself to that: in most cases, our instructors are back on a plane (or back in their own lab) as soon as they're done teaching, so our learners have to make sense of what they've just been shown on their own. Based on follow-up discussions and Jory Schossau's work, here are things they stumble over in order of increasing pain:

Welcome Our First New Instructors of 2015

Sat, 24 Jan 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

One of the best parts of this job is welcoming new instructors to our team. Many of this year's first group have already helped with workshops, and I hope to have a chance to teach with all of them before too long.

Improving the Balance

Thu, 22 Jan 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Jennifer Martin's recent article "Ten Simple Rules to Achieve Conference Speaker Gender Balance" reminded me that while we've been reporting the number of workshops we've run, and the number of people who've attended, we haven't reported the gender balance among our instructors in a while. I did a quick check, and the result was sobering. From a high of almost 30% eighteen months ago, our instructor pool is now only 18% female. It seems that as we grow, we are regressing to computing's unfortunate mean: from a higher of 38% in the early 1980s, the proportion of computer science degrees awarded to women has dropped to 15-18%, and CS is the only STEM discipline where the gender balance has actually been getting worse over the past few decades.

Welcome Aboard

Tue, 23 Dec 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

A lot of people qualified as instructors this fall and winter, thanks in part to the live sessions we ran in Charlottesville, Norwich, and Seattle. They join the 86 other people who received their badge this year; we look forward to seeing them all run workshops before 2015 is over.

What About MOOCs?

Tue, 02 Dec 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We frequently get asked whether Software Carpentry would work as a MOOC. The answer is that I think it can work well if it's what Siemens and Downes actually had in mind when they coined the term. They didn't people watching videos and then doing robo-graded exercises; instead, their connectivist model of learning assumed that participants would use the internet to collaborate in exploring ideas, rather than as a faster form of television.

I'm definitely excited about the Siemens and Downes kind of MOOC. In particular, I believe that instructors who don't have time to teach a full workshop might give us an hour a week to help people via one-to-one or one-to-few sessions via Skype and screen sharing. There was a lot of enthusiasm among the instructors for this when we tried it in the spring of 2012; that experiment wound down because we lacked critical mass, but we're five times larger now, and I think it would be worth trying again.

The most interesting question for me is where this fits. Should we start people off this way? Should people do the first day in person (so that we can get them through software setup and configuration issues), then do the rest online? Should this be used as the "day 3" follow-on that everyone keeps asking for? We'd like to try all of this and more; if you'd like to help, please let us know.

Ongoing Learning with User Groups

Mon, 10 Nov 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

For the past two years I've run the UC Davis R User's Group (D-RUG). In this post, I'll (1) outline the structure of D-RUG, (2) summarize some lessons learned, and (3) discuss how such users' groups could act to support and complement SWC's workshops.

You Should Read Juha Sorva's Thesis

Thu, 06 Nov 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

If you really want to dig deeper into educational research and how it applies to teaching programming, you should grab a copy of Juha Sorva's PhD thesis. The UUhistle system he built is interesting, and the research he did with it is thought-provoking, but what's really great is the summary of educational research in the first third of the thesis. I've extracted that part with his permission, and I can't recommend it highly enough.

A 'Joel Test' for Grassroots Programming Groups

Tue, 04 Nov 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Back during the first dot-com bubble, Joel Spolsky wrote an article titled "The Joel Test: 12 Steps to Better Code" that listed 12 questions you can ask to estimate the maturity of a software development team:

Revamping the Instructor Survey

Sun, 02 Nov 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

In September, Greg Wilson wrote a blog post on "building better teachers" that was inspired in part by an issue brought up by John Blischak on reporting time spent on lessons. In order for us capture this information, we decided to revamp our post-workshop instructor survey.

Particle Physicists Pulling Themselves From The Swamp

Fri, 31 Oct 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

What does it mean to work on a modern particle physics experiment like ATLAS (wikipedia, public) or CMS (wikipedia, public) at the Large Hadron Collider in the 21st century? It's fun, it's collaborating with great and interesting people, it's challenging, it's making you enjoy finding things out, it's what I always wanted to do. Also: it is painful, discouraging, and tends to suck the life out of a young mind. Confused? Let's rewind...

Why We Don't Teach Testing (Even Though We'd Like To)

Thu, 30 Oct 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

If you haven't been following Lorena Barba's course on numerical methods in Python, you should. It's a great example of how to use emerging tools to teach more effectively, and if we ever run Software Carpentry online again, we'll do it her way. Yesterday, though, when she posted this notebook, I tweeted, "Beautiful... but where are the unit tests?" In the wake of the discussion that followed, I'd like to explain why we no longer require people to teach testing as part of the Software Carpentry core, and then ask you all a favor.

Lost in Space

Mon, 27 Oct 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

You probably haven't seen the 1998 movie Lost in Space, or if you have, you've suppressed the memory—it was awful. But I do know one guy who enjoyed it. His name was Joe, and he had worked on the software used to create its special effects. Ten minutes into the film he took out his Walkman (a primitive form of iPod), put on his headphones, and spent the next two hours head-bobbing to a mix of Bob Marley and Smashing Pumpkins.

Welcome More New Instructors

Thu, 16 Oct 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We are very pleased to welcome another new batch of instructors to our team:

A Self-Recorded Workshop

Tue, 14 Oct 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Among the many great lessons contained in Greg Wilson's recent post on building better teachers, perhaps one of the most important was that in order to improve our collective teaching standards, we really need to see each other in action:

Ideas to Improve Instructor Training

Sun, 05 Oct 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Have you ever learned something new and then had it appear in other areas of your life? After a summer at SWC thinking about how to train better instructors (and how to be a better teacher myself) I get to try discussion-based teaching this quarter at UC Davis.

Welcome Our New Instructors

Fri, 03 Oct 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We are very pleased to welcome a new batch of instructors to our team:

UCOSP as a Model

Sun, 28 Sep 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Software Carpentry's two-day workshops are just one of many ways to teach people practical skills. Term-long group projects are another model that I'm very fond of, and earlier this year, the four people who've been running the UCOSP program in Canada wrote a paper about what they've learned. Some of the lessons rhyme with what we've learned from Software Carpentry, but other insights are new. If you know of papers describing lessons learned from other innovative teaching projects, pointers in the comments section would be very welcome.

Learning Goals

Tue, 23 Sep 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

A few weeks ago, Greg Wilson asked me how to better express the learning objectives listed in the Software Carpentry lessons. My main concerns with the existing goals are that they focus too much on specific skills, rather than attitude changes, and is that they are generally stated as lesson descriptions (more like instructor goals or a lesson outline) rather than as learning goals for participants.

Videos from Stanford

Fri, 12 Sep 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Stanford University has posted videos from the Software Carpentry workshop held there in August featuring Azalee Bostroem, Chris Lonnen, Dani Traphagen, and Chris Beitel. These are a great place to start if you'd like to do a little informal jugyokenkyu.

Our thanks to Amy Hodge and Stanford University for making these available.

Further Thoughts on Building Better Teachers

Wed, 10 Sep 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

On Greg's recommendation, I just finished reading Building a Better Teacher - it was an interesting book, and a well-written story. It turns out that I completely agree with Greg's assessment of the book's lessons and the challenges facing Software Carpentry, but I very much disagree with his proposed solutions!

More Thoughts on Better Teachers

Wed, 10 Sep 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Over the last few weeks I read Greg's blog post on Building Better Teachers and watched his Scipy keynote and I've been thinking a lot about how can instructors share their knowledge.

Building Better Teachers

Thu, 04 Sep 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Some books are intrinsically great. (I've read Going Postal half a dozen times, and enjoyed it just as much at each encounter.) Other books feel great because they hit you at the right time. Elizabeth Green's Building a Better Teacher is one of those: in a little over 300 pages, she takes a bunch of things I've been worrying about for the last two years and assembles them into a coherent whole. The end result is a road map of sorts for making our teaching more effective; the problem is, I don't know if it's a path we can actually follow.

The Fifth ANGUS Course

Thu, 21 Aug 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Titus Brown recently blogged a summary of the fifth run of the Analyzing Next Generation Sequencing (ANGUS) course at Michigan State. It includes some interesting observations on what's working and what needs to be improved, and some thoughts on assessment—he'd welcome feedback.

Conversations About Teaching

Mon, 18 Aug 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Over the last few days, there have been four related discussion threads on the Software Carpentry mailing lists about what we use, what we teach, and how we teach it. Together, they highlight what we're doing well and where we need to do better.

Fixing 14 Repositories

Sun, 15 Jun 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We cloned our workshop repository at the beginning of the workshop at Spelman to give everyone an identical directory tree and contents to explore, and to distribute the sample data files. On the first day of our workshop, about a third of the learners (all running Windows) could not clone the workshop repository: git clone was failing for them with the error:

Wise as Athena...

Thu, 01 May 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Katy Huff has written an article for the Berkeley Science Review about our recent bootcamp for women in science and engineering in California. It's a good summary of what Software Carpentry is all about as well—please check it out.

Import Lesson

Wed, 23 Apr 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Lorena Barba has done it again. Having created a wonderful 12-step introduction to the Navier-Stokes equations using the IPython Notebook, she has now published AeroPython, which teaches the use of potential flow for aerodynamic analysis via the panel method. You don't have to know what that is to appreciate the beauty of what she has built—I certainly don't, at least not yet—but I'd like to explore something that isn't in those notebooks. Before doing that, though, I need to introduce an acronym that never caught on.

Mr. Biczo Was Right

Wed, 23 Apr 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

I didn't have nearly enough time to enjoy everything that was going on at PyCon 2014 last week. One event I particularly regret missing was a sprint organized in part by the folks at Scrapinghub. They got a bunch of people to write little scrapers to go through old conference websites, pull out speakers' names, and run them through a gender identification library in order to plot changes in gender balance per conference over time. The code is all available on GitHub, and Gayane Petrosyan (currently at the Hacker School in New York City) has started plotting some of the results.

Do Not Be Worried

Wed, 16 Apr 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Sage advice for our instructors and learners from an eight-year-old:

Summarizing Our Instructors' Skills

Tue, 15 Apr 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We've been asking bootcamp participants to tell us about themselves for a while now, so it seems only fair to share some information about our instructors. First, of the 82 instructors who responded to our survey two weeks ago, how many are comfortable teaching which topic to novices, to intermediates, or not at all?

Uniting the Narrative

Fri, 04 Apr 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

The Victoria workshop that just wrapped a few hours ago was my first stab at teaching SWC live, and I have to say - few things feel better in teaching than the tiny victory of having material that is right on pitch. I've had the lurking notion for years that the hilariously overshot lectures ('I need to cover the syllabus in half time so I can go on sabbatical'), conference talks ('One slide per 30 seconds for a solid hour seems reasonable') and lab presentations ('A 5 by 5 grid of histograms on one slide will communicate ALL the science!') were the tragic offspring of time constraints and one-upmanship, and in desperate need of a pan-academia slide deck disarmament treaty. I always pushed my students to strip it down, just hit the highlights and leave the details for the paper, because I always suspected that that little bit of entertainer's savvy was how we could really reach people: not by fact-bombing the audience into a glassy torpor, but by electrifying their curiosity just enough that the energy that propelled them forward was their own.

Updating Our Checklists

Sat, 29 Mar 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We have updated our checklists for bootcamp administrators, hosts, instructors (and lead instructors), and helpers. Further improvements are welcome, and we'd appreciate comments on this post suggesting items we could put in a checklist for learners.

Changing Our Core Curriculum

Thu, 27 Mar 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We currently say that people must teach task automation, structured programming, version control, and unit testing in order to use the Software Carpentry name. However, many bootcamps either don't teach unit testing at all, or only cover it briefly, while many of us teach data management using SQL, which also seems like a core lab skill for scientific computing. We asked instructors this week whether we should formalize the change, and they responded as follows:

Empirical Software Engineering Papers

Wed, 19 Mar 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

When I teach scientists programming, I frequently cite empirical studies in software engineering to back up my claims about various tools and practices making people more productive. No good, short survey of those papers exists—writing one has been on my to-do list for several years—but I hope the pointers below will be a useful substitute.

Collaborative Lesson Development - Why Not?

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

This post originally appeared on the Software Carpentry website.

A few weeks ago, Greg Wilson asked me:

Why is there so little open, collaborative development of lesson plans and curricula? Is there something that makes teaching different from coding (e.g., open source software) and from writing (e.g., Wikipedia)?

A dozen emails later, I can't claim that we're much closer to a definitive answer, but we have come up with a working hypothesis. We'd be very interested in feedback.

A Workshop for Librarians at PyCon

Tue, 04 Mar 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We are very pleased to announce that we will be running a two-day workshop on programming skills for librarians during the PyCon sprints in Montreal on April 14 and 15, 2014. The workshop will introduce participants to core skills for managing and manipulating data, including task automation, version control, modular programming, and databases. The event is open to everyone, not just to PyCon attendees; please see this page for more information, register here, mail us if you have any questions, and help spread the word to your friends and colleagues.

Learn How to Teach People to Program

Tue, 04 Mar 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We are very pleased to announce that we will be running two one-day workshops on how to teach programming during the PyCon sprints in Montreal on April 14 and 15, 2014. The workshops will be led by Greg Wilson, who will show participants how to use basic concepts from educational psychology and instructional design when teaching beginners how to code. The event is open to everyone, not just to PyCon attendees; please register here, or mail us if you have any questions.

Why Not a MOOC?

Sun, 19 Jan 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We got mail yesterday asking us whether we were going to run Software Carpentry as a MOOC. The short answer is, "No." The full answer has several parts:

From 0 to 1 to 10

Wed, 15 Jan 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Andromeda Yelton has written a great blog post about her experiences teaching a bootcamp for librarians in Toronto earlier this week. It includes this insightful observation:

It's Not Just the Tools that Differ Between the Two Cultures

Fri, 10 Jan 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

In the conversation that followed Philip Guo's blog post on the two cultures of computing, most on focused comparing the tools used by those two cultures, as discussed by Philip to create a contract. Some even wondered if Software Carpentry instructors should perhaps become more versed in MS Excel to meet potential students where they are. In so doing, we lost the fact that even with the same tools, the two cultures would likely use them differently. It's not about the tools, but about the users.

Mental Models and Vicious Circles

Tue, 07 Jan 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

A few days ago, Konrad Hinsen asked this on our discussion list:

Is anyone aware of teaching methods that aim at either developing or verifying the students' mental model of some non-trivial procedure? If so, have they been used for teaching the use of computers?

We Need More of These

Tue, 07 Jan 2014 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Michael Nygard's Release It! is one of my favorite books about the practical side of computing—I gave it five stars when it first came out, and while it's too advanced for most of the scientists we want to teach, there's something from it that I'd like to share: the diagram titled "Interaction of Patterns and Antipatterns" from page 43:

Curriculum Design

Mon, 14 Oct 2013 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

I spoke with three different people about curriculum design last week, so this seems like a good time to summarize what I know about doing that properly, how we've actually been doing it for Software Carpentry, why the two are different, and what we hope to do in future. To set the stage, I need to talk about the medical program at McMaster University in Ontario.

Bootcamp Student Composition by Domain

Mon, 30 Sep 2013 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Recently I was challenged to show that computational science is important to biologists, and, more importantly, that biologists care about learning how to develop quality software. I am not a biologist. While I find the subject fascinating I cannot make any broad claims on the topic or hope to speak for all biologists. So I turned to Software Carpentry.

My experience teaching Software Carpentry and related bootcamps has been that biologists are always a significant portion of the student population. In order to demonstrate this I asked to have access to anonymized answers to part of the pre-assessment survey. Specifically, I was interested in the "Which of the following most closely aligns with your primary discipline?" question. With a big assist from Amy Brown I obtained the data I was looking for.

Scientific Computing at AIMS

Sun, 15 Sep 2013 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Close on the heels of another bootcamp in Madison, WI, for the past two weeks I had the pleasure of teaching a 30 hour scientific computing course at the African Institute for Mathematical Sciences (AIMS) in Cape Town, South Africa. The course was an expansion and refactor of Software Carpentry material to fit the AIMS need. You can find the repository of source material here.

I could gush about how I fell in love with Cape Town, the unexpected preponderance of vegan cafes in Muizenberg, the sea, the sand, the mountains, and la dolce vita I am otherwise used to from Santa Barbara. I will not. AIMS is about the students. Let's examine them after a brief tour of AIMS itself.

More Tips

Tue, 06 Nov 2012 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Philip Fowler, who recently hosted a bootcamp at Oxford, has written a 5-point guide for people who are thinking about doing it themselves—we hope you'll find it useful.

Maintaining Correctness

Sun, 11 Dec 2005 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

I'm re-thinking the lectures in the Software Carpentry course based on feedback from this term's students. I'm going to merge the three lectures on different development processes into one, and use the space that frees up to talk in more detail about programming style and software design—assuming, of course, I can think of something to say that isn't banal.

I also want to talk about the material in an article by Paul Dubois in the May/June 2005 issue of Computing in Science & Engineering called "Maintaining Correctness in Scientific Programs". Here are a few key lines from the introduction:

Day 9

Tue, 20 Sep 2005 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Week two of Software Carpentry, and things are starting to settle down. There are now 93 (!) people signed up for the course:

	U of T	Elsewhere
Auditing	18	21
Enrolled	25
Unknown	29

Of those actually at the University of Toronto (as opposed to the
local hospitals—a few radiologists are sitting in) the breakdown
is:

16	Computer Science
14	Physics
9	Civil Engineering
	Mechanical and Industrial Engineering
5	Biochemistry
	Institute for Aerospace Studies
2	Institute of Medical Science
	Mathematics
1	Astronomy
	Biomaterials and Biomedical Engineering
	Botany
	Geology
	Medical Biophysics
	Zoology
	Non-degree student

This week's lecture went much more smoothly than last week's, in part because we were in a larger room, with seating for everyone, and in part because the content was an introduction to Python, which I've given more times than I can count. There were still some glitches in the slides, though: a few things were out of order, and I really do need to choose more concrete examples. 33 students have completed the first exercise, which is already more than I'd expected—I'm feeling uncharacteristically optimistic right now ;-)

Software Carpentry: First Meeting

Wed, 14 Sep 2005 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

The Toronto edition of the Software Carpentry course met for the first time on Monday. 51 people crammed into a room with seating for 34 (and no air conditioning, on an unseasonably warm day): medical biophysicists, computer scientists, civil engineers, and even a couple of faculty members.

I was pleased with the turnout, but less pleased with my lectures. I don't think my introduction to the shell made sense to anyone who didn't already know the content—it was far too long, and as Andy Lumsdaine (who's teaching from these same notes at Indiana) said, this stuff really does need to be interactive.