Latest: GaDoEd says Science Yes, Math No

We just got word that the Georgia Department of Education will count AP CS as a science credit towards high school graduation, but not as a math. The University System of Georgia, however, will count AP CS as either a math or science towards admissions requirements. No word on why the difference, or even how the decision was made, but at least we’re no worse off than we were — and maybe even a bit better.

Georgia Board of Regents accepts APCS as “counting”

Just found a great piece of email in my (massive!) unread pile from the Board of Regents of the University System of Georgia.

Here’s the latest on the AP CS. After much thought and discussions on the AP CS course, we have decided to accept the AP CS course as a 4^th course for admission to the USG institutions. However, the course will be listed in a separate category.

To follow up…..I do have a question for you. Would it be helpful to the students and our institutions if the AP CS course was to be accepted as a fourth science course only, or as a fourth science OR math course? We would like to do what’s best for the students and our institutions.

This could hardly be a better answer for us.  Computing is something different, so it gets a new category.  Of course, yes, we have asked for the “science OR math” option — which also matches with the understanding that computing has aspects of both, and helps students with either.

There’s another step yet.  This is the University saying, “This will count for University admissions.”  Next, the Georgia Department of Education has to say, “And we’ll count that for high school graduation.”  Normally, that should be nearly automatic, but creating a whole new category of courses may take some more convincing.  We’ll keep you informed.

How do we make high school CS classes more “real”?

I started working on a reply to Alan Kay’s comment on my previous blog post, and as it got longer with more links, I realized I should just use blog-owner’s prerogative and make a new post.  The issue we were discussing was how to make the case that the AP CS should count as a course that fulfills the “science” requirement in Georgia.  I commented:

Barb and I were just talking last night about the issue you raised, that the AP CS curriculum doesn’t look like a science. In the argument that I offered to the GaDOE, Computer Science classes have a lot of science practices (even if the content is not easily recognized as science by a traditional scientist), such as developing hypotheses, experimentation, and analysis of results. However, most CS curricula (including AP CS) do not make those connections between debugging and the scientific method explicitly.

Alan replied that he’d like to see more “real science” in these classes.

While pretty much agreeing with your comments, I think the real issue is a much deeper epistemological one — and is a problem not just in computer “science” but in the teaching of most high school and many college “real sciences” which have deep models as the representations for their theories (e.g. physics, chemistry, biology).

In the “real deal” it’s not so much about “hypotheses, experiments, analysis” (the standard elementary school characterization of science) as it is about the goodness and depth of the mapping between the observations and the model (in the standard characterization of science, this could be thought of as real thresholds in what “analysis” actually should mean).

So, how do we make that happen?  How do we get the “real deal” into high school classes?

My suggestion is that this doesn’t happen by making the argument for “real” classes at the state level.  The job of the Georgia Department of Education Science Committee is, explicitly,  to ask if any individual class “aligns with the GPS science standards, and/or the national science standards.” State standards are not re-written all that often, and Georgia just rewrote theirs.  Take a look at a given set of science standards, like those for high school Chemistry.  There you see terms like “hypotheses, experiments, analysis.”  Terms like “modeling” and “mapping” don’t appear at all.

How do we get a modeling and mapping focus in these classes?  Georgia (probably like most states) takes their lead from national authorities, like the American Association for the Advancement of Science standards “Science for All Americans.”  Take a look at what AAAS says about how to teach science — it’s a pretty close match to what Georgia has in their standards.  Nothing about modeling or mapping there, either.

The suggestion that I’m making is, if you want to get science classes to change, to make them more “real,” get the National Academies, or AAAS, or similar respected body to issue a report.  Larry Snyder’s NRC report on “Information FITness” gets cited a lot when discussing what students need to know about computer science.  It’s hard to make the case at the State level, because people within the State look outside the State for evidence.  These kinds of national reports make a difference.

Now, how do you get CS classes to be more “real”?  One way is by changing the Advanced Placement class, as NSF is trying to do.  Another way might be to use the same strategy as for Science — get the recognized authorities to come out with a statement, a report that says, “Here’s what real Computing Education should look like.”

My own opinion is that radical change is not going to come out of the ACM/IEEE curriculum standards process.  I was part of the committee for the CS 2008 standards update.  It is hard to get a dramatic and powerful statement for change out of that process.  We’re in a challenging stage in our field — we’ve got lots of ideas, and few measures for determining which is better than the other.

There were easily a half dozen new approaches to teaching CS that were vying to get a mention (better yet, a recommendation) in the new curricular volume.   How do you decide?  We have no reliable and valid measures of computing knowledge that cross approaches and languages.  We as a field can’t even agree on the learning objectives.  We on the committee tried to come up with some measure about usage and peer-review, but even that was insufficient.  If three schools do kinda the same thing and the approach got mentioned in a software engineering conference article, does that count?  Maybe it should — do we have a better standard? To list everything is no recommendation or guidance at all.  One of the criticisms of CC2001 was that it recommended a half dozen approaches for CS1 already.  I pushed to get some of those off the list — don’t we have evidence that some of these aren’t really all that effective?  The push back was similar.  “How do we really know that these don’t work?” and “We know friends who use those approaches.  How can we say in this volume that they don’t work?”  The result is that the volume reflects the least common denominator curriculum, which is useful for describing current accepted best practice, but it’s not a forward-looking statement of what should be.

Seymour Papert in his book The Children’s Machine argued that part of what happened to Logo was school.  School has a process of compartmentalizing and turning new ideas into standard curricula.  We can argue that this is wrong (and Seymour did in his book), but it is the reality.  I am describing here the process (as I understand it now, incomplete as that understanding is) of how one achieves curricular change at the secondary level — you show how you can meet the existing standards, or you push to get the standards re-written, with the most leverage coming from authoritative statements at the national level.  It’s hard work, but as Seymour points out, that’s how the system keeps from thrashing.  The system is designed to make it hard to change the system.

New Scottish Computer Science Curriculum

Interesting blog on the CACM site: http://cacm.acm.org/blogs/blog-cacm/37565-what-does-a-computer-scientist-do/fulltext. Scotland is developing a new computer science curriculum, from grade school up through higher education. Their “Big Ideas” are pretty similar to the ones being developed for the new AP “Computer Science: Principles.” They’re much more about what is possible with a computer, than how one uses a computer or how one works.

The meaning of computer science: What our students are thinking about

If you haven’t seen these blog posts yet by “The Wicked Teacher of the West,” I recommend them.  The author is middle school computer science teacher whom I think is terrific–smart, cares about teaching, trying hard to learn something new.  The challenges she had in her workshop are probably like those of our best students when they are struggling in our computing classes.
- http://geek-knitter.blogspot.com/2009/07/lost-in-syntax-part-1-or-omg-im-going.html
- http://geek-knitter.blogspot.com/2009/07/lost-in-syntax-part-2-or-omg-im-going.html

I also know a bit about the workshop that she was in, and I also hold it in high regard.  It’s got great ideas in it, and there are definitely things in that workshop that Wicked Teacher might use in her classes.  Here’s the rub as I see it: those two things weren’t connected for her.  As she put it, “I felt like I didn’t ‘get it’ but other than saying that I felt like I had no context, I couldn’t articulate what I meant.”

Today, I’m currently working on the lists of “Big Ideas of Computer Science” for the new APCS “Computer Science: Principles” Commission (and connecting these to Peter Denning’s Great Principles of Computing), and for the last few days, I’ve been working on the lecture slides for the Second Edition of our Python Media Computation book.  The combination of these blogs and these activities have me wondering, “How do we explain the big picture to students, especially when we don’t agree on the big picture?”

Whenever I hear someone saying matter-of-factly, “Computer Science is really just engineering,” I know that they haven’t really thought about what computer science is, at least in terms that students are looking for.  I think the workshop leaders had a reason for telling the Wicked Teacher why they were asking her to do all that she did.  But not only didn’t they tell her, I don’t think it was the same one that  she was looking for.

The workshop leader saw the meaning of the code as being the correct execution.  What Wicked Teacher was looking for was why should she care.  The state education officer who critiqued me for not thinking hard enough about the match of standards to computing principles was right.  If I want teachers to care about computing, I need to show them why it’s important in terms that they consider important.

This connects to my Python slides and Great Principles. In one example, in the book, we show how to decreaseRed in a picture:

def decreaseRed(picture):
  for pixel in getPixels(picture):
    value = getRed(pixel)
    setRed(pixel, value * 0.5)

Then we parameterize that function further:

def changeRed(picture, factor):
  for pixel in getPixels(picture):
    value = getRed(pixel)
    setRed(pixel, value * factor)

Why do that? Why should we add the additional parameter to the function? I completely believe that this is an important part of introductory computing that we should teach. But what’s the story that we give students to give this meaning?

In our Python book, we give the traditional, engineering-based explanation: By adding the additional parameter, we make the code more reusable so we can later build even more complex things more easily.  But what if someone doesn’t care about building more complex things, or building anything later?  What if they care about other things that are just as valuable?

I realized that I really could tell a story about “bindings” here, about associating names with values.  Peter Denning’s Great Principles touch on some of these.  By delaying the association of a value for factor, I maintain flexibility and expressiveness.  That’s a path that leads me to thinking about a wonderful set of abstractions that are powerful and unique to computer science: scopes and namespaces, functions as first class data objects, lambda (as the value for a function binding), creating new kinds of control structures, aggregating data and procedures together to create objects, and the power of “messages” where the function to be invoked for a given “name” is decided later, by the receiver.  That might be engineering, but it’s closer to mathematics to me.

What many of my most serious students really care about is exploring the effects of this new function.  What visual effects can you get by manipulating red?  When do you want to?  What is the power and  limitation of a red/green/blue color model?  What can I say easily, and what is more complex?  They care about the power of representations, and choosing a particular model, and about empirical data resulting from experiments with these program.  Now, computer science looks like science.  That’s yet another, equally valid meaning for adding the factor parameter.

The Wicked Teacher was looking for a meaning in what she was learning, and I suspect that it’s a different meaning than what the workshop leaders were offering.  There are several efforts, like Peter Denning’s and those of the APCS Commission, to define what “Computing” means. The real challenge that we face (in these efforts, and as teachers) is to offer a variety of meanings. We want to encourage deep thought and engagement in the power of computing.

Nudging Computing Education

I’m spending Father’s Day reading. Just finished Terry Pratchett’s Equal Rites (the first appearance of Granny Weatherwax, which I had never read before), and have now just started Nudge: Improving Decisions about Health, Wealth, and Happiness by Thaler and Sunstein.  I’d heard of behavioral economics before, especially in the context of how these ideas are influencing the Obama administration.  I’m recognizing implications for computing education as well.

The basic premise of behavioral economics is that people are bad decision makers, and those decisions are easily biased by factors like the ordering of choices.  Consider the choice between a cupcake and a piece of fruit.  The worse choice there only has consequences much later and the direct feedback (“You gained weight because you chose the cupcake!”) is weak.  Thaler and Sunstein promote libertarian paternalism.  The idea is that we want to offer choices to people, but most people will make bad choices.  Libertarian paternalism suggests that we make the default or easiest choice the one which we (paternalistically) define as the best one — that’s a nudge.  It’s not always easy to decide which is the best choice, and we want to emphasize making choices that people would make for themselves (as best as we can) if they had more time and information.

An obvious implication for computing education is our choice of first programming language.  Alan Kay has pointed out many times that people are sometimes like Lorenz’s ducks, who were convinced that the Lorenz was their parent: people “imprint” on the first choice they see.  Thaler and Sunstein would probably agree that the first language someone learns will be their default choice when facing a new problem. We want to make sure that that’s a good default choice.

How do we choose the first, “best choice” language?  If our students are going to become software engineers, then choosing a language which is the default (most common, most popular) in software engineering would make sense: C++ or Java.  But what if our students are not going to become software engineers?  Then we’ve made their first language harder to learn (because it’s always harder as a novice to learn the tool used by experts), and the students don’t have the vocational aspirations to make the extra effort worthwhile.  That choice might then lead to higher failure/withdrawal rates and students regretting trying computer science.  Hmm, that seems familiar…

Another choice might be to show students a language in which the best thinking about computer science is easiest.  For example, Scheme is a great language for pointing out powerful ideas in computer science.  I believe that Structure and Interpretation of Computer Programming by Abelson and Sussman is the best computer science textbook ever written.  It’s power stems, in part, from its use of Scheme for exemplifying its ideas.

The challenge of using Scheme is that it is not naturally the language of choice for whatever problem comes the student’s way.  Sure, you can write anything in Scheme, but few people do, even people who know Scheme.  Libraries of reusable tools that make it easy to solve common problems tend to appear in the languages that more people are using. If students were well-informed (or are/become informed), would they choose Scheme? If the answer to that question is “No,” the teacher appears coercive and constraining, and the course is perceived as being irrelevant. That’s another familiar story.

The ideas of Nudge have implications for teachers, too. I am on the Commission to design the new Advanced Placement (AP) Computer Science exam in “Computer Science: Principles.”  (This exam is in contrast to the existing Level A CS AP exam in computer science programming in Java.) We just met for the first time this last week.  There will be programming in the new APCS exam, and there’s interest in providing teachers with choices of what language they teach.  Providing infinite choice makes it really hard to write a standardized, national exam.  Teachers will likely be offered a menu of choices.  How will those choices be ordered?  How will teachers make these choices?  While there are some wonderful high school teachers, there are too few high school CS teachers.  The new APCS exam will only be successful if most of the teachers offering it are brand new to computer science.  These teachers need help in making these choices, with reasonable default values, because they simply won’t have the experience yet to make well-informed choices.

The Responsibility of APCS for the Decline of Enrollment in Undergraduate Computer Science

I had a really interesting discussion (perhaps “disagreement”) at the NCWIT meeting a few weeks ago.  My discussion partner claimed that “the APCS (Advanced Placement Exam in Computer Science) has to go” and “the APCS does nothing good for undergraduate computer science” and most pointedly, “the APCS exam is a factor in declining enrollments in computer science.”  I disagree strongly with that last point. I do think that the APCS is in need of improvement for broadening participation in computing, and I even agree that it doesn’t do much good for undergraduate computer science today.  However, I don’t believe that it does any harm.  The reality is that there is just so little computer science in high schools today, that the APCS (and just about any other CS curriculum) has almost no impact on potential computer science students in high school.

One of our major accomplishments (read “Barbara Ericson’s major accomplishments”) in “Georgia Computes!” is that the number of APCS high school teachers in the state has more than doubled in the last four years, and most of those new teachers took workshops from Barbara. The way we get the teacher count is by measuring the number of high schools in the state who send anyone to the APCS exam.  Since there is only one high school in the state that has more than one APCS teacher, the number of high schools is essentially 1:1 with the number of teachers. It’s also the case that the percentage of high schools offering APCS out of all high schools is higher in Georgia than any other school in the Southeast.  Georgia’s percentage of APCS-offering schools is higher than Florida, South Carolina, Alabama, etc.

That sounds impressive — until you realize that that percentage is 22%.  22% of Georgia high schools offer APCS.  The inverse implication is that 78% of high schools in Georgia offer no APCS, and if a high school doesn’t offer APCS, they most likely offer no computing at all.  Thus, with more than 75% of high schools offering no computer science, Georgia is a leader.

The CSTA has been recently crunching the numbers on APCS.  The APCS has been around for 25 years now.  In 26 states, the grand total of all students who have taken the APCS in all that time is less than 200.  That’s 8 students per year on average (over 25 years), in more than half of the United States.  8 students could be the output of a single teacher in a single high school.  In 26 states, then, there could be essentially no high school computer science at all.

APCS does over-emphasize programming, and it does emphasize Java which is not the best introductory programming language.  However, I can’t believe that APCS is swaying high school students’ opinions of computer science if the vast majority of those students never see AP classes or students taking them! The argument was made to me that, by offering credit for APCS, universities are holding the APCS in some respect and thus drawing attention to it, which may be hurting us because of the APCS failings.  Yes, the APCS may be overly emphasized by college CS departments. That doesn’t change the fact that even if a high school student in the US wanted to take APCS, almost none of them have any opportunity to even see the course.  We may be saying implicitly, “the APCS is great!” But if a student can’t take APCS, that statement has no real impact.

The problem with high school computer science is not that APCS is such a bad model. It’s that far too few students see any model of CS at all.  That’s another reason why Jan Cuny’s efforts at NSF to create “10,000 CS teachers for 10,000 high schools by 2015″ is so important.  We need more CS teachers.  Yes, we need more and better curricular models.  But without teachers, even the best models will get no further into high schools than APCS is today.