Posts tagged ‘CS:Principles’
“Florida is killing Computer Science,” was the first thing that Joanne Barrett told us when we asked her how things were going in Florida. Barbara and I went to Orlando to give the Technology track keynote (joint! It was fun!) and two breakouts at the FCIS Conference on Thursday. Joanne ran the Technology track at FCIS. (Our travel was sponsored by CSTA and Google – thanks!) The mood of the CS teachers we met was dismal.
Currently, computer science is part of the academic high school degree in Florida — the classes that one would take as College preparation. It’s mostly taught by mathematics teachers. This year is the end of that. This is the last year that the current CS classes will be offered.
As of next year, all the computer science classes in Florida will be moved into business, as part of career preparation. As we understand it from Joanne, they literally won’t count for credit towards an academic high school degree. The AP CS will stay in the academic track, but all the other computer science courses will move to business.
Why? Exactly the same issue as in Georgia: Perkins funding will pay for hardware, so career prep has the computers, and it gets computer science. We spoke to one business teacher who is desperately seeking professional development to prepare herself for teaching all these new computing courses. We met one of the teachers at the Florida Virtual High School (which has a really cool CS sequence, and an astounding success rate for their students on AP CS), and she said that they may not even be able to offer any CS next year. FVHS is about academic subjects, and CS is being re-classified. Florida is also looking for industry certification for the end of the Perkins-funded pathway, and the teachers we talked to said that they’re currently considering an IEEE Certification — which is explicitly for graduates of four year degree programs, not high school students.
What will this do to CS education in Florida? it won’t be “killed,” but it will be changed. I worry about the quality, when swapping out all the experienced math teachers for inexperienced business teachers. I can’t the impact on CS10K goals.
Can AP CS succeed (in particular, the new CS:Principles effort) as a standalone AP, with all the other CS courses in another track? Maybe. I wonder how much effort school districts will put into AP CS, if they have a different, funded CS pathway. I also wonder if CS:Principles can meet its goal of helping to broaden participation in this context — the career prep programs that I’ve seen are far more heavily under-represented minority than the college prep programs. What if the minority students you want to draw into computing via AP CS are off taking the career prep classes?
A nice piece (with interviews with Barbara Ericson, Jeff Gray, Dan Garcia, and Maureen Biggers) on getting more women into computing. I like that the story reflects current thinking and research on best practices for drawing more women into computing. For example, we used to think that having more female professors was critical to provide role models. But Joanne Cohoon’s work showed us that male professors can motivate women to consider graduate work in computing as well as female professors.
Experts on the gender gap in computer science have increasingly come to believe that a multipronged strategy is needed to close it. The tactics would include the following:
- More-diverse programming activities, to seize the interest of middle-school girls, in the same way that role-playing video games are embraced by boys.
- A revamped introductory course, whether taken in college or as an Advanced Placement course in high school, to provide a broad overview of the real-world applications of computer science.
- Early exposure to research projects during the first year of college. (Ms. Lamm was paired with her mentor, Mr. Gray, during her first month at Alabama.)
- Opportunities for undergraduates to interact with women who have enjoyed successful careers in technology.
ICER 2012 in Auckland, New Zealand, was notable for having the highest number of submitted papers to any ICER (8th year) and almost as many attendees as last year, despite being a long way for all the US and European delegates. In the end, there were 13 research papers accepted, 8 discussion papers (shorter papers, with shorter presentations and longer discussion periods), 16 attendees at the Doctoral Consortium, and 19 Lightning Talks accepted. Despite all the successes, I’m worried whether ICER can meet the global needs for computing education research.
The first talk of the conference ended up winning the People’s Choice award, voted on by the delegates (used to be called the “Fool’s Award,” but now renamed the “John Henry Award” for a paper with great “potential to be transformative”) from Ian Utting and the BlueJ crew. BlueJ, probably the most successful and popular pedagogical Java IDE, is going to be outfitted in the Spring with event logging. We’ll know what the students are doing in BlueJ, at a large scale (probably about 1Tb/year). All of that data is going to get stored (anonymously) for use by researchers. The interesting discussion point is: What are web-scale questions in CS Education?
The Chair’s Award (new to ICER, kind of a best-paper award) was won by Colleen Lewis for her detailed explanation of how a middle schooler at a summer camp in Scratch did his debugging. In a sense, Colleen (just graduated from Berkeley, and just started at Harvey Mudd College) was answering a comment that Ray Lister made which was often quoted during the conference: that students sometimes demonstrate “bizarro programming behaviors.” Colleen carefully reconstructed the activity of the student and pieced together a story of how the student thought through the problem, and how his behavior did make sense.
I tweeted some of my favorite one-liners from the conference. I’ll mention just a couple highlights here.
- Quintin Cutts presented an intriguing paper suggesting a new way of looking at questions that spur learning, with data drawn from Beth Simon’s CS:Principles course for non-majors. The idea is called the Abstraction Transition Taxonomy, and it’s about how we talk about problems (natural language), we talk about CS (“arrays”), and we talk in code (e.g., “a[i]“). They hypothesize that questions that lead to transitions between levels may be the most successful scaffolding for novice learning. So, how do we test that hypothesis?
- My former students, Drs. Brian Dorn and Allison Elliott Tew, are working on a new validated measure of attitudes towards computing, based on similar instruments developed for physics and biology. They presented their validation scheme at ICER. I’ve already read a draft of a future paper where they’re actually using the instrument, and I think that this is going to be a big deal.
- Lauren’s subgoal paper drew some oohs when I showed the results, a few shakes of heads (I don’t think everyone believed it), and some challenging questions. ”Why aren’t you using this in your intro classes?” asked one questioner. ”Or your advanced classes?” asked another. Yup. Good questions.
- One of the lightning talks had an interesting idea: Form pairs for pair-programming based on perception of efficacy. Put non-confident students together! The idea is that self-efficacy feeds off a vacuum, “I’m doing worse than everyone else. I just know.” Having someone else with low-confidence provides evidence that you’re not alone in struggling. No data were presented, but it’s an intriguing idea.
One of my mentors here at Georgia Tech is Jim Foley who recommends structuring research around BHAG’s — Big, Hairy Audacious Goals. The BHAG for computing education is teaching computer science in all schools. What’s particularly scary about this BHAG is it’s already happening. The US has the CS10K effort. The Computing At School effort is going strong in the UK. New Zealand and Denmark have both instituted new nationwide CS curricula in the last couple years. There is an enormous need for research on how to help teachers learn to teach computer science, what the challenges are in teaching computer science to school children (e.g., who have not declared a major of computer science, who are not necessarily motivated to learn computing for a career), and evaluations of successful models for supporting learning by both teachers and school children. Maybe we’re just going to do it, and figure out later what works. But maybe there’s a better way.
How much of ICER 2012 research could possibly inform these efforts? There’s Colleen’s interesting paper on a pre-teen debugging, and there’s Briana’s work on professional development efforts. That’s pretty much it for directly computing-at-schools/CS10K relevant, from my read of the papers. There were a few papers that addressed non-majors (like Quintin’s, and our statewide survey paper), but at the undergraduate level. The rest of ICER’s papers were seeking to understand and teach undergraduate CS majors.
It’s important to understand undergraduate CS majors and to improve their understanding. My personal research agenda is more on the latter than the former — it’s more important to me to learn how to teach better, rather than to understand the effects of teaching that might be better if we built on everything that we know about teaching. But I do get the value of understanding understanding (or lack of understanding, or even misconceptions). There are far more high school teachers and schoolchildren than there are undergraduate majors, and they’re different. The oncoming problems are much bigger than the ones we’re currently facing.
How do we inform the broader need for research on computing education? Is ICER the place to look for that research? Or will ICER (and SIGCSE) always be a mostly undergraduate-oriented conference (and organization)? If not ICER and SIGCSE, where should we look? I was a reviewer for AERA’s new engineering and computing education division, and while I was excited about those papers, they’re coming at the problems almost entirely from the education perspective. There was little from ICER and the computing education research community. The problems that we need solved will require work from both communities/disciplines/fields. How do we get there?
Ben Chun posts an interesting article critiquing the NSF CS10K project, which is worth reading. (Thanks to “Gas stations without pumps” through which I first heard about Ben’s post.) i don’t agree with all of it — I’m not sure that it’s such a significant concern that the papers describing the CS10K project are “behind a paywall.” — most of the information is readily available at the CS:Principles site (and I believe that the articles from the recent InRoads will be made available soon).
But his main point is a valid one: This is a huge project, and it’s not obvious that it’s even possible, let alone whether it’ll be successful. He asks what specific policy changes are necessary. I don’t think anybody knows, because it’s not knowable in a general sense. Policy changes that impact high schools have to be made on a state-by-state basis. I know what we have done and would like to do in Georgia, and I know what’s going in Massachusetts, South Carolina, and California, but all four of those are completely different. Ben calls the desired policy changes “a unicorn,” but I think it’s closer to “that animal I can hear in the other room, thumping around, but can’t tell what it is yet.” I also agree that we need to figure out how to engage the whole community. I believe that that is happening, through CSTA Chapters and efforts like the AP attestation. I don’t know how to make it happen faster or more broadly, but I do believe that NSF is bringing together a team of people who do.
I say that because if you’re actually putting together a “large-scale, collaborative project bringing together stakeholders from wide-ranging constituencies”, you don’t bury all the information about it behind a paywall. I happen to be teaching at UC Berkeley this summer, but otherwise I wouldn’t even have access to the paper that describes the CS10K project. And I think I’m the kind of person that might be able to help. I actually teach high school computer science! I want more colleagues! I believe CS education is vitally important for young people! The fact that the first result for “cs10k” in Google takes you nowhere is a problem. The lack of open, public discussion of the issues and plans is a problem. The lack of savvy about engaging the whole community — including high school teachers and administrators — is a problem.
But dire as it is, that’s not the biggest problem. The biggest problem is that we don’t agree on what we’re asking for. It’s not that we disagree. We just have no idea. But at least the goal has been made clear, even if not effectively publicized: A new AP course in 10,000 high schools by 2015. (Or maybe 2016 or 2017, I now hear.) In 2011, there were only 2,667 high schools in the world with students taking the AP Computer Science A exam. Today, I think there are about 2,100 high schools authorized to offer the course in the US (not that all of them actually do). There are about 40k total public and private high schools in the US.
P.S. I’m in Oxford now, and start my classes this afternoon (early this morning for East-coasters, VERY early for West).
My colleague, Janet Murray, wrote a nice blog post (linked below) identifying what parts of programming that designers need to know. There’s a significant intersection with the CSPrinciples work. She points out that the purpose of a designer learning programming is not to get them to build things for themselves — she says that that would dramatically limit the designers. Instead, she wants them to understand how code is created, what it can do, and how flexible it is. It’s very much about developing a mental model of a notional machine and gaining procedural literacy.
But even expert programmers, especially the self-taught ones, can be ignorant of the key architectural principles that make for good design: information abstraction, modularity, and encapsulation. So I would encourage any designer with a desire to learn programming to become as expert as they can at it because it will help them to think procedurally and to understand the plasticity of the medium. But I’d also remind them that it is the principles of computational architecture that will last them over their career, not the coding.
The 999th blog post feels like a good point to think about where we’re going. Here’s how I define the big question of computing education research:
Computing education research is the study of how people come to understand computing, and how we can make that better.
But that’s the big question. There are lots of research questions inside that. Here are some of the ones that I’m intrigued by. This is an overly-long blog post which I’m using as a place marker: Here’s what I’m thinking about right now at the end of the first 1000 blog posts. Skip around to the parts that you might find interesting.
What are the cognitive processes of learning to program?
Why is learning to program hard? The empirical evidence of teaching computer science suggests that it is. Failure rates worldwide of 30-50% in the first class have been reported for decades. The misconceptions and challenges that students faced in Scratch in Israel (ITICSE 2011) are quite similar to the same ones documented in Pascal at Yale in the 1980’s (Soloway et al.).
Are there cognitive challenges to learning programming that are unique among other disciplines? Perhaps so. Consider these two possibilities:
- Agency: Writing a computer program is the task of providing instructions to another agent to execute, but a non-human agent. Miller in 1981 found that humans found it hard to describe task processes to another human, and the produced instructions required human understanding to interpret them. People do not naturally produce instructions at a level detailed enough for a computer to execute.
- Time: A program uses a variety of notations to compress time, e.g., iteration and recursive constructs. These notations describe a process in brief which will execute repeatedly many times (perhaps millions of times). We know that these notations are among the most challenging for students to grasp.
Both agency and time notations are unique to the challenge of programming. Perhaps these factors (among others) help to explain why programming is so hard, and understanding these challenges will lead to new insight into how humans conceive of agency and time.
Where do problems/difficulties/misconceptions in learning programming come from?
Most students have no experience in programming computers before they enter their first computer science class. So, no prior conception of assignment, memory allocation, WHILE and FOR loops, linked lists, or recursion — yet these are way up there on the list of things that are hard about learning to program. They haven’t changed in decades, across multiple languages. Where did those problems come from? Do we teach them wrong? Exactly where so that we can fix it! Do students have some prior knowledge that is interfering? What knowledge are students bringing to bear in learning to program?
Can we teach computing without a programming language?
Can someone learn what a computer is, how it works, and what its limitations are simply through non-programming activities?
Mathematicians did. Turing defined what a computer is, without a programming language. Instead, he defined a machine and a language.
I’m increasingly coming to believe that those are outliers — Turing and mathematicians who figure out computing without a computer are unusual, and we can’t do that at-scale. Learning to understand computing is learning to understand a notional machine (duBoulay), to construct a mental model of how you expect the notional machine to work (Norman), and that mental model consists of decontextualized parts (deKleer and Brown). It’s very hard to think about those parts without having names or representations of them. It can happen, but it takes enormous cognitive effort. It’s not going to be effective and efficient to reach our learning goals without a language.
Challenges for CS10K
The CS10K effort (to have 10,000 high school teachers capable of teaching CS:Principles in 10,000 US high schools) requires answers to some significant research questions. Some of these include:
- What kind of pedagogy will fit into the lives of in-service high school teachers and other working professionals?
Computer science pedagogy today is mostly apprenticeship-based: Students get a bit of instruction (perhaps some modeling of good behavior), and then are expected to learn through doing, by programming in front of an IDE. While the apprenticeship-based model is effective, it’s inefficient if the goal is understanding about computer science, as opposed to expertise as a software engineer.
In-service high school teachers are a particularly challenging audience. Most likely, they will never be professional software engineers, and they are full-time (overworked) professions, so they have neither the motivation nor the time to engage in apprenticeship-based learning. How do we teach CS to these teachers in the small bits of time that they have available?
- How do we create sufficient, high-quality on-line materials to lead to successful CS learning at a distance?
The best distance learning programs in the world (such as the Open University UK) rely significantly on text-based materials, because we know how to control costs while creating and maintaining high-quality content. CS is not best taught with printed text, since visualizations and simulations play a key role in student learning. How do we create sufficient (e.g., at reasonable cost), high-quality materials to support CS learning at a distance?
- What will motivate high school teachers to take classes in computer science, to be engaged with the content, and to sustain their interest?
The existing CS teaching programs in the United States are woefully undersubscribed, e.g., Purdue’s CS methods course has never had more than one student enrolled each term that it is offered. What will drive more teachers into CS education?
- What do teachers need in order to develop into successful computer science teachers?
High school teachers will not need to be professional software engineers. They do need to be able to present CS ideas, to assign and assess student work, and to mentor, e.g., to help facilitate student debugging and guide development. What are the learning objectives for CS high school teachers? How do we assess that development?
- CS PCK: What is Computer Science Pedagogical Content Knowledge?
In most disciplines, there is a body of knowledge of how to teach that. How People Learn has a whole chapter on domain-specific teaching practices, and points out that those are much more powerful for effective teaching than domain-general teaching practices. For example, science educators explain how to support inquiry-based learning, and mathematics educators know how to build on innate understanding of number. We call that knowledge pedagogical content knowledge. How do we best teach computer science? How do we help future educators develop the unique skills to teach computer science?
Because of my recent posts on teaching with Logo and the culture of older programming languages, I’ve been poking around the Logo sites. My most enjoyable find has been the Logo Books page of the Logo Foundation. Remember that it was always part of Seymour Papert’s vision that Logo would be used across the curriculum, not just to teach programming. There was a rich collection of books written to support that vision.
- There were books written to teach discrete mathematics and algebra with Logo.
- E. Paul Goldenberg’s book on linguistics in Logo was wonderfully inventive. One of my favorite exercises: Grab text in each of French, Russian, and English. Now, replace all vowels with “_”. Can you tell which language is which? Then, there are variations, like replacing all consonants with “_”. The point is to get students to think about what characterizes a language.
- Of course, Turtle Geometry is a terrific book, connecting physics, mathematics, and biology . I’ve read the first few chapters, and skimmed other chapters, but I’d have to build up my math chops to finish it. The book finishes with non-Euclidean geometry and Einstein’s general theory of relativity, with turtles.
- I was pleased to see that LogoWorks is actually available in its entirety . Though the book is written for Atari Logo, much of it can be modified for more modern Logo implementations. The chapter on music was my favorite, with code for transposing music and doing ear training.
Probably the greatest treat for me was finding that all three of Brian Harvey’s Computer Science Logo Style books are available on-line for personal use. I have all three volumes in their first edition, and was pleased to see the second edition here. This is such a fun series of books. For example, Volume 2 includes a Basic compiler, and a version of Doctor (think “Eliza”) which is based on Brian’s access to the original source code. Just as we ask questions today like, “Does learning Scratch help you learn Java/C++/Python later?” there was the question years ago, “Does Logo help you learn Pascal later?” Or in other words, “Is the mental model that one develops with Logo helpful in understanding Pascal?” Brian’s Volume 3 kind of addresses that — by building a Pascal parser and compiler, complete with virtual machine! All of this in Logo — in fact, it will all run in the free, cross-platform Berkeley Logo that Brian has made available.
When I told my PhD student, Briana Morrison, about my explorations, she asked, “Why aren’t any of the CS:Principles pilot classes using Logo?” It’s a great question. Logo fell out of favor because researchers were unconvinced learning Logo led to higher-order thinking skills. But that’s not what we ask of computer science classes any more. We want students to learn computer science, and we want that computing integrated into other learning — a form of literacy. Logo is a powerful, Lisp-like language that was explicitly designed to be easy for students to learn. There are lots of resources available for using Logo across the curriculum. Why aren’t we? Is it merely because it’s “out of fashion”? Are we so swayed by what professional software developers think is fringe or “not real” that we will discount a great idea just because it is thirty years old? In other disciplines, foundational ideas are studied and built upon. Why do we ignore ours?
GasStationWithoutPumps did a blog piece on the newspaper articles that I mentioned earlier this week, and he pointed out something important that I missed. The Guardian’s John Naughton provided a really nice definition of computational thinking:
… computer science involves a new way of thinking about problem-solving: it’s called computational thinking, and it’s about understanding the difference between human and artificial intelligence, as well as about thinking recursively, being alert to the need for prevention, detection and protection against risks, using abstraction and decomposition when tackling large tasks, and deploying heuristic reasoning, iteration and search to discover solutions to complex problems.
I like this one. It’s more succinct than others that I’ve seen, and still does a good job of hitting the key points.
Naughton’s definition includes issues of cyber-security and risk. I don’t see that often in “Computational Thinking” definitions. I was reminded of a list that Greg Wilson generated recently in his Software Carpentry blog about what researchers need to know about programming the Web.
Here’s what (I think) I’ve figured out so far:
- People want to solve real problems with real tools.
- All we can teach people about server-side programming in a few hours is how to create security holes, even if we use modern frameworks.
- People must be able to debug what they build. If they can’t, they won’t be able to apply their knowledge to similar problems on their own.
Greg’s list surprised me, because it was the first time that I’d thought risk and cyber-security as critical to end-user programmers. Yes, cyber-security plays a prominent role in the CS:Principles framework (as part of Big Idea VI, on the Internet), but I’d thought of that (cynically, I admit) as being a nod to the software development firms who want everyone to be concerned about safe programming practices. Is it really key to understanding the role of computing in our everyday lives? Maybe — the risks and needs for security may be the necessary consequent of teaching end-users about the power and beauty of computing.
Greg’s last point is one that I’ve been thinking a lot about lately. I’ve agreed to serve on the review committee for Juha Sorva’s thesis, which focuses on his excellent program visualization tool, UUhistle. I’m enjoying Juha’s document very much, and I’m not even up to the technology part yet. He has terrific coverage of the existing literature in computing education research, cognitive science, and learning sciences, and the connections he draws between disparate areas is fascinating. One of the arguments that he’s making is that the ability to understand computing in a transferable way requires the development of a mental model — an executable understanding of how the pieces of a program fit together in order to achieve some function. For example, you can’t debug without a mental model of how the program works (to connect to Greg’s list). Juha’s dissertation is making the argument (implicitly, so far in my reading) that you can’t develop a mental model of computing without learning to program. You have to have a notation, some representation of the context-free executable pieces of the program, in order to recognize that these are decontextualized pieces that work in the same way in any program. A WHILE loop has the same structure and behavior, regardless of the context, regardless of the function that any particular WHILE loop plays in any particular program. Without the notation, you don’t have names or representations for the pieces that is necessary for transfer.
Juha is making an argument like Alan Perlis’s argument in 1961: Perlis wasn’t arguing that everyone needed to understand programming for its own sake. Rather, he felt that the systems thinking was the critical need, and that the best way to get to systems thinking was through programming. The cognitive science literature that Juha is drawing on is saying something stronger: That we can’t get to systems thinking (or computational thinking) without programming. I’ll say more about Juha’s thesis as I finish reviewing it.
It’s interesting that there are some similar threads about risk and cyber-security appearing in different definitions of computational thinking (Naughton and Wilson discussed here), and those thinking about how to teach computational thinking (Sorva and Perlis here) are suggesting that we need programming to get there.