Posts tagged ‘CS1’
Openness is influenced by cognitive abilities: Self-efficacy too?
Interesting finding that supporting older adults learning better problem-solving skills seems to lead to a change in a personality trait called “openness.” I find this interesting for two reasons. First, it’s wonderful to see continuing evidence about the plasticity of the human mind. Surprisingly little is “fixed” or “innate.” Second, I wonder how “openness” relates to “self-efficacy.” We heard at ICER 2011 how self-efficacy plays a significant role in student ability to succeed in introductory computing. Is there an implication here that if we could improve students’ understanding of computer science, before programming, that we could enhance their openness or self-efficacy, possibly leading to more success? That’s a related hypothesis to what we aim for in CSLearning4U (that studying programming in the small, worksheet-style, will make programming sessions more effective — more learning, less time, less pain), and I’d love to see more evidence for this.
Personality psychologists describe openness as one of five major personality traits. Studies suggest that the other four traits (agreeableness, conscientiousness, neuroticism and extraversion) operate independently of a person’s cognitive abilities. But openness — being flexible and creative, embracing new ideas and taking on challenging intellectual or cultural pursuits — does appear to be correlated with cognitive abilities.
via Enhancing cognition in older adults also changes personality.
“We’ve got to teach kids to program, but not as a subject in isolation.”
Mike Goldweber sent me a link to this video at BBC News – Newsnight – Is lack of computer science teaching failing pupils?. I’m a bit worried about the overall theme of this story, that it’s important to teach UK kids programming in order to save the British gaming industry. (Are there that many jobs available in gaming? So much that we should teach every kid in school to program?) But the quote right at the beginning, around 44 seconds in, is a thought that I’ve been mulling a good bit recently.
We’ve got to teach kids to program, but not as a subject in isolation.
That sentiment is in keeping with Seymour Papert’s original vision for Logo in schools. In his book “The Children’s Machine,” Seymour critiqued the process of “schooling” that took Logo out of its natural home as a tool for exploration and expression in mathematics and science class, and instead “schoolified” it. Logo was shoved into the lab (far away from the interest of teachers), and made into a separate subject to be taught, after the pre-requisite “Keyboarding Skills” course. Seymour saw programming as going beyond “the 3 R’s,” in an amazingly prescient Wired piece from 1993, where one can see the seeds of the Open Learning effort and individualized learning support through technology.
This issue of teaching programming in the context of other courses helps to address some of the concerns voiced in the recent discussion about computer science as a liberal art. It’s a point I hear often from high school teacher advocates. “The curriculum is too full. If we put CS in, what comes out?” Seymour was saying that that’s the wrong way to think about it, and I’m starting to think he was right on this count (among many others–some of his insights take me longer to grok). It’s not about doing something more. It’s about teaching what we have now, but in a new and more powerful way. It’s Andy diSessa’s argument for computing literacy — how much powerful are we when we are as literate with computing as we are with numbers or text?
Set aside the issue of programming being a weird (and arguably, badly designed for the general purpose of insight and expression) notation, and even set aside the technology issue. Imagine that we had a new form of writing, that wasn’t that much different than English (e.g., it’s not Esperanto), but was significantly more powerful (e.g., more accurate, more understandable, more usable for mapping to theory, more practical for solving problems) for expressing science and mathematics. And what’s more, once you used that language, you could easily visualize and simulate what you described. Wouldn’t that be worth teaching to every science and mathematics student, at least at the undergraduate level? Certainly, we would want that for every graduate student. Why is it not worth teaching, just because it’s a notation that runs on a computer?
I have advocated for some years now “Computing for Everyone,” that Alan Perlis had it right when he argued in 1961 that everyone on campus should learn to program. Perlis advocated a required course for everyone, and so have I. Maybe that’s the wrong end-goal. I understand the argument from CSTA, that it’s hard enough to teach enough CS teachers in high schools — how in the world can we teach every mathematics and science teacher how to use and teach programming? I totally get that we don’t know how to get there. But that doesn’t make it the wrong desired goal. (I’m reading in the middle of Abelard to Apple now, so I might be particularly receptive to learning-with0ut-courses these days.)
How do we get there, where students have true computing literacy and programming is part of science and mathematics? Are required courses in computing part of the trajectory to the desired state? Or is there a different path to integrating computing into the rest of the curriculum?
Teaching programming to those who don’t shoot: Give up on the shooters
I’ve been exchanging email lately with a CS teacher using media computation in Python with her 9th grade class this year. She has been pushing the boundaries of JES, trying to do more interactive programming. It’s hard to do with JES. Swing and Jython don’t get along all that well, particularly from within JES, a Swing application. I finally asked her: Why not just use media computation for what it’s good for? Play to its strengths: Make collages, sound collages, music, and videos. Interactivity is hard for early beginners. She had this response.
I need to develop an approach that appeals to all of the people who have traditionally signed up for programming classes (because they want to shoot things) along with the underrepresented groups who have not signed up for programming because they don’t want to shoot things.
It’s a great comment, and it’s a deep question. Does she? Does she need to serve both audiences? Do we need to teach, in every classroom, to engage every student?
This issue comes up when I talk to people about Threads. “We love your approach, but we have a small school. We can’t cover all those Threads. What should we do?” The answer is not “whatever we have been doing, pretty much decontextualized, which works for any problem” (which is what I normally hear). Go ahead and specialize. Teach to a context. Students (especially novices who don’t understand what computing is for) will learn more, and more deeply, than by teaching in a decontextualized way. Your students will be more marketable by knowing about computing + X, where X is some interesting applications context. Pick a context that draws the students that you want to encourage and engage.
At the post-secondary level, you don’t have to please everybody in every class in every school. Students have choices. Colleges should play to their strengths. Larger Universities can offer more options on the same campus. For smaller schools, build coalitions so students have choices between the schools.
But the question is harder for the high school teacher. Her students don’t have a choice. If she doesn’t engage them, they’re not going to get computer science somewhere else.
Here’s my answer, though I realize that it comes at some risk: Give up on the shooters. There’s a lot more of those who weren’t interested in computing traditionally, than those that were. Computer science in the last decades has drawn from only a small demographic. Play to the larger audience. Play to the audience with different interests than those most commonly in CS today. Teach to those who don’t shoot.
Maybe it’s CS2 that’s wrong, not just CS1
I don’t disagree with the claim here, that students don’t learn to program that well in one semester of CS. But I think the author doesn’t also consider that maybe our expectations are too high in CS2, too. Programming isn’t learned quickly. If we don’t have it in high schools, most people are going to take multiple semesters in undergrad to become competent — for expertise, multiple years.
In particular, I believe that expecting a student to learn to program well enough to study Computer Science in a single 15-week course is almost as absurd as expecting a student with no instrumental musical experience to be ready to join the university orchestra after 15 weeks. There are, of course, musical prodigies that can handle this challenge. Likewise, there are many “natural born programmers” who learn how to program with very little apparent effort. However, these individuals are the exception, not the rule.
How only one path fails to help everyone succeed at learning how to code
Project Euler sounds great! The author of the now oft-forwarded Atlantic piece is making a mistake by extrapolating from himself to everyone.
The article (linked below) tells the story of how author James Somers finally learned to program by discovering Project Euler, an effort to teach programming by leading students through a sequence of carefully constructed programming problems. Somers “finally” learned to program after first failing at reading one of the enormous tomes on how to program and then after failing to learn through AP CS.
I don’t doubt that Somers really did learn a lot from Project Euler, and I believe that thousands have and will in the future. The “inductive chain” theory described below seems plausible. Project Euler is a terrific idea! I also believe, though, that some people do learn (at least, get started) from those massive tomes, and others do learn through the more engineering-oriented approach that Somers dislikes in AP CS. Some may even learn from playing with digital media.
I personally don’t find Project Euler’s problems attractive. Somers gives this example of a Project Euler problem that inspired him:
If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.
I completely believe that Somers was inspired by this. I do not have an “itch” to solve this one. I don’t find mathematical puzzles that fun. I like to make things, so when I was getting started learning to program, I was motivated to play around and explore by building things. My first sizable just-for-fun program played tic-tac-toe, and most of my just-for-fun projects were interpreters and compilers. Today, I like to make interesting pictures and sounds with Media Computation. My experience doesn’t mean that Somers is wrong about Project Euler working for him. He’s wrong in believing it can work for everybody.
We need multiple paths. Math works to motivate some. Engineering for others. Media for still others. I agree that getting the playful learning that Somers wants is about engagement and motivation. Math doesn’t engage and motivate everyone.
Project Euler, named for the Swiss mathematician Leonhard Euler, is popular more than 150,000 users have submitted 2,630,835 solutions precisely because Colin Hughes — and later, a team of eight or nine hand-picked helpers — crafted problems that lots of people get the itch to solve. And its an effective teacher because those problems are arranged like the programs in the ORIC-1s manual, in what Hughes calls an “inductive chain”:The problems range in difficulty and for many the experience is inductive chain learning. That is, by solving one problem it will expose you to a new concept that allows you to undertake a previously inaccessible problem. So the determined participant will slowly but surely work his/her way through every problem.
via How I Failed, Failed, and Finally Succeeded at Learning How to Code – Technology – The Atlantic.
Visiting CMU: Historical Home of CS1-for-All
It’s Spring Break at Georgia Tech this week. Last week was crammed full of midterm grading. Now that it’s Spring, I’m traveling north to colder climates.
Today, I’m at Carnegie Mellon University to speak in their Program for Interdisciplinary Education Research (PIER) today, and at the “EdBag” tomorrow. I’m excited (and a bit nervous) — I’ve never spoken here at CMU before. Leigh Ann Sudol-DeLyser is my student host, and she gave me a great tour of the campus yesterday. For today’s talk, I’m giving a variation of my “Meeting the Computing Needs for Everyone” talk (describing Brian Dorn’s work and the role of contextualized computing education in this goal), but with special attention to the Alan Perlis lecture from 1961.
I re-read that chapter again yesterday. Wow — it’s really clear that the idea of teaching everyone an introductory course on CS has its home here, at the University that grew out of Carnegie Tech. While I had remembered that Peter Elias of MIT had pushed back against the idea of such a course as being unnecessary, I hadn’t remembered how J.C.R. Licklider and Perlis responded.
- Elias argues that programming is just a “mental chore” that the computer should be able to take care of for us: “If the computers, together with sufficiently ingenious languages and programming systems, are capable of doing everything that Professor Perlis describes—and I believe they are (and more)—then they should be ingenious enough to do it without the human symbiote being obliged to perform the mechanical chores which are a huge part of current programming effort, and which are a large part of what must now be taught in the introductory course that he proposes.”
- Licklider emphasizes what might be possible with this new kind of language. “Peter, I think the first apes who tried to talk with one another decided that learning language was a dreadful bore…But some people write poetry in the language we speak.”
- Perlis makes a really interesting pedagogical rebuttal. He says that what he really wants to teach are abstractions, and a course in programming is the best way he can think of doing that. He also says (not quoted below) that he has no evidence for this, but believes it strongly. “The purpose of a course in programming is to teach people how to construct and analyze processes…A course in programming is concerned with abstraction: the abstraction of constructing, analyzing, and describing processes…The point is to make the students construct complex processes out of simpler ones….A properly designed programming course will develop these abilities better than any other course.”
- John McCarthy (father of Lisp) also responded in opposition to Elias. “Programming is the art of stating procedures. Prior to the development of digital computers, one did not have to state procedures precisely, and no languages were developed for stating procedures precisely. Now we have a tool that will carry out any procedure, provided we can state this procedure sufficiently well. It is utopian to suppose that either English or some combination of English and mathematics will turn out to be the appropriate language for stating procedures.” Interesting how McCarthy and Licklider, as in Donald Knuth’s Turing award lecture, talk about programming as art.
Leigh Ann told me that the “EdBag” is a place to play with new and incomplete ideas. I’m planning to talk about the challenge of producing more high school CS teachers, including alternatives like Dave Patterson’s proposal. I’ve been thinking a lot about using a worked examples approach, informed by Ashok Goel’s structure-behavior-function model of design cognition.
Tomorrow, I fly to DC and spend two days reviewing NSF proposals. Still trying to get the rest of my proposals read today, and all the reviews written tonight. Thursday night, I’ll get back home to Atlanta where it really is Spring already.
Changing CS1 doesn’t help recruitment
Our experience at Georgia Tech matches the one at Brown. Changing CS1 can help keep the women who come in, but doesn’t draw new women in. Students get turned off to CS before they get to college, and improving CS1 can help with retention and attrition, but not recruitment from high school.
Those already on campus might be a different story. Barb had a great idea that she told me about yesterday — we should offer more Biology-inspired CS1-level courses like the great one at Harvey Mudd. Biology has way too many students for available jobs, and it’s female-majority. Let’s provide all those Biology students (who won’t get jobs in Biology) a better option.
The CS department also offers three introductory sequences, partially in hopes of attracting women. But offering many options likely has not affected the University’s numbers, Doeppner said. He said he doubts introductory courses “are scaring women off any more than they’re scaring men off.”
“The problem is not that women get disenchanted with CS when they get here — it’s that they aren’t coming here interested in computer science,” he said. “The perspective that people are getting is that a bunch of male hackers get together and just code all the time, which isn’t really computer science.”
via Algorithms can’t solve CS gender gap – The Brown Daily Herald.
What is Already ‘First’
Bertrand Myer did a Blog@CACM piece in response to my argument that there is no ‘first’ in CS1. I meant it in the sense that students have some idea of computation. Bertrand explored what his students already knew about programming, which is a subset of computation. He found that his students had mostly already had some programming experience, at least at ETH Zurich.
For the past eight years I have been teaching the introductory programming course at ETH Zurich, using the “inverted curriculum” approach developed in a number of my earlier articles. The course has now produced a textbook, Touch of Class [1]. It is definitely “objects-first” and most importantly contracts-first, instilling a dose of systematic reasoning about programs right from the start.
Since the beginning I have been facing the problem that Mark Guzdial describes in his recent blog entry [2]: that an introductory programming course is not, for most of today’s students, a first brush with programming. We actually have precise data, collected since the course began in its current form, to document Guzdial’s assertion.
via What ‘Beginning’ Students Already Know: The Evidence | blog@CACM | Communications of the ACM.
Predictions on Future CS1 Languages
A recent article in InfoWorld on up-and-coming languages got me thinking about the future of CS1 languages. They went on at some length about Python, which I think most people consider to be the up-and-coming CS1 language.
There seems to be two sorts of people who love Python: those who hate brackets, and scientists. The former helped create the language by building a version of Perl that is easier to read and not as chock-full of opening and closing brackets as a C descendant. Fast-forward several years, and the solution was good enough to be the first language available on Googles AppEngine — a clear indication Python has the kind of structure that makes it easy to scale in the cloud, one of the biggest challenges for enterprise-grade computing.Python’s popularity in scientific labs is a bit hard to explain, given that, unlike Stephen Wolframs Mathematica for mathematicians, the language never offered any data structures or elements explicitly tuned to meet the needs of scientists. Python creator Guido von Rossum believes Python caught on in the labs because “scientists often need to improvise when trying to interpret results, so they are drawn to dynamic languages which allow them to work very quickly and see results almost immediately.”
via 7 programming languages on the rise | Developer World – InfoWorld.
There have only really been three “CS1 languages,” the way that I’m using the term: Pascal, C++, and Java. All three programming languages were used in a large (over 50%) percentage of CS1 (intro CS for CS majors in post-secondary education in the US, and AP in high school) classes. All three were AP CS languages.
Pascal at one point was probably in over 80-90% CS1 courses. Not everyone jumped immediately to C++, but C++ was in the majority of CS1 classes. I know that because, when our Java MediaComp book came out, our publisher said that Java had just pulled even with C++ in terms of percent of the market — that means C++ had to have been in lots of classes. Java is the dominant language in CS1 classes today, but it’s declining. Python’s market share is rapidly growing, 40% per year the last three years. While it’s not clear that the new AP CS nor the AP CS Level A would ever adopt Python, Python might still gain the plurality of all CS1 languages. I doubt that any language will ever gain more than 30-40% of the CS1 market again — there are (and will be) too many options for CS1 languages, and too many entrenched interests. Faculty will stick with one, and may skip a plurality, e.g., I’ve talked to teachers at schools where they stuck with C++ but now are switching to Python.
I have two specific predictions to make about future CS1 languages, based on observations of the last three and the likely fourth.
- All future CS1 languages will be in common use in industry.
- No language will gain a plurality of CS1 courses unless it existed at the time of the last transition.
The transition from Pascal to C++ led to the greatest spike in AP CS Level A tests taken in Georgia. Until 2010, that was largest number of AP CS exams taken in Georgia. The transition from C++ to Java had nowhere near that kind of impact on the test numbers in Georgia. What might have led to so much more interest in the Pascal -> C++ transition? Pascal was a language that was not (perceived to be) common in industry, while C++ was. I don’t think that people perceived such a huge difference between C++ and Java. I believe that the sense that C++ was vocationally useful, was approved of by industry, had a huge positive impact on student interest in the test.
In this blog, we have often touched on the tension between vocational and academic interests in computer science classes. Vocational most often wins, especially in the majority schools. The elite schools might play with BYOB Scratch in their intro courses (but notice — even at Harvard and Berkeley, it’s for the non-majors, not for those who will major in CS), and community colleges might use Alice to ease the transition into programming, but the vast majority of schools in the middle value industry-approval too much to adopt a pedagogical language for their CS majors.
The implication of the first prediction is that, if Scratch or Alice are ever adopted for the new AP CS, only schools on the edges of the distribution will give CS major credit for it, because most schools will not adopt a CS1 language that isn’t useful for programming in industry. That isn’t necessarily a bad thing for the new AP CS — to succeed, schools must agree to give some credit for it, not necessarily CS major. Another implication is, if my prediction holds true, Scheme will never gain a plurality in CS1 courses.
The second implication is based on an observation of the timing of the four languages. Each existed as the previous was adopted for the AP CS Level A, which is a reasonable point at which to claim that the language had reached plurality. C++ existed (since 1983) when the AP CS Level A was started in Pascal (1988, I think). C++ was adopted in 2001, and Java came out in 1995. AP CS Level A shifted to Java in 2003, and Python 1.0 came out in 1989, with Python 2.0 (the one receiving the most interest) in 2000. It takes a lot of time to develop that industry use, and to build up the sense that the new language may be worth the pain in shifting.
The implication is that, whatever the next CS1 language will be (after Python), it exists today, as Python reaches plurality. Maybe Ruby, or Scala –more likely Ruby, given the greater industry penetration. Any language that we might invent for CS1 must wait for the next iteration. Scratch, Alice, and Kodu are unlikely to ever become CS1 languages, because it is unlikely that industry will adopt them. Few professional programmers will get their jobs due to their expertise in Scratch, Alice, or Kodu. That absolutely should not matter to CS1 instructors. But it does.
Especially In Computing: ‘Trust Us’ Won’t Cut It Anymore – Commentary – The Chronicle of Higher Education
Given that we have a track record of being unable to measure accurately our students’ achievement, I suspect that those of us in Computing are particularly susceptible to this criticism.
“Trust us.”
That’s the only answer colleges ever provide when asked how much their students learn.
Sure, they acknowledge, it’s hard for students to find out what material individual courses will cover. So most students choose their courses based on a paragraph in the catalog and whatever secondhand information they can gather.
No, there’s isn’t an independent evaluation process. No standardized tests, no external audits, no publicly available learning evidence of any kind.
Yes, there’s been grade inflation. A-minus is the new C. Granted, faculty have every incentive to neglect their teaching duties while chasing tenure—if they’re lucky enough to be in the chase at all. Meanwhile the steady adjunctification of the professoriate proceeds.
via ‘Trust Us’ Won’t Cut It Anymore – Commentary – The Chronicle of Higher Education.
There is no “First” in CS1
Andy diSessa has a great video that he sometimes shows in his talks, where he is interviewing a Physics Senior at Berkeley. He’s asking her what happens to ball being tossed from one hand to the other. She tells him a story about potential and kinetic energy. He points out that the ball traces a parabola — what happens to cause that shape? She tells him a story about horizontal and vertical velocity, and about acceleration due to gravity impacting the vertical velocity, but not the horizontal. He presses her further — what really happens at the very top of the arc? What causes the ball to change direction? Finally, she blurts out, “The air pressure! The air pressure pushes down on the ball forcing it to fall!”
Which is wrong. It’s a common alternative conception for falling objects. The student was certainly not taught that explanation at Berkeley. She developed it as a novice, as an observer of the world around her. She chose to major in physics — she must have had an interest in the physical world before coming to Berkeley. She observed the physical world, and developed theories about how it worked. Andy’s video shows that, despite her developing new understanding, the old belief system is still there.
Cognitive science shows that no student enters our class a blank slate. They enter undergraduate study with nearly two decades of experience, and theories that they have developed in those decades about how the world works. Those theories have allowed them to function on a daily basis. If they enter our computer science classroom voluntarily, then they have probably been an astute observer of computing mechanisms, and they have certainly developed theories about how the computing world works.
I have heard proponents of a wide variety of beliefs about the power of CS1:
- “If we teach them recursion first, then iteration becomes simple.”
- “If we teach them strong typing (or test-driven development, or functional programming), then they will have good practices of mind that will stick with them for the rest of their years.”
- “If we teach them objects first, then objects will be natural to them. We all can’t understand it the same way, because we learned imperative programming first.”
- “It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration.” (You probably recognize this one.)
I don’t know if any of them were once true, but I’m quite confident that none of them are true today. There is no first. There is no objects-first, functions-first, hardware-first, or non-Basic-first. No, I’m not suggesting that there already is computer science in high school — there are way too few teachers and classes for that to be true, on average. Rather, in a world where students live with Facebook and WiFi and email and “To The Cloud,” they most certainly have theories about how computing works. There’s no way to get them before they make up their theories. By the time they decide to study computing, they have them.
I thought of this looking at Carsten Schulte’s ITICSE 2010 paper, on studying student perceptions of difficulty in an objects-first vs. an objects-later class. This is a follow-up to his earlier ICER paper where he reported no learning differences between an objects-first and an objects-later class. While I’ve heard complaints about Schulte’s analysis methods, I found his experimental set-up to be as careful as one could possibly be. The only difference between his two classes were the order of topics. Objects-first vs. objects-later doesn’t matter, but neither does any other -first. His results are really not surprising. We already know that the sequence of topics in a curriculum doesn’t really seem to make much difference in the learning — that’s how problem-based learning works.
It’s an important open research question: How do students understand the computing around them? What theories do they have?
- How do students explain how a router box works, that my daughters get Wikipedia when they ask for it and I get WordPress when I ask for it, though there’s only one DSL connection and one router box in the house?
- How do the Chinese characters appear on my screen when I get an email from China — were the characters in the email, or in my computer?
- How is it that I can run Windows on my MacBook?
- What is on that CD that I put into my Wii, and how is it different from what’s on a DVD or a CD that works on my Mac or PC?
We know something about how novices develop naive theories of computing. John Pane’s research shows us that novices tend to develop declarative explanations of software that is driven by events, and don’t seem to develop notions of objects at all. The “Commonsense Computing” group has shown us that novices can create algorithms for a variety of problems, though that doesn’t really tell us how they think software and software development works in the world around them.
One problem that we have as educators is that this is a constantly open research question. Every new technological doohickey that students meet will lead to new theories about how technology works, sometimes requiring changes to old theories. Our students will have different theories depending on their computing experiences. That’s how all learning works — we meet a new situation, that we either assimilate into our understanding, or that we accommodate with a new theory. Over 50 years of cognitive science tells us that this is happening with every student who is paying attention to computing. If they enter into our CS classes, they are paying attention, they are making sense of the world around them, and they already have theories about how their computing technology works, how software works, and how software is developed.
We are in the same position as physics (or biology, or chemistry, or other science) educators. Students have theories about how Wii controllers, voicemail menu systems driven by spoken voice commands, touch screens, and Google/Bing search work. If these novice theories “mutilate” their minds, then it’s done, it’s happened to everyone, and we’d best just get on dealing with it. There is no chance to place a theory in their minds before they learn anything else. We have to start from where the students are, and help them develop better theories which are more consistent and more correct theories. There is no first, but we can influence next.
Slow change in CS1 Culture: China and Gates
I’m currently in China. Barb and I arrived in Beijing Wednesday night, visited the Great Wall and the Forbidden City on Thursday, and are now traveling to Jinan where I will be speaking on Saturday. For me, China feels the most foreign of any place I have visited. Qatar was very different, but China differs from my American expectations in everyday life in a way that Qatar didn’t, in values about food, money, time, and space.
I’ve been particularly thinking about culture since I read on the (unbelievably long) outbound flight a great interview with Melinda French Gates in the July/August issue of Smithsonian Magazine. It’s a special issue (that I’ve been working through very slowly), on the 40th anniversary of the magazine, about the next 40 years.
Q: You have referred to mistakes as “learning opportunities.” Which have had the greatest impact on your thinking?
One thing that was driven home on my last trip to India was how important it is to pair the best science with a deep understanding of traditional cultures. I was in Rae Bareli, a rural village in northern India, to see a project called Shivgarh. This is a Johns Hopkins research site that our foundation and USAID funded together, and the goal is to decrease infant mortality. The first six months of the Shivgarh project was spent on research to understand current newborn care practices, with a focus on identifying the practices that lead to neonatal deaths, and analyzing the perceptions on which these practices are based.
The researchers found that most mothers didn’t understand the importance of skin-to-skin contact, immediate breast feeding, or keeping the umbilical cord clean. However, by making analogies to important local customs, health workers were able not just to tell women what to do but also to explain why they should do it. In less than two years, Shivgarh has seen a 54 percent reduction in neonatal deaths in the target areas.
Gates does not actually answer the question about mistakes. Rather, she tells a story of a success–from taking into account cultural values, and introducing improvements as incremental changes in practice that still relate to those values. We’re left to wonder about what the mistake was that gave her this insight. What happens if you force change? Maybe the change doesn’t get adopted. Maybe the change leads to something worse.
I’m no anthropologist, so connections I draw are those of an amateur. I think Gates’ story may offer insights for us in computing education. Look at the history of CS1, seen in terms of what’s happened to the AP CS. First it was in Pascal, and then C++ and Java. Python is clearly gaining a foothold in CS1, and maybe it will be a language for the new AP CS. If we look at that sequence, it feels to me like a series of incremental changes that maintains certain values about what an introductory language should look like and what students should learn to do. Think about some of the options that have been explored for CS1 during this same time, like Scheme, or Prolog, or Smalltalk. None of those gained the momentum of the AP CS languages. Why not? Maybe those other languages were too radical a change. Maybe they challenged the cultural values of the majority of CS1 teachers. I can well believe that we might have much greater success (measured in your choice of measures) if we all adopted a radically different language. But we didn’t.
There’s a similar story to be told about how we teach CS1. Media computation challenges CS1 values about what we ask students to program. Most schools try Media Computation for their non-majors where it doesn’t challenge CS1 cultural values. Only a few (like UCSD and UIC) have tried it with their majors. Pair programming is popular, though not in the majority of CS1’s. I think it challenges CS1 teachers’ notions about the individual effort that CS1 students should make. Peer instruction and peer-lead team learning may make greater inroads because it doesn’t challenge CS1 culture in the same way, though it does challenge our sense of what a CS1 teacher does.
In Lijun Ni’s research, she found that the main factor influencing teacher’s adoption was the personal excitement or appeal that the approach has for the teacher. The research evidence did not matter at all to her subjects. That supports Gates’ view–it’s about appealing to currently held values, not about making a rational argument. Values trump reason, especially long-held values.
I don’t really know what leads to changes in values and culture. I suspect that it’s important to keep innovating, to keep challenging culture and values, and that that’s what leads to change. Gates suggests that, if you really want to make change happen in the short term, you figure out what the current values and practices are, and introduce change as an increment on those practices, explained in terms of those values. That may be frustrating if you don’t agree with the values. I’ll bet that Gates’ researchers didn’t agree with all the values they found in Rae Bareli, but that’s not the point. You work with what is there.
Call for Participation: Computing Commons Collaboration Conference
We are currently inviting you to submit a proposal for presentations and posters. Both high school computing teachers and undergraduate computing faculty are welcome to present by submitting a 1-page proposal. The deadline for submission for the first mini-conference is Nov 30th, 2010.
Call for Participation for the C3 Conference
- Your name, school name, e-mail address, a mailing address, and phone number
- Which session are you submitting for, discussion session or poster?
- Your proposal abstract with title, presenter(s) and the proposal for your presentation or poster. The proposal should include description of the objectives and content of your presentation and ways of involving the audience in the discussion.
Moti asks: Objects Never? Well, Hardly Ever!
Moti Ben-Ari told me at ICER that this piece was coming out in the September CACM, but I promised not to say anything here until it was out. I just saw that it’s been posted on the CACM website. I recommend reading the article. It’s a radically different perspective than objects-first or objects-late. He suggests “objects-never” or maybe “objects-graduate school.”
I claim that the use of OOP is not as prevalent as most people believe, that it is not as successful as its proponents claim, and, therefore, that its central place in the CS curriculum is not justified.
via Objects Never? Well, Hardly Ever! | September 2010 | Communications of the ACM.
Growth of Python in CS1
I just got a report from Tracy Dunkelberger of Pearson on the state of the Python CS1 market. The market size is estimated to be about 20,300 students per year, up 45% since last year. The market has had around 40% gains for each of the last three years. She also shared with me some market share data which she asked me not to share further — I think it’s sufficient to say that our Media Computation book isn’t the top book in the market, but is doing well.
Computing Ed Research - Guzdial's Take 
Recent Comments