Gas station without pumps

2013 July 1

How can we get more programming taught in high schools?

In the comments on Mark Guzdial’s post Why AP CS:Principles is a good thing: Responding to Gas Station without Pumps (which is a response to my post Millions for a fairly useless new test), an interesting question has arisen: What should a CS teacher know?

I commented

I agree that figuring out what content an intro CS teacher needs to know is important, both in depth and in breadth. If we set the bar too high, there will be no CS teachers in public schools (essentially the current situation). If we set the bar too low, no CS will be taught and we’ll have to undo the damage once the students get to college.

CS as a field is still struggling with how to teach beginners (it is pretty clear that some students learn, but it is not clear to me how much this correlates with what teachers do—but that’s your [that is, Mark Guzdial’s] area of expertise, not mine).

Defining the core competencies that a beginning instructor of beginning students needs seems to me quite difficult. I suppose it starts with deciding what the students need to learn, then figuring out what the teacher needs to be able to do to get them there. I further suppose that this is the intent of the CS Principles course—figuring out the minimal set of essential skills we want out of a first course.

Garth commented

In most schools the CS teacher will also be teaching something else; Math, Science, Art or whatever so the requirements have to be realistic. I think CS Ed would almost have to be a minor, there are just not enough jobs out there yet for a teacher with only a CS Ed major.

So Garth has been thinking of it in terms of new teachers only, it seems. I suspect that we’d get more CS teachers more quickly by summer training for existing math and physics teachers than by trying to train new teachers in ed schools.

Physics teachers could be attracted to programming by a computational modeling curriculum, like the one used in the Matter and Interactions textbook.  Vpython provides a fairly simple entry point for physics teachers and students to write simulations of the sorts useful for AP Physics (both C: Mechanics and B).  I think that a computation-based text for Physics B still needs to be written, as Matter and Interactions definitely requires calculus after the first couple of weeks (or is there already an algebra-based physics book using something like Vpython?).  Once physics teachers become proficient in Vpython, it is not a big stretch for them to teach the CS Principles course (they could even continue to use Vpython for it).

Math teachers could be attracted to programming by summer workshops based around Project Euler, which provides a series of math challenges to be solved by programming (currently 434 such challenges).  Providing them with instruction in a suitable programming language (Python is a good choice for Project Euler) so that they can tackle the math problems would give them the experience programming needed before they would consider teaching programming.  Teaching them to program in Geogebra, free software for doing geometry and algebra presentations and apps, would also be valuable—both for improving their programming skills and for improving their current math courses.

The key point of both these ideas is that we could attract physics and math teachers to programming in order to become better teachers in their current fields.  That they would also become competent to teach beginning CS courses is a bonus.  Even if this approach failed to produce any new CS courses, we would still have improved physics and math teaching.  Given how addictive programming is, I think that we would also find these teachers becoming a force within their schools for creating programming courses, avoiding the current Catch-22: that there are no CS courses because there are no CS teachers, and no CS teachers because there are no courses.

I’ve not addressed in this post the initial question from the comments: what do beginning CS teachers need to know?  One implication of my proposal is that CS teachers need to be able to program.  They don’t need to be fantastically good programmers, nor do they need to know many different programming languages, but they need to be able to program and debug in the language of instruction.  They need to be able to model debugging, and they need to be able to assist students who are stuck (without taking over for the student).  They need to have personally done every assignment they assign, to figure out any ambiguities in the wording of the assignment and to make sure that it is doable with the tools and techniques that the students have been given in their class.

I think that may be enough—I don’t think that beginning CS teachers need to know software development techniques and the intricacies of the development environments and libraries beyond what is essential for the assignments.  They may choose to learn more (some math teachers might enjoy asymptotic analysis of algorithms, for example, and some physics teachers might get into programming robots), but it isn’t necessary for teaching an intro course.

I don’t think we can set the bar any lower: a teacher who can’t program can’t teach programming effectively, and programming should be at the heart of any intro CS course.

Advertisements

2013 June 19

Millions for a fairly useless new test

According to the College Board Press Release: The National Science Foundation Provides $5.2 Million Grant to Create New Advanced Placement® Computer Science Course and Exam.

Innovative College-Level AP® Course Created to Increase Interest in Computing Degrees and Careers, Particularly Among Female and Minority Students

To help ensure that more high school students are prepared to pursue postsecondary education in computer science, the National Science Foundation (NSF) is making a four-year, $5.2 million grant to the College Board’s Advanced Placement Program® (AP®) to fund the creation of AP Computer Science Principles (AP CSP).

The college-level AP CSP course will be introduced into thousands of high schools nationwide in fall 2016, with the first AP CSP Exam set to be administered in May 2017. Unlike computer science courses that focus on programming, AP CSP has been designed to help students explore the creative aspects of computing while also providing a solid academic foundation for understanding the intellectual concepts and practical contributions of computing. AP CSP includes a curriculum framework designed to promote learning with understanding, a digital portfolio to promote student participation throughout the year, and a course and assessment that is independent of programming language.

Successful implementation of the AP CSP course will hinge on the ability to recruit and train qualified teachers with computer science backgrounds to teach the course. Through its CS 10K Project (10,000 computer science teachers in 10,000 high schools by 2016), NSF has been laying the foundation for an unprecedented, national effort to prepare educators to teach this new material using hands-on, inclusive curricula.

The college-level AP CSP course will be introduced into thousands of high schools nationwide in fall 2016, with the first AP CSP Exam set to be administered in May 2017. Unlike computer science courses that focus on programming, AP CSP has been designed to help students explore the creative aspects of computing while also providing a solid academic foundation for understanding the intellectual concepts and practical contributions of computing. AP CSP includes a curriculum framework designed to promote learning with understanding, a digital portfolio to promote student participation throughout the year, and a course and assessment that is independent of programming language.   

I know that Mark Guzdial is fond of the Computer Science Principles (CSP) course that has been prototyped for a few years now at colleges, but I’m not convinced that it represents college-level course work (the supposed intent of AP courses and exams). I don’t know much more about the course than when I blogged about it in 2011, so my opinions in this article may reflect my own lack of knowledge about the course more than anything else.

I’m not saying that CSP is a bad course, or even that it is a bad introduction to computer science, but it seems to me to be at best high-school level. I know that many colleges disagree—the press release says

In a recent survey of 103 of the nation’s top colleges and universities, 87 percent confirmed that AP CSP requires the same content knowledge and skills as the related introductory college course, and 86 percent indicated a willingness to award college credit for qualifying scores on future AP CSP Exams.

There are also colleges that teach high school algebra and precalculus, but we don’t offer AP exams in them.

My own campus has several intro programming courses, some at the level of the AP CSP course.  I suspect that our campus would offer credit in these low-level courses for the AP CSP exam. These lowest-level courses do not count towards any major, though—they provide elective credit for what should be high-school level courses.  The intent (as is apparently the intent for AP CSP) is to provide an extremely low barrier to entry into the field.

I don’t know how well the low barrier to entry works, though.  I’ve not seen much evidence on our campus that the lowest level courses produce many students who continue to take higher level CS courses. Of course, I’ve not tried to get reports on that from the campus academic planning office, as I have enough to do without meddling in the affairs of other departments.  We still have appallingly low numbers of women finishing in CS (and the new game-design major within CS is even more heavily male), so I can’t say that the lower-level intro courses have done much to address the gender imbalance.

The success of CSP also depends on thousands of high schools suddenly deciding to teach the course and getting training for their teachers to do this. I (along with many others) have grave doubts that the schools have the desire or the ability to do this. It is true that the CSP course should be a bit easier to train people for than the current AP CS A course (if only because Java syntax, the core of CS A, is so deadly dull).

Even if, by some miracle, the NSF manages to train 10,000 teachers to program well enough to teach programming, the result is likely to be underwhelming.  I suspect that many will leave teaching—many of the math teacher bloggers I’ve followed who learned to program have moved out of teaching into being full-time programmers.    The result of the 10K project may not be a huge increase in high school CS teachers, but a loss of some of the better math teachers and the production of a core of under-trained programmers.

The justification for the new AP CSP course is that it will drive many more students in computing fields. The College Board continues to confuse correlation with causation:

Research shows that students who took college-level AP math or science exams during high school were more likely than non-AP students to earn degrees in physical science, engineering and life science disciplines — the fields leading to careers essential for the nation’s future prosperity.

Students wanting to do STEM fields in college often chose that path in high school, and took as many STEM courses as they could in order to get into good colleges.  Quite likely, wanting to do STEM in college caused them to take AP exams, not the other way around.

I’m not defending the current AP CS exam—from what I’ve heard about the AP CS A course and exam, it is mainly about Java syntax.  Personally, I think that Java is a poor pedagogical choice for a first programming language (I still favor the sequence Scratch, Python, C, Java), and using it as the language for the AP CS exam forces high schools into poor pedagogy.  The new CSP exam is not supposed to be so language-dependent, which may allow for better pedagogy.

Of course, I’m curious how the exam will be written to be language-independent, and whether it will be able to make any meaningful measurements of what the students have learned.  I’ve never been convinced that exams do an adequate job of measuring programming skills, and I’m not sure what the new exam will measure since the new course is “unlike computer science courses that focus on programming”.

I suspect that the easier AP CSP will replace AP CS A at many high schools, and that CS A will disappear the way that CS AB did in May 2009 (Gresham’s Law for pedagogy: easier courses drive out harder ones).  Whether this is a good or bad outcome depends on how good the AP CSP course turns out to be.

Overall, I’m simply not convinced that the College Board needs federal funding of $5.2 million to develop a new exam.  They are going to make enough money off the new exam that they should be able to fund it without subsidies.

Create a free website or blog at WordPress.com.

%d bloggers like this: