Around the world, education systems are moving computing into primary and secondary schools. Whole nations (e.g., England and Denmark) and individual U.S. states are trying to figure out how to teach computing to students in K-12. A recent Economist editorial highlights the biggest challenge to getting computing into schools: how do we get enough well-prepared computer science teachers?
The first part of answering that question is "who are we starting with?" In Israel, the Technion is preparing high school computer science teachers starting from graduates with degrees in STEM. The Computing at School effort in England is working to prepare existing Information and Communications Technologies (ICT) teachers to teach computer science. Here in the United States, we are mostly preparing Business teachers to teach computer science, because Computer Science is classified as Career and Technical Education in most U.S. states, and CATE teachers have business teaching certifications.
A related question is: "what do we need to prepare the teachers to do?" Sure, teachers who have an undergraduate degree have the content knowledge. ICT teachers may know something about computing, but may not know CS. Existing teachers know a lot about running classes, but may not have the computer science background. Best possible world is to have teachers who know CS content, teaching practices, and specifically how to teach CS, but the reality is that we will have to prioritize. What does it take to be a successful high school computer science teacher?
When we were working on teacher professional development in the early days of our "Georgia Computes!" project, our external evaluator (Tom McKlin) interviewed a set of high school teachers of Advanced Placement Computer Science classes. He grouped the teachers in terms of more successful teachers (e.g., were able to recruit more students into the AP CS course, had a high pass rate of students on the AP CS exam, and were confident and satisfied with being an AP CS teacher) and less successful teachers. The interviews give us some insight into what we want high school CS teachers to be able to do, and what's less useful.
The below quotes were both in response to a question about how the teacher prepared students for the AP CS exam.
Everything in that class is more or less an assessment. They’re supposed to read certain sections in the book, and then they have quizzes over the reading. After they do the reading assignments, they have Gridworld case study quizzes and also Gridworld case study segments of code that they will go in and manipulate to change to get the things in the Gridworld case study to react different ways. Those are pretty much graded as labs or programs or quizzes.
What the teacher in the above quote is describing is pretty much what you'd expect any high school teacher to do when teaching pretty much anything. There's a heavy emphasis on assessment and reading. This is one of our less successful teachers. Teaching computer science the way you might teach any subject generically might not be enough for learning computer science.
And then if I read these [student quizzes], I can see any misconceptions or gaps in what I’ve done. I get a picture in my mind of where the current class is. Making them do the explaining is new this year. I’m seeing them do a lot better there. I‘ll do like little code (assignments) that they’ll write once a week. They have to write it by hand away from the computer, and I’ll read that and write them comments on what they’re doing and help them grade it with a rubric, and also pass them back after I’ve read them for them to grade, too, and have them look at what was catching it or where it didn’t quite get to it.
This is a response from a more successful teacher. We see a lot of CS-specific teaching techniques: students explaining their code, writing code by hand away from the computer (as well as at the computer), and self-grading of code by rubric. Teaching computer science is not the same as teaching any other subject.
Particularly interesting to me is what the teacher is doing in each of these quotes. The first teacher makes assignments. The second teacher talks about creating assignments and rubrics, but she also reads student quizzes, and reads and comments on student code. None of our successful teachers ever talked about writing programs. They probably did some of that, but it wasn't a big part of what they did.
That's a big difference from what we teach computer science majors. The latest ACM/IEEE computer science curriculum standards highlight that we expect graduates to be professional software developers who use good engineering practices. A teacher who has software development knowledge and skills certainly would know how to read and comment on student code -- but that's a small part of what we teach people to do as software developers.
Studies like these give me hope that we can provide professional learning opportunities to existing teachers without trying to turn them into software developers. We mostly need to teach computer science teachers to read code. Raymond Lister has done a lot of research exploring the developmental path from being able to read and trace code into being able to write code, and his results suggest that reading and tracing precedes code-writing skills. It should be easier to teach reading than to teach software development.
Can we teach teachers to read and comment on code without teaching them to be software developers? Can we teach reading code more efficiently (less time, less cost) to a broad range of teachers (e.g., business teachers who may not have a strong math and science background) than we could teach software development skills to those same teachers? These are important questions to answer in order to be able to prepare enough high school computer science teachers worldwide.
By the definition given here, I am a reasonably successful computer science teacher. The ability to read code and quickly determine what is wrong is valuable for another reason. While students are working on a program in the computer lab, they will get stuck and need assistance. If I am able to quickly determine a students' error and point him or her in the right direction, I can help a number of different students within a class period. If it takes me 5 minutes to find out where a student went wrong, then other students may get frustrated while they wait for assistance. Quickly helping students debug their code is more important at the beginning of the course, but remains important throughout.
While I think we are correct in identifying the importance of reading code, I don't think this paves the way to a simplified path for qualifying teachers. It is impossible for a teacher to help students acquire a skill that he or she does not posses. If we want computer science teachers to help students learn how to write programs, these teachers need to learn how to write code themselves. In practice, they may spend more time reading code than writing it, but that doesn't mean teachers do not benefit from writing code themselves. Teachers of computer science need to experience the pleasure of seeing code that they have written work. They need to experience this so that they can communicate that enthusiasm to their students. This doesn't mean that they need to become software developers, but it does mean that they need to acquire some code writing skill.
I completely agree that teachers of computer science need to write some code. I also strongly agree with you, "Teachers of computer science need to experience the pleasure of seeing code that they have written work." But how much? How much of computer science can we teach *without* writing code? How much do teachers need to write in order to develop confidence, to feel that pleasure, and to understand what their students will be doing? I predict that that's far less than the amount of code we ask CS majors to write. These are open research questions that are interesting and worthwhile trying to answer.
Displaying all 2 comments