Posts tagged ‘computing for everyone’
The article linked below makes the argument that then-Governor Ronald Reagan changed perception higher education in the United States when he said on February 28, 1967 that the purpose of higher education was jobs, not “intellectual curiosity.” The author presents evidence that date marks a turning point in how Americans thought about higher education.
Most of CS education came after that date, and the focus in CS Education has always been jobs and meeting industry needs. Could CS Education been different if it had started before that date? Might we have had a CS education that was more like a liberal education? This is an issue for me since I teach mostly liberal arts students, and I believe that computing education is important for giving people powerful new tools for expression and thought. I wonder if the focus on tech jobs is why it’s been hard to establish computing requirements in universities (as I argued in this Blog@CACM post). If the purpose of computing education in post-Reagan higher education is about jobs, not about enhancing people’s lives, and most higher-education students aren’t going to become programmers, then it doesn’t make sense to teach everyone programming.
The Chronicle of Higher Education ran a similar piece on research (see post here). Research today is about “grand challenges,” not about Reagan’s “intellectual curiosity.” It’s structured, and it’s focused. The Chronicle piece argues that some of these structured and focused efforts at the Gates Foundation were more successful at basic research than they were at achieving the project goals.
“If a university is not a place where intellectual curiosity is to be encouraged, and subsidized,” the editors wrote, “then it is nothing.”
The Times was giving voice to the ideal of liberal education, in which college is a vehicle for intellectual development, for cultivating a flexible mind, and, no matter the focus of study, for fostering a broad set of knowledge and skills whose value is not always immediately apparent.
Reagan was staking out a competing vision. Learning for learning’s sake might be nice, but the rest of us shouldn’t have to pay for it. A higher education should prepare students for jobs.
I buy Chris Granger’s argument here, that coding is not nearly as important as modeling systems. The problem is that models need a representation — we need a language for our models. The point is modeling, but I don’t think we can have modeling without coding. As Michael Mateas said, there will always be friction (see post).
We build mental models of everything – from how to tie our shoes to the way macro-economic systems work. With these, we make decisions, predictions, and understand our experiences. If we want computers to be able to compute for us, then we have to accurately extract these models from our heads and record them. Writing Python isn’t the fundamental skill we need to teach people. Modeling systems is.
Why programming in a non-majors, CS course is unlikely to lead to computational thinking (but is still a good idea): We must go beyond Intuition to Evidence
The March 2015 issues of Inroads (linked here) has a special section on “The role of programming in a non-major, CS course.” I was disappointed by several of the articles in the special section for making arguments without empirical evidence, and decided to write my February Blog@CACM article on the need for evidence-based practice in computing education (see post linked here).
I left out Henry Walker’s second article in the Blog@CACM post, and will discuss it here. In the first article, he argues against teaching programming because it would not leave enough time for other, more important topics. In the second one, he argues for teaching programming, if your learning objective is computational thinking.
If a non-majors course in computer science seeks to help students sharpen their skills in computational thinking, then students must be able to write solutions precisely. Further, students must be able to analyze the correctness of solutions and compare alternative solutions. Such work requires precision in writing. English or another natural language allows precision, but does not require precision.
Like in his first article, Henry offers no evidence for his claims. I do agree that programming requires greater precision than natural language. Henry argues for a value of the use of programming that is not supported by our research evidence.
If defined in sufficient detail, pseudo-code can enforce rigorous thinking, but pseudo-code cannot be run to check correctness or test efficiency. Ultimately, the use of a programming language is essential if computing courses are to help students sharpen their problem-solving skills.
In the decades of studies that have tried to find such transfer, the research evidence is that computing courses do not help students sharpen their problem-solving skills. I am not aware of studies that have rebutted David Palumbo’s 1990 review of the literature on programming and problem-solving (see paper reference here). It is possible to teach problem-solving skills using programming, but students do not gain general problem-solving skills from computing courses (with or without programming).
Henry’s evidence that this does happen is an anecdote:
An upper-level political science major who took my introductory computer science course indicated that her logical thinking in computer science had a clear payoff when she put arguments together for her papers in political science.
As a rationalization for a teaching decision, this is weak evidence. It’s self-report from a single student. The student probably did learn something interesting and useful from the class. Maybe the student did gain in logical thinking. Given the preponderance of evidence against general problem-solving skills coming from a programming class, I’m skeptical. Maybe she just saw her existing skills in a new light because of the computer science class — a useful learning outcome. In any case, is the positive experience of one student justification for designing a course for dozens or hundreds?
The conclusion of my Blog@CACM post still applies here. We don’t know what non-CS majors need or what they can learn. We shouldn’t just guess, because our intuition is very likely wrong — and it’s dangerous, since our experience (as mostly white, mostly male, CS faculty) is so different than those of most non-CS majors. We need the humility to admit that we don’t know. We must seek out evidence to inform our decision-making.
Ian Bogost believes that an “algorithmic society” is a myth, and believes that we treat algorithms as a religion.
I don’t want to downplay the role of computation in contemporary culture. Striphas and Manovich are right—there are computers in and around everything these days. But the algorithm has taken on a particularly mythical role in our technology-obsessed era, one that has allowed it wear the garb of divinity. Concepts like “algorithm” have become sloppy shorthands, slang terms for the act of mistaking multipart complex systems for simple, singular ones. Of treating computation theologically rather than scientifically or culturally.
This attitude blinds us in two ways. First, it allows us to chalk up any kind of computational social change as pre-determined and inevitable. It gives us an excuse not to intervene in the social shifts wrought by big corporations like Google or Facebook or their kindred, to see their outcomes as beyond our influence. Second, it makes us forget that particular computational systems are abstractions, caricatures of the world, one perspective among many. The first error turns computers into gods, the second treats their outputs as scripture.
I respond with another quote:
“And this is that decision which are going to affect a great deal of our lives, indeed whether we live at all, will have to be taken or actually are being taken by extremely small number of people, who are normally scientists. The execution of these decisions has to be entrusted to people who do not quite understand what the depth of the argument is. That is one of the consequences of the lapse or gulf in communication between scientists and nonscientists. There it is. A handful of people, having no relation to the will of society, having no communication with the rest of society, will be taking decisions in secret which are going to affect our lives in the deepest sense.”
That’s C.P. Snow in 1961 (Computers and the World of the Future, ed Martin Greenberger, MIT Press), talking about why everyone on campus should (explicitly) learn algorithms. He foresaw the “algorithmic culture” where algorithms control “a great deal of our lives, indeed whether we live at all.” He had two concerns. One was that the people writing those algorithms are making decisions when they implement them that don’t reflect social or political will. The second was that the “nonscientists” were unwilling to learn the algorithms. Explicitly, Snow’s argument was that those who don’t understand algorithms are at the mercy of those who do. His book, The Two Cultures, blamed the nonscientists for not making the effort to learn the science and algorithms so that they could participate in scientific discourse.
Today, Snow might agree with Bogost. When we don’t understand the algorithms that control our lives, we might see them as divine or magical. Arthur C. Clarke famously said, “Any sufficiently advanced technology is indistinguishable from magic.” The corollary (see here) is a better explanation of the phenomena that Bogost describes, ” Any technology, no matter how primitive, is magic to those who don’t understand it.”
I use the above quote in my talks on why we need computing for everyone. Snow is arguing that CS Education is a critical part of a functioning “algorithmic society.” If our social processes and rules are built into the software, not understanding algorithms keeps you from understanding and influencing the algorithms that control your life. Thomas Jefferson said, “An educated citizenry is a vital requisite for our survival as a free people.” Knowledge about computing is part of that education that keeps the citizenry free in today’s algorithm-driven world.
The onus to enable citizens to be free in an algorithm-driven world is on us in computer science, not on the citizenry alone. We have too much power to hide our algorithms behind interfaces and firewalls. We have a responsibility to make the computational world (and the algorithms that run it) accessible and understandable. As Diana Franklin said in her recent CACM essay (which I mentioned here), it’s up to computer science to make computing education work.
Both sides in this debate make good points. Of course, I’m on Pat Yongpradit’s side — computing education is very important and should be in all schools. But I totally see his opponent’s position (and I’ve made similar arguments myself about why the US is not ready for mandatory CS education): it’s expensive, teachers are not well-prepared, and it’s not obvious (to schools or teachers) how computer science helps with the primary goals of literacy and numeracy.
I’m not saying that elementary students are not capable of using or even mastering code. But I believe that really teaching — not just introducing — coding is simply beyond the scope of what most K-5 schools and their students are able to do, and it’s even asking a lot of middle schools when both lab time and class time are so limited. What’s more, pushing students into the study of abstract concepts before they are developmentally ready will not make them any more prepared for the rest of the 21st century than they are now.
I recommend this talk by Ben Shapiro. He does a great job framing his work in computing education research, and shows some terrific examples of his latest work. I like how his work fits so well into both computing and education — he’s using education theory to help students learn important ideas in CS from distributed systems and parallelism (like latency and synchronization) that aren’t yet in the CS standards. This is using advanced knowledge in CS and advanced knowledge in Education to explore new ground.
Programming with Pseudocode, Keeping Student Interest, the Need for School, and International Curricula: Trip Report on WiPSCE 2014
First week of this month, Barb and I went to Berlin for WiPSCE 2014 conference. See the program here and the proceedings here, and the post on my keynote here. Let me tell you about some of the interesting things I heard there.
We heard about so many international CS curricula efforts. Tim Bell talked about different levels of programming activity going on in different curricula (all the images in this blog post are from me snapping pictures of presentations).
We heard about Austrian efforts, Flemish efforts, and programs I was aware of in the UK, New Zealand, Germany, Israel, and the United States. I had not previously hear much about Poland in CS Ed, but they’ve been including computing in their curriculum for a long time.
Quintin Cutts (Code or (not Code) – Separating Formal and Natural Language in CS Education) talked about a problem that they’re having in Scotland that we’re also facing in the US with the CS Principles effort. There are several different programming languages in use in schools. Nobody wants to be the bad guy to say “You have to use X (maybe Scratch? Alice? App Inventor? Python?), because that’s what the national test will be in.” So, national test-developers are creating pseudocode languages that aim to be understandable without getting hung up on syntax. Scotland has one that’s made up of bits and pieces of other languages (which they call “Haggis” — seriously!). The problem is that if a piece of code is never expected to run, it can have assumptions within it that would have to be cleared up to build a runtime system. Quintin showed how even simple examples of the pseudocode from their national test have all kinds of logical inconsistencies.
It’s a real problem. Allison Elliott Tew’s dissertation (see here for post) showed that weakest performing students had the worst time transferring their knowledge from whatever language they learned to a pseudo-code. That means that your top students are going to be fine with a pseudo-code test, but your bottom students are not going to do well at all — they won’t know all the concepts, and they’re going to trip over the language. A pseudo-code test is going to be another barrier to underprepared students getting into CS.
Now, once you get them in the door, how do you keep them there? One interesting paper (Scratch vs. Karel – Impact on Learning Outcomes and Motivation) compared student interest in using Scratch or Karol the Robot. Scratch is a blocks-based language, and Karol was programmed in a text-based language. Students liked Scratch and performed better with it, but felt that Karol was more “real-life” and thus was more motivating for doing more in CS later. Betsy DiSalvo found similar results with her Glitch students. When comparing Alice and Python, students liked what they could produce with Alice, but felt that Python was more like what real programmers did and was consequently more motivating for some students. This paper has had me thinking, “Maybe we should bring Logo back?” It’s text-based like Karol, designed for students, and we have LOTS of books and other materials available for Logo across the curriculum.
Leigh Ann DeLyser talked about her work with CS NYC (Software Engineering Students in the City). It’s a remarkable program: 1900 students applied for 120 slots, and the selection among the qualified students was by lottery. They did pre and post surveys around the first year of the program, with questions like “Would you like to study CS or SE after this semester?” or “Want to be a computer scientist or software engineer one day?” Females lost much more interest in a future computing career then males.
Finally, the talk that has most been in my thoughts since the conference was by Debby Fields and Yasmin Kafai on their Scratch study (Programming in the Wild: Patterns of Computational Participation in the Scratch Online Social Networking Forum). They studied 5000 visitors to the Scratch website in the first quarter of 2012. First big finding — most of them don’t do much. 55% visit but don’t do anything. The other 45% engage at a variety of levels, and the levels are pretty much gender-balanced. The most active participants are about evenly split male-female.
Debbie and Yasmin defined four “classes” of programming activity based on the programs that these users uploaded to the Scratch website. Booleans are a big differentiator, as are variables and random numbers. The below figure describes how much of each kind of programming block appears in each class of programs, and what percentage of programs they saw land in each class.
Here’s the disappointing part: The highest level of programming activity was almost all boys. Girls don’t go much beyond the simplest programming.
Now, we don’t know much about ages or where these students are or their ethnic group. As Debby pointed out, age and location are self-reported on the Scratch website, and it’s remarkable how many 100 year old Scratch programmers there are in Antartica. Their data suggest that informal education activities like Scratch (or Kahn Academy or MOOCs) are unlikely to reach a broad range of users. Debby pointed out that what students are building influences what students do. If Scratch programmers can tell stories without booleans, how do you motivate more advanced programming actvities if they’re only story-telling? If we want to reach more diverse students, and we want to encourage more kinds of activities, we need school. We need formal education to reach everyone.