Instructor training has been key to Software Carpentry's growth, but it was clear by the time our last online class finished in April that we couldn't and shouldn't keep doing it the way we had been: couldn't because of the time it ate up, and shouldn't because it wasn't doing enough to prepare people for actually teaching.
After five months of thinking, talking, and revising, we finally have a plan for rebooting the course. We are going to run it twice between now and the end of the year: once in the usual multi-week format, and once more compressed into two full days. We are also going to introduce some preparatory requirements, mentoring for new instructors, and mini-lessons to help ease people into organizing and running workshops. Finally, we will start training a few more people to run instructor training so that we can afford to give trainees more personal attention.
The full proposal is included below, and we will be contacting people who have applied for instructor training over the next few days to invite them to take part. I apologize right now for not being able to offer everyone a place right away, but if this reboot goes well—and I think it will—we should be able to start clearing the rest of our backlog soon.
This proposal addresses three issues related to instructor training, and will result in a written description of our instructor training pipeline and a written curriculum for instructor training.
Integrating New Instructors: Many people we have trained have never taught for us, and many who do teach either feel that they don't really know our curriculum, or don't feel truly part of our community.
Satisfying Pent-Up Demand for Instructor Training: Several hundred people are currently on the waiting list for open instructor training, and some have been there for almost a year.
Training Trainers: Prior to May 2014, Greg Wilson did all instructor training and certified all new instructors. Some trainer training events since then have been co-taught with other people, but of these, only two are committed to helping with training events in the future, and their availability is limited by their other responsibilities. That, coupled with the desire of some partners to be able to run instructor training events themselves, and our own desire to eliminate critical dependence on the current Executive Director, means that we need to train people to run instructor training.
An instructor is someone who teaches a workshop. Instructor training (IT) prepares them to do this.
A trainer is someone who teaches people how to teach workshops. Trainer training (TT) prepares them to do this.
Someone who teaches people how to train trainers is a hobbit. We do not currently offer hobbit training.
Proposal: Preparatory Work for Instructor Training
In order to take part in instructor training, we will require people to:
Demonstrate sufficient competence with core tools used in the lessons they will teach. For Software Carpentry, this will mean submitting and revising a pull request on GitHub. Data Carpentry will propose its own prerequisites.
Note: for the Fall 2015 pilot discussed below, we will waive these requirements. Instead, we will pick some participants from the current waiting list.
Watch a short video of someone teaching part of our core lessons and write a summary of what was taught and how. Participants in the Fall 2015 pilot will be required to complete this step, and we will select segments from the videos from SciPy 2015.
The first task ensures that they have the technical skills needed to participate in the course (and in our community); the second ensures that they have seen and thought about how we teach.
Proposal: Open Online Training
We will offer two open (free) online instructor training courses in the fall of 2015: one running over eight weeks (meeting weekly instead of bi-weekly) in October-November, and one running over two full days in early December 2015.
We will select and invite applicants from our waiting list to take part in the multi-week course. They must complete the tasks outlined in the preparatory work proposal by Friday, October 2, in order to take part. (See the timeline at the end of this document.) Trainers-in-training will be required to take part in this class's weekly meetings, and to record and refine what is taught in order to help develop a reusable curriculum for IT.
We will invite groups of 4-6 people to take part in the two-day training course in December 2015; the mentoring subcommittee will select groups from those that apply. The members of each group must be able to co-locate in one room for the two days, and each group must commit to jointly running one workshop within three months of completing training. Each of the instructor trainers in training will be assigned two groups; Greg Wilson will observe and provide feedback to the novice trainers.
Satisfies pent-up demand for IT in our community.
Allows us to compare two different approaches to open online training and get a handle on their true costs.
Allows us to see what effect the requirement for preparatory work has on completion and follow-through rates.
Provides practical training for new trainers.
Provides raw material that those new trainers can turn into reusable IT curriculum.
Gives us coverage in areas that aren't being reached by other training sessions currently planned for partners.
Participants in these courses will not be charged a registration fee, as we wish to see whether the requirement for preparatory work will filter out those who are unlikely to complete or follow through. If this turns out not to be the case, we will explore introduction of a fee starting in 2016.
Proposal: Mentoring New Instructors
After completing the generic IT program (which focuses on educational psychology, instructional design, and general teaching practices), new instructors will be required to complete mentoring on core lessons under the direction of an experienced instructor before actually teaching. For Software Carpentry, novice instructors must complete mentoring on the Unix shell, Git, and one programming language. Data Carpentry will set its own requirements.
Note: we currently propose that instructors must complete mentoring in all three core topics before teaching. Mentoring and certifying them lesson-by-lesson would allow them to teach sooner, but would be a headache to track.
Novices will form groups of 3-4 per lesson. Students will be encouraged to stay in the same groups for all topics in order to build ties with each other. Where possible, each group will include people who know some topics less well than others, so that everyone in each group will have both something to learn, and something to teach.
Each group will have one week to work through each module (or possibly, in the case of large modules like Python and R, two weeks). During that time, they should meet at least twice (online or in person if possible) to discuss their progress. One of these meetings should include their mentor, to check progress and to answer questions. Participants will be encouraged to ask questions of each other when figuring things out, and to take notes to be shared with other novices, their mentors, and the community.
Existing instructors who wish to learn or brush up on specific topics, or who have recently taught those lessons, will be invited to take part in these meetings as well. Where possible, they will be mixed with novice instructors to help integrate people into the community.
Mailing lists, forums, and/or other tools for coordinating groups will be put in place as part of the first round of mentoring. We will use our experience with these to determine the best tooling to use for future rounds.
Mentoring will be organized and run by the mentoring subcommittee; a full description will be published shortly.
A large fraction of people completing IT do not go on to teach a workshop, possibly due to the need for better outreach to hosts to encourage them to request workshops.
To address this problem, we will give new instructors an opportunity to participate in a smaller, guided teaching experience that serves as a stepping stone to a full workshop, and which simultaneously provides potential hosts with a short preview of what a SWC workshop is like. These mini-lessons will avoid many the hurdles of organizing the first workshop alone, such as booking a room and handling registration.
A mini-lesson is characterized by the following:
It should deliver the first few sections of a unit of existing SWC material, to promote instructor familiarity with the material and mitigate additional content maintenance costs.
It should be about 1-1.5 hours in length, and certainly no longer than a full SWC unit.
Instructors are encouraged to deliver it in a familiar setting, e.g., to their research group, as a seminar in their department, or among any group of peers they feel comfortable with.
It should be observed by a more experienced SWC instructor, who will provide feedback and support. Ideally, this mentor should be present during the lesson, but practicality will sometimes require that they watch by video stream.
New instructors (particularly those who have not been helpers in workshops) will be strongly encouraged to deliver a mini-lesson during or after their participation in mentoring (described above).
We will also arrange mini-lessons by experienced instructors on how to set up a workshop, i.e., how to persuade an institution to host one, and the mechanics of actually running it.
Mini-lessons will be organized and run by the mentoring subcommittee; a full description will be published shortly.
Proposal: Training Trainers
We will run a pilot trainer training (TT) program starting in October 2015 in which we will train four people to run instructor training (IT).
These individuals will be trained as trainers subject to agreement that they will only offer Software Carpentry-branded instructor training within the framework that the SCF develops for it. (We require this, rather than conformance to any specific terms, because the terms may change over time.)
Note: this is only a pilot program. We will begin offering TT more generally once it has been completed and evaluated (which we expect will be February 2016).
Gives organizations that want TT a timeline.
Let us find out how much time and effort it actually takes to train a trainer before setting a price for it as a service.
Allows us to focus on developing our mentorship program (which we should have in place before new trainers start producing new instructors).
Ensures that we have a reusable, transferable curriculum for IT by the start of 2016 (since trainers-in-training will be required to help write up that curriculum as part of their training).
This proposal does not fully specify the conditions under which people may run Software Carpentry-branded instructor training. Those must be decided before we start offering TT as a service to partner organizations, but we feel that decision should be deferred until:
the mentorship program is in place,
we know the true cost of TT,
we have had further discussions with the Advisory Council, Data Carpentry, and our community about what they want, and
the new Executive Director is in place.
- 2015-09-10: proposal approved.
- 2015-09-14: invite people from waitlist to take part in multi-week online training.
- 2015-10-02: cut-off date for finishing preparatory work.
- 2015-10-07: multi-week online class begins.
- 2015-11-04: group applications for two-day online class open.
- 2015-11-18: group applications for two-day online class close.
- 2015-11-25: multi-week online class ends.
- 2015-12-07: two-day online class begins.
- 2015-12-08: two-day online class ends.
- 2016-01-04: post-training mentoring for both classes begins.
Multi-week Instructor Training
- Overview and key concepts (ex: live lesson).
- Learner-centered design (ex: task characterization).
- Concept mapping (ex: create concept map).
- Reverse instructional design (ex: multiple-choice questions).
- Active learning (ex: live lesson).
- Motivation and diversity (ex: personal history).
- Organizing and running a workshop (ex: set up a workshop).
- Wrapping up and next steps.
This post originally appeared in the Software Carpentry blog.