Posts tagged ‘computational thinking’

Computing Education Lessons Learned from the 2010’s: What I Got Wrong

There’s a trend on Twitter over the last few weeks where people (especially the academics I follow) tweet about their accomplishments over the last 10 years. They write about the number of papers published, the number of PhD students graduated, and the amount of grant money they received. It’s a nice reflective activity which highlights many great things that have happened in the 2010’s.

I started this blog in June 2009, so most of it has been written in the 2010’s. The most interesting thing I find in looking back is what I got wrong. There were lots of things that I thought were true, ideas that I worked on, but I later realized were wrong. Since I use this blog as a thinking space, it’s a sign of learning that I now realize that some of that thinking was wrong. And for better or worse, here’s a permanent Internet record.

There are the easy ones — the ones I’ve been able to identify in blog posts as mistakes. There was the time I said Stanford was switching from Java to JavaScript. I should have fought for more CS in the K-12 CS Framework. And I should have been saying “multi-lingual” instead of “language independent” for years. And there was the blog post where I just listed the organizational mistakes I’d made.

The more interesting mistakes are the ones that are more subtle (at least to me), that took me years to figure out, and that maybe I’m still figuring out:

Creating pre-service CS teacher programs would be easy. I thought that we could create programs to develop more pre-service computer science teachers. We just needed the will to do it. You can find posts from me talking about this from 2010 and from 2015. I now realize that this is so hard that it’s unlikely to happen in most US states. My Blog@CACM post this month is about me getting schooled by a group of education faculty in December. We are much more likely to integrate CS into mathematics or science teacher programs than to have standalone CS teacher professional development — and even that will require an enormous effort.

CS for All is about Access. I used to think that the barrier to more students taking CS was getting CS classes into high schools. You can find me complaining about how there were too few high school CS classes in 2016. I really bought into the goal of CS10K (as I talked about in 2014). By 2018, I realized that there was a difference between access and participation. But now we have Miranda Parker’s dissertation and we know that the problem is much deeper than just having teachers and classes. Even if you have classes, you might not get students taking them, or it may just be more of the same kinds of students (as the Roehampton Report has shown us). Diverse participation is really hard.

Constructionism is the way to use computing in education. I grew up as a constructionist, both as a “technically precocious boy” and as a researcher. Seymour Papert wrote me a letter of recommendation when I graduated with my PhD. My post on constructionism is still one of the most-read. In 2011, I thought that the One Laptop Per Child project would work. I read Morgan Ames’ The Charisma Machine, and it’s pretty clear that it didn’t.

The idea of building as a way of learning makes sense. It’s at the heart of Janet Kolodner’s Learning by Design, Yasmin Kafai’s work, Scratch, and lots of other successful approaches. But if you read Seymour carefully, you’ll see that his vision is mostly about learning mathematics and code, through teaching yourself code. That only goes so far. It doesn’t include everyone, and at the worst implementations of his vision, it leaves out teachers.

I was in a design meeting once with Seymour, where he was arguing for making a new Logo implementation much more complicated. “Teachers will hate it!” several of us argued. “But some students will love it,” he countered. Seymour cared about the students who would seek out technical understanding, without (or in spite of) teachers, as he did.

Constructionism in the Mindstorms sense only works for a small percentage of students, which is what Ames’ story tells us. Some students do want to understand the computer soup-to-nuts, and that’s great, and it’s worthwhile making that work for as many students as possible. But I believe that it still won’t be many students. Students care about lots of other things (from business to design, from history to geography) that don’t easily map to a focus on code and mathematics. I still believe in the value of having students program for learning lots of different things, but I’m no longer convinced that the “hard fun” of Logo is the most useful or productive path for using the power of computing for learning. I am less interested in making things for just a few precocious students, especially if teachers hate it. I believe in making things with teachers.

The trick is to define Computational Thinking. Then there’s Computational Thinking. I thought that the problem was that we didn’t have a clear definition. If we had that, we could do studies in order to measure the value (if any) of CT. I blogged about definitions of it in 2011, in 2012, in 2016, and in 2019. I’ve written and lectured on Computational Thinking. The paper I wrote last Fall with Alan Kay, Cathie Norris, and Elliot Soloway may be the last that I will write on CT. I realized that CT is just not that interesting as a research topic (especially with no well-accepted definition) compared to the challenge of designing computation for better thinking. We can try to teach everyone about computational thinking, but that won’t get as far as improving the computing to help everyone’s thinking. Fix the environment, not the people.

But I could be wrong on that, too.

January 13, 2020 at 7:00 am 46 comments

We should be emphasizing design of computing over teaching computational thinking

Alan Kay, Cathie Norris, Elliot Soloway, and I have an article in this month’s Communications of the ACM called “Computational Thinking Should Just Be Good Thinking.” (See link here, and a really nice summary at U-M which links to a preprint draft.) Our argument is that “computational thinking” is already here — students use computing every day, and that computing is undoubtedly influencing their thinking. But that fact is almost trivial. What we really care about is effective, critical, “expanded” thinking where computing can play a role in helping us think better. To do that, we need better computing.

It’s more important to improve computing than to teach students to think with existing computing. The state of our current tools is poor. JavaScript wasn’t designed to be learnable and to help users think. (Actually, I might have just stopped with “JavaScript wasn’t designed.”) We really need to up our game, and we should not be focusing solely on how to teach students about current practices around iteration or abstraction. We should also be about developing better designs so that we spend less time on the artifacts of our current poor designs.

Ken Kahn called us out, in the comments at the CACM site, suggesting that general-purpose programming tools are better than building specialized programming tools. I wrote a Blog@CACM post in response “The Size of Computing Education, By-The-Numbers.” We have so little success building tools that reach large numbers of students that it doesn’t make sense to just build on our best practice. They may all be local maxima. We should try a wide variety of approaches.

I got asked an interesting question on Twitter in response to the article.

Do you think @Bootstrapworld and @BerkeleyDataSci Data 8 modules both embody your philosophy?

I don’t think we’re espousing a philosophy. We’re suggesting a value for design and specifically improved design of computing.

Bootstrap clearly does this. The whole Bootstrap team has worked hard to build, iterate, test, and invent. If you haven’t seen it, I recommend Shriram Krishnamurthi’s August 2019 keynote at the FCRC. They solved some significant computer science design problems in creating Bootstrap.

Berkeley’s Data 8 is curriculum about existing tools, R and Jupyter notebooks. That’s following an approach like most of computational thinking — the focus is on teaching the existing tools. That’s not a bad thing to do, but you end up spending a lot of time teaching around the design flaws in the existing tools. I just don’t buy that R or Jupyter notebooks are well-designed for students. We can do much better. LivelyR (see link here) is an example of trying to do better.

We should be teaching students about computing. But computing is also the most flexible medium humans have ever invented. We should be having an even greater emphasis on fixing, designing, and inventing better computing.


Many thanks to Barbara Ericson, Amy Ko, Shriram Krishnamurthi, and Ben Shapiro who gave me comments on versions (multiple!) of this essay while it was in development. They are not responsible for anything we said, but it would be far less clear without them. The feedback from experts was immensely valuable in tuning the essay. Thanks!

November 13, 2019 at 2:00 am 5 comments

What’s NOT Computational Thinking? Curly braces, x = x + 1, and else.

In the previous blog post, I suggested that Computational Thinking is the friction necessary to make your problem solvable by a computer. It should be minimized unless it’s generative.  It’s a very different framing for computational thinking.  Rather than “what’s everything that we use in computing that might be useful for kids,” it’s closer to, “the day is full and students are already in so many subjects — what do they have to know about computing in order to use it to further their learning and their lives?”

What is NOT Computational Thinking

I have been talking to my students about what’s on the list of things that we typically teach but don’t fit into this model of computational thinking. Here’s what I’ve thought of so-far:

Here are criteria for what should NOT be part of teaching computational thinking:

  • These are hard for students — why go to that extra effort unless it’s worthwhile?
  • We have invented ways of framing problems for a computer that do not use these things, so they’re not necessary.
  • They are not generative. Knowing any of these things does not give you new leverage on thinking about problems within a domain.

If Computational Thinking is something we should teach to everyone, these are items that are not worth teaching to everyone.

Computational thinking includes programming, for me. It is generative.  It allows students to explore causal models that are tested with automation.  It’s the most powerful idea in computational thinking.

What is Computational Thinking for OTHER subjects

Then there are the ideas that are on most lists of computational thinking, like decomposition and abstraction. I absolutely believe that all programmers have those skills. They are absolutely generative. I believe that programming is a terrific place to try out and play with those ideas.

In the Rich et al. paper about learning trajectories that I reference so often, they talk about students learning “Different sets of instructions can produce the same outcome.” That’s a critical idea if you want students to learn that different decompositions can still result in the same outcome.

But does abstraction and decomposition belong in a Computational Thinking class?  They feel more like mathematics, science, and engineering to me.  Yes, use computing there, but don’t break them out into a separate class.  A mathematics teacher may be better prepared to teach decomposition and abstraction than are computer science teachers. It’s better to teach these ideas in a context with a teacher who has the PCK to teach them.

What’s more, it’s clear that you don’t need abstraction and decomposition to program computers as a way to learn.  Task-specific programming languages are usable for learning something else without developing new abilities to abstract or decompose. Our social studies teachers did in our participatory design study in March — they learned things about life expectancy in different parts of the world, using programming that they did themselves, in 10-20 minutes.

What is Computer Science that EVERYONE should know

There’s another list we could make that is ideas in computer science that everyone should know because it helps them to understand the computation in their lives.  Yes, there’s a lot in the school day — but this is worth it for the same reason that Physics or Biology is worth it. This is a different matter than what helps them solve problems (which is the guts of the computational thinking definitions we have seen earlier).  On my list, I’d include:

  • Bits, the atom of information processing.
  • Processes, what programs allow us to define.
  • Programming, as a way to define processes.

Other suggestions?

  • What’s on your list for what’s NOT necessary in Computational Thinking, and
  • What is in Computer Science that everyone needs but is not Computational Thinking?

May 3, 2019 at 7:00 am 37 comments

A new definition of Computational Thinking: It’s the Friction that we want to Minimize unless it’s Generative,

David Benedetto wrote a blog post about computational thinking for CSTA that gave me new insight into Computational Thinking (thanks to Shuchi Grover whose tweets drew me to it):

http://advocate.csteachers.org/2019/02/27/situated-computational-thinking/

David says:

I think this definition of CT is as good a starting point as any:

Computational Thinking is the thought processes involved in formulating problems and their solutions so that the solutions are represented in a form that can be effectively carried out by an information-processing agent (Cuny, Snyder, Wing, 2010).

He evolves this position until, like Shuchi, he comes up with two definitions of CT:

What are the implications of this? I think there are two clear options for how we define CT:

(A) Restrict what we mean by CT. This is perfectly reasonable and probably necessary for most practical purposes. However, this has the inevitable consequence of fragmenting our understanding of CT. There will be different CTs in different disciplines / fields. We will do this, but we should try to understand the restrictions that we are imposing, and the consequences of imposing them.

(B) Break our concept of CT wide open. I think the scientific community (at least, those who are studying the construct of CT and how it plays out in real cultural contexts) should do this, so that we can explore how CT is understood and practiced in a variety of contexts and for a wide range of purposes.

As a researcher, I’m more in favor of the former — let’s define Computational Thinking precisely.  David’s concern is really about the social context around CT. People want to call lots of things Computational Thinking. Can we come up with a definition for CT that bridges these? That represents the discipline-specific uses of CT, and is well enough defined that we can actually measure something about it?

There are many other “thinkings” that lay claim to providing students with critical skills. Admiral Grace Hopper would likely support “mathematical thinking” more than “computational thinking,” as this interesting essay from Yale points out. Skills like “decomposition” or “abstraction” are included in many definitions of computational thinking (eg this blog post), and it’s true that you need those in computing.  But those skills first belonged to mathematics, engineering, and science, and I’d argue that the teachers in those subjects might be in a better position to teach them and to measure them. Computation can play an important role in learning decomposition and abstraction, but those skills don’t belong uniquely to computation, or to a class on computational thinking. So, what is unique about computation?

The tension between HCI and Computational Thinking

On the computer science side of my life, my research community is human-computer interaction.  I’ve published in CHI, DIS, CSCW, VL/HCC, and UIST. The Cuny, Snyder, and Wing definition is hard for me to reconcile with being an HCI researcher.  The point of HCI research is to minimize the amount that a user has to learn in order to “formulate problems and their solutions so that the solutions are represented in a form that can be effectively carried out by an information-processing agent.”  HCI is trying to make it easier for the user to think with a computer whatever they want to think about. Computational Thinking is about what you need to think with a computer.

Over the last few weeks in this blog, I’ve been exploring the notion of task-specific programming languages. I was amazed at how much social studies teachers could do with Vega-Lite in a participatory design session we ran in early March. Sarah Chasin’s work with Helena and Rousillon is absolutely stunning for how much people could achieve with no training. Hariharan Subramonyam sent me this fascinating essay on end-user programming and about how to minimize the effort it takes end users to start programming: https://www.inkandswitch.com/end-user-programming.html. As I talked about in my SIGCSE 2019 keynote, Bootstrap:Algebra and most uses of Scratch actually rely on a small number of computational ideas. There is expressive and learning power in even a small amount of computation.

Michael Mateas wrote an essay back in 2009 that has been influential in my thinking. I blogged about it here: “There will always be friction.” Michael looked at the Alan Perlis talk of 1961 (that I talk and write about often), and particularly, at the exchange with Peter Elias. Elias argued that students shouldn’t have to learn to program — the computer should learn to understand us. Both Perlis and Mateas disagree. The computer can never understand us completely. We have to smooth the communication because the computer cannot. There will always be a challenge to human-computer interaction. There will always be friction, and it’s the human’s job to manage that friction..

A New Definition for Computational Thinking

So, here’s my new take on Computational Thinking: It’s the friction. Let’s take the original Cuny, Snyder, and Wing definition — computational thinking is about framing problems so that computers can solve them. The work around task-specific programming languages is showing us that we can make that amount that the user has to learn in order to use programming for their problem very small.

To meet Alan Kay’s point about generativity, there are some things in computing that we want to teach because they give us new leverage on thinking. We want to teach things that are useful, but not those that are necessary just because we have bad user interfaces.

A minimal definition of Computational Thinking: The stuff that we have to learn in order to communicate our tasks with a computer. It should be small, and the part that we learn should be generative, useful for new problems and new thinking. Everything else should be eliminated by good user interfaces.

You don’t have to master abstraction and decomposition just to use a programming language to help you learn. Our social studies teachers modified Vega-Lite programs, made mistakes (every single one of them) and recovered from them, and tried new things that they figured out on their own — all in 10-20 minutes. They already have problem solving skills. They didn’t need any “computational problem solving skills.” They certainly didn’t learn any special computational abilities to abstract and decompose in 10 minutes. They already know enough to use programming to learn. If we can eliminate the need for a particular skill in order to use computing to learn something else, we should.

This meshes with David Weintrop and Uri Wilesnky’s definition — it’s the computational practices of actual scientists and engineers who use computing. Their definition is particularly strong because it’s empirically grounded. They asked computational scientists and engineers what they actually do. Weintrop and Wilesnky’s participants want to do their work, not programming for its own sake. So they use a minimal subset of computing that buys them something for their thinking and in their tasks.

I like this definition because it’s aspirational.  Today, there’s a lot of stuff that you have to learn to use a computer to solve problems. Philip Guo gave a talk here at Michigan recently (similar to one he gave at U-W) and described how data scientists have to become system administrators to manage all the various packages and databases to do their job.  That’s a problem. That’s not computational thinking. That’s stuff to get rid of. How small can we make computational thinking?

 

April 29, 2019 at 7:00 am 14 comments

The Ground Truth of Computing Education: What Do You Know?

Earlier this month, I was a speaker at a terrific event at Cornell Tech To Code & Beyond: Thinking & Doing organized by Diane Levitt (see Tweet here). I spoke, and then was on a panel with Kelly Powers, Thea Charles, Aman Yadav, and Diane to discuss what is Computational Thinking.

One of the highlights of the day for me was listening to Margaret Honey, a legendary educational technology designer and researcher (see bio here). She is President and CEO of the New York Hall of Science. One of my favorite parts of her talk was a description of the apps that they’re building to get kids to notice and measure things in their world. I even love the URL for their tools — https://noticing.nysci.org/

At the event, Diane mentioned that she was working on a blog post about her “ground truth” — what she most believed about CS education. She shared it as a tweet right after the event. It’s lovely and deep — find it here.

A couple of my favorite of her points:

Students thrive when we teach at the intersection of rigor and joy. In computer science, it’s fun to play with the real thing. But sometimes we water it down until it’s too easy—and kids know it. Struggle itself will not turn kids away from computer science. They want relevant learning experiences that lead to building things that matter to them. “I can do hard things!” is one of the most powerful thoughts a student can have.

The biggest lever we have is the one we aren’t using enough yet: preservice education for new teachers. The sooner we start teaching computer science education alongside the teaching of math and reading, during teachers’ professional preparation programs, the sooner we get to scale. It’s expensive and time-consuming to continually retool our workforce. Eventually, if every teacher enters the classroom prepared to include computer science, every student will be prepared for the digital world in which they live. This is what we mean by equity: equal access for every student, regardless of geography, gender, income, ability, or, frankly, interest.

Sara Judd answered Diane’s post with one of her own — find it here. I really enjoy it because she sees computer science like I do. It’s not just about problem-solving, but also about making things and connecting to the world.

Programming makes things.

While programming for it’s own sake can be fun for some people, (me, for instance) generally when people are programming it is because there is a thing that needs to be made. These things can be expressive pieces of visual art or music. These things can be silly fun for fun’s sake. These things can revolutionize the world, they can make our lives easier. The important thing is, they are “things.” CS doesn’t exist in a vacuum. Therefore, classroom CS should not exist in a vacuum.

I encourage more of us to do this — to write down what we believe about CS education, then share the essays. It’s great to hear goals and perspectives, both to learn new ones and also to recognize that others share how we think about it. I particularly enjoy reading these from people with different life experiences. I have a privileged life as a University CS professor. Teachers in K-12 struggle with very different things. I’m so pleased when I find that we still have similar goals for and perspectives about CS education.

January 28, 2019 at 7:00 am 1 comment

Computational thinking abstracts too far from the computer: We should teach CS with inquiry

Judy Robertson has a blog post that I really enjoyed: What Children Want to Know About Computers. She argues that computational thinking has abstracted too far away from what students really want to know about, the machine.

Computational thinking has been a hugely successful idea and is now taught at school in many countries across the world. Although I welcome the positioning of computer science as a respectable, influential intellectual discipline, in my view computational thinking has abstracted us too far away from the heart of computation – the machine. The world would be a tedious place if we had to do all our computational thinking ourselves; that’s why we invented computers in the first place. Yet, the new school curricula across the world have lost focus on hardware and how code executes on it.

Her post includes pictures drawn by children about what they think is going on inside of the computer.  They’re interested in these things!  We should teach them about it.  One of the strongest findings in modern science education is that inquiry works. Students learn science well if it’s based in the things that they want to know. Judy argues that kids want to know about the computer and how code executes on the computer. We shouldn’t be abstracting away from that. We should be teaching what the kids most want to learn.

To be clear, I am not criticizing the children, who were curious, interested and made perfectly reasonable inferences based on the facts they picked up in their everyday lives. But I think that computer science educators can do better here. Our discipline is built upon the remarkable fact that we can write instructions in a representation which makes sense to humans and then automatically translate them into an equivalent representation which can be followed by a machine dumbly switching electrical pulses on and off. Children are not going to be able to figure that out for themselves by dissecting old computers or by making the Scratch cat dance. We need to get better at explicitly explaining this in interesting ways.

December 10, 2018 at 7:00 am 3 comments

Maybe there’s more than one kind of Computational Thinking, but that makes research difficult

Shuchi Grover has a nice post in Blog@CACM where she suggests that there is more than one kind of Computational Thinking, which tries to resolve some of the concerns about the term (some of which I discussed here):

It’s also clear to me that in order to help make better sense of CT, we must acknowledge and distinguish two views of CT for K-12 education that are defined and operationalized based on the context for teaching/learning/application. One is a view of CT as a thinking skill for CS classrooms, that includes programming and other CS practices with the goal of highlighting authentic disciplinary practices and higher-order thinking skills used in computer science. The other is CT as a thinking skill/problem-solving approach in non-CS settings—this is often about using programming to automate abstractions of phenomena in other domains or work with data with the goal of better understanding phenomena (including making predictions and understanding potential consequences of actions), innovating with computational representations, designing solutions that leverage computational power/tools, and engaging in sense making around data.

She says that their are two “views” of CT, but she does distinguish Wing’s original definition which most people don’t buy. So, it seems like there are three.  (Kudos to Shuchi for pointing out that Seymour Papert actually uses the phrase “computational thinking” in Chapter 8 of Mindstorms — so cool!)

But I’m still wondering: Why do we have to call all of these things “computational thinking”?  I get that there’s a lot of energy around the term, but it’s an overloaded term.  Think about it from the perspective of any other science.  If you discovered that a species of animal or bacteria you were studying was actually two species, you’d name them differently.  In the 19th century, physicists thought that light traveled through a “luminiferous aether,” but now, nobody uses that term because we realized that such a thing didn’t exist. Maybe we as scientists should invent some new and more accurate terms instead of overloaded and confusing “computational thinking”?  If we’re using “computational thinking” because it has marketing cachet with teachers and principals (even if the term isn’t useful to researchers), that makes it hard to have a science around computing education.  Do we write about CT Type-1 vs CT Type-2?

December 7, 2018 at 7:00 am 17 comments

Literature is to Composition, as Computer Science is to Computational Literacy/Thinking

Coding_Literacy___The_MIT_Press

Annette Vee was visiting in Ann Arbor, and looked me up. We had coffee and a great conversation.  Annette is an English Professor who teaches Composition at University of Pittsburgh (see website here). She published a book last year with MIT Press, Coding Literacy: How Computer Programming is Changing Writing. (I’m part way through it and recommend it!) She knew me from this blog and my other writing about computational literacy. I was thrilled to meet someone who makes the argument for code-as-literacy with a real claim to understanding literacy.

One of the themes in our conversation was the distinction between literature and composition.  (I’m going to summarize something we were talking about — Annette is not responsible for me getting things wrong here.) Literature is about doing writing very well, about writing great works that stand the test of time. It’s about understanding and emulating greater writers.  Composition is about writing well for communicationIt’s about letters to Grandma, and office memos, and making your emails effective.  Composition is about writing understandable prose, not great prose as in literature. People in literature sometimes look down on those in composition.

There’s a similar distinction to be made between computer science as it’s taught in Universities and what Annette and I are calling coding/computational literacy (but which might be what Aman Yadav and Shuchi Grover are calling computational thinking).  Computer science aims to prepare people to engineer complex, robust, and secure systems that work effectively for many users. Computational literacy is about people using code to communicate, to express thoughts, and to test ideas. This code doesn’t have to be pretty or robust. It certainly shouldn’t be complex, or nobody will do it. It should be secure, but that security should probably be built into the programming system rather than expecting to teach people about it (as Ben Herold recently talked about).  People in computer science will likely look down on those teaching computational literacy or computational thinking. That’s okay.

Few people will write literature. Everyone will compose.

November 23, 2018 at 7:00 am 41 comments

Novum Organum: The original “How To Not Be Wrong”

When I visited with Alan Kay and Bonnie MacBird in June, one of the ideas that he got me thinking about was Sir Francis Bacon’s Novum Organum (1620, wikipedia link), for ‘new instrument of science.’ Bacon understood human tendencies for bias long before behavioral economics. His book was the prototype for the modern popular book “How to Not Be Wrong: The Power of Mathematical Thinking” which advocates for mathematics as an approach to addressing human biases and limitations.

Bacon aimed to construct a foundation for real science, a body of knowledge that we could trust despite the fact that our minds are weak and that we are easily swayed. He lists four “idols” — the biases which keep us from thinking objectively and scientifically. Wikipedia has a short description for each. A couple that I found particularly striking:

  • Idols of the tribe: The things we get wrong because we like to see things at human scale and in regular structures. I read these as including the ideas we like because everyone else likes them, like picking a programming language because it’s popular and not because it suits the task.
  • Idols of the cave: The things we get wrong because of our unique education and background. Bias due to privilege (and assuming that everyone else has the same privilege) seem to fall in here.
  • Idols of the market: I just kept thinking “computational thinking” here. Idols of the market include words “which spring from fallacious theories” and “that are the result of imprecise abstraction.”  Unsupported theories of transfer and terms which we can’t actually define and test are part of Bacon’s warnings about “the market.”

I haven’t read the whole document — it’s available on Project Gutenberg, but it’s tough going.  I have found that Bacon talks about issues not in the Wikipedia article that are are significant today. For example, Bacon decries making decisions based on too “few experiments” which is explicitly a concern addressed in the efforts to replicate prior results (e.g., article here).

I keep thinking about what Bacon would say about computing education research. CER has some deep research questions it’s pondering (which I plan to address in some future blog posts). How do we make sure that we’re doing Science and not just following our Baconian idols?

October 29, 2018 at 7:00 am 2 comments

Teaching Computational Thinking across an Entire University, With Guest Blogger Roland Tormey

During Spring Break, Barbara and I were invited to go to Switzerland.  Sure, when most people go someplace warm for Spring Break, let’s head to the mountains!

Roland Tormey organized a fascinating workshop at EPFL in Lausanne, Switzerland (see workshop page here) to inform a bold and innovative new effort at EPFL. They want to integrate computational thinking across their entire university, from required courses for freshman, to support for graduate students doing Computational X (where X is everything that EPFL does).  The initiative has the highest level of administrative support, with the President and Vice-President of Education for EPFL speaking at the workshop.  The faculty really bought in — the room held 80-some folks, and it was packed most of the day.

Roland got a good videographer who captured both of the keynotes well.  I had the first keynote on “Improving Computing Education with Learning Sciences: Methods for Teaching Computing Across Disciplines.”  I argued that we need different methods to teach computing across the curriculum — we can’t teach CS the same way we teach CS majors as future software developers.  I talk about Media Computation, predictions (and they caught my audio demo with ukulele playing well), subgoal labeling, and Parsons problems.

Shriram Krishnamurthi had the second keynote on “Curriculum Design as an Engineering Problem.”  He talked about the problems of transfer and how Bootstrap works.  I liked how he broke down the problem of transfer — there there are three requirements: Deep structural similarities between the problems, explicit instruction, and a process for performing tasks.  He showed how all other design disciplines have multi-stage processes, use multiple representations in their designs, and look at problems from multiple viewpoints.  Mostly in CS classes, we just code.  I learned about how Bootstrap scaffolds problem-solving, and includes all of those elements.  I recommend the talk.

Barb’s panel on teaching computational thinking wasn’t captured.  She talked about the methods she’s developed for teaching computing, including her great results on Parsons problems.  In a short talk, she gave a lot of pointers to her work and others’ on how to teach CT.

Roland sent me a note with what he took away from the workshop. I thought it was a great list, so with his permission, I’m including it here:

For me, we also had a lot of other valuable take home points from the day:

(1) We need to work on putting Computational thinking (and maybe Math and Physics too) into the context of the students’ own disciplines — at least, though the examples and exercises we choose.

(2) The drive to better develop scientific thinking in disciplines like chemistry and life sciences and the development of CT are entirely consistent, but one shouldn’t eclipse the other. It’s not about replacing existing scientific processes with CT. It’s about augmenting them.

(3) We need to help professors gather data on effective methods of teaching as well as help them become aware of methodologies with demonstrated effectiveness (like the Parsons Problems for example).

(4) The exercises and exercise sessions will be crucial for making the link between CT and disciplines, but this implies giving the doctoral and teaching assistants a clear understanding of the goals and methods of CT. They have to understand what we are trying to achieve.

(5) CT provides an understanding of, a language for, and a toolbox for analysing processes, and these can be applied in a lot of domains. However that is not going to happen unless we explicitly teach CT in ways that promote near and far transfer

(6) We need to make the most of the EPFL initiative by properly evaluating the impact, which implies the need to collect some pre-intervention data now.

April 20, 2018 at 7:00 am 11 comments

The state of the field in pre-college computer science education: Highly recommended Google report

Google has just released a report: Pre-College Computer Science Education: A Survey of the Field (available here).  The report is authored by Paulo Blikstein of Stanford.  The report is innovative, developed with an unusual method.  It’s terrific, and I highly recommend it.

Paulo started out with a pretty detailed survey document about the state of the literature in computer science education. He covered from the 1967 launch of Logo to modern day.  Then he interviewed 14 researchers in the field (I was one). These were detailed interviews, where the interviewees got to review the transcript afterwards.  Paulo integrated ideas and quotes from the interviews into the document.  Here comes the really cool part: he put the whole thing on a Google doc and let everyone comment on it.

When I got the call to review the document, I just skimmed it.  It looked pretty good to me.  But then the debates started, and the fights broke out.  That Google doc had some of the longest threads of comments I’ve ever seen.  After a few weeks, Paulo closed the comments, and then integrated the threads into the document.  So now, it’s not just a serious survey paper, brought up to date with interviews.  It’s also a record of significant debate between over a dozen researchers, where the tensions and open questions were surfaced.

This is the document to read to figure out what should come next in computing education research.  I will recommend it to all of my students.

Of course, it’s not perfect.  The researchers interviewed tended towards the Logo/MIT/constructionist perspective.  The emphasis was on the US, though there were a couple of non-US interviewees.  If someone was to do this again (which I don’t recommend for a few years — it’ll take us awhile just to work on this agenda), I’d recommend including interviews with a wider range of folks:

  • We need to hear more voices from the evidence-based learning perspective, those inspired by Carl Wieman.  I’m thinking about people like Beth Simon, Leo Porter, Cynthia Lee, Christine Alvarado, and Dan Zingaro.
  • There’s no one on this list that I think would label themselves as a cognitive tutors or Learning at Scale researcher.  We need to hear from people like Mehran Sahami and Ken Koedinger.
  • I’m so glad that we have voices from the UK in this document, but if you’re going to go international, you have to include voices from the Nordic (e.g., Michael Caspersen, Jens Bennedsen, Lauri Malmi, Juha Sorva, and probably several from Upcerg, the world’s largest academic CS Ed research group), from Israel (e.g., Moti Ben-Ari, Judith Gal-Ezer, Yifat Kolikant, and Orit Hazzan), and from Australasia (e.g., Katrina Falkner, Ray Lister, Tim Bell).  The reality is that CS Ed Research is far larger outside the US than inside the US. There are more CS Ed researchers with a more diverse range of opinions outside the US.

I’m sure that I’m forgetting important voices, but this is enough to say that this report is a good first effort at bringing in a range of perspectives.  There are other important voices needed, if you really want to understand the state of CS education research at the pre-college level.

As it is, it’s still a fascinating and important report.  I’m biased — my thoughts and words are in there.  There is a range of opinions in there. I don’t agree with everything in there.  Paulo did a good job capturing the tensions around computational thinking, and I’m much more positive about blocks-based programming languages than are other voices in the report.

I highly recommend reading the report.

 

March 5, 2018 at 1:00 pm 4 comments

Advancing Computational Thinking Across K-12 Education, across Many Disciplines – Digital Promise #CSEdWeek

New report on coding, computer science, and computational thinking has just come out from Digital Promise.  I have been critical of some definitions of computational thinking (as I described in my book). I like the way Digital Promise defined them, and particularly how they connect CT to learning in other disciplines.

Advocating for computational thinking throughout the K-12 curriculum does not replace or compete with efforts to expand computer science education: on the contrary, it complements them. Where computer science is not yet offered, integrating computational thinking into existing disciplines can empower educators and students to better understand and participate in a computational world. And schools already teaching coding and computer science will benefit from weaving computational thinking across disciplines in order to enrich and amplify lessons that are beyond the reaches of computer science classes.

We offer a number of recommendations to move this work forward. Among them are advocacy campaigns, curriculum and resource development, professional development for teachers and administrators, and continued research.

Source: Advancing Computational Thinking Across K-12 Education – Digital Promise

December 8, 2017 at 7:00 am Leave a comment

Why should we teach programming (Hint: It’s not to learn problem-solving)

This is a revision of the original post. Several readers pointed out on Twitter that my original post was insensitive. It read like an attack on Brenda, a woman of color, from a senior white guy (me). That was not my intent, and I apologize for that. I am grateful to Joseph P. Wilson who helped me understand how to avoid that impression. I can’t change the post that went out yesterday, but I will be more careful in future blog posts.


At the CS for All Consortium Celebration Tuesday, Brenda Wilkerson gave the closing keynote. The full livestream of the CS for All Summit is available here, and it includes Brenda’s talk. I’m a huge fan of Brenda, and she’s done fabulous work in Chicago. She is a leader in bringing CS to All.

I have not seen Brenda’s talk or any of the livestream. My experience of the Consortium Celebration was through reading the Twitter stream as I found time during the day. Brenda had one slide (which you can see in the tweet linked here) that I disagreed with, and because it’s an important point, I’m going to respond to it here.

It says, “Computer science builds the mental discipline for breaking down problems, and solving them.” There are few studies that test this claim as “computer science,” but there have been lots of studies looking for transfer from teaching programming to general problem-solving skills. Probably the first study investigating this claim is Roy Pea and Midian Kurland’s paper On the cognitive effects of learning computer programming. You can find this claim in a paper by Henry Walker to which I responded in this blog. You can see it in posts all over the Internet, from this blog post to this article from a teacher in England. There is a strong belief out there that learning computer science, and programming called out specifically, leads to new problem-solving and “a new way to think.”

There is simply not evidence in support of these claims. I talk about these in my book, I reference the Palumbo meta-review in this blog post, and NYTimes wrote about it this last spring. Like “learning styles” and “Latin teaches thinking,” this is a persistent myth that learning computing leads to problem-solving skills, and we have no support the claim.

I tweeted in response to Brenda’s slide, and several CS teachers asked me, “So why teach programming or computing at all?”  That’s a great question!  Here are some of my top reasons:

  1. To understand our world. The argument that Simon Peyton Jones made in England for their computer science curriculum is that Computer Science is a science like all the others. We teach Chemistry to students because they live in a world with chemical interactions. We teach Biology because they live in a world full of living things. We teach Physics because they live in a physical world. We should teach Computer Science because they live in a digital world.
  2. To study and understand processes. Alan Perlis (first ACM Turing Award laureate) argued in 1961 that everyone on every campus should learn to program. He said that computer science is the study of process, and many disciplines need people to know about process, from managers who work on logistics, to scientists who try to understand molecular or biological processes. Programming automates process, which creates opportunities to simulate, model, and test theories about processes at scale. Perlis was prescient in predicting computational science and engineering.
  3. To be able to ask questions about the influences on their lives. C.P. Snow also argued for everyone to learn computing in 1961, but with more foreboding. He correctly predicted that computers and computing algorithms were going to control important aspects of our lives. If we don’t know anything about computing, we don’t even know how to ask about those algorithms. It shouldn’t be magic.  Even if you’re not building these algorithms, simply knowing about them gives you power. C.P. Snow argues that you need that power.
  4. To use an important new form of literacy. Alan Kay made the argument in the 1970’s that computing is a whole new medium. In fact, it’s human’s first meta-medium — it can be all other media, and it includes interactivity so that the medium can respond to the reader/user/viewer. Computing gives us a new way to express ideas, to communicate to others, and to explore ideas.  Everyone should have access to this new medium.
  5. To have a new way to learn science and mathematics. Mathematics places a critical role in understanding our world, mostly in science. Our notation for mathematics has mostly been static equations. But code is different and gives us new insights. This is what Andy diSessa has been saying for many years. Bruce Sherin, Idit Harel, Yasmin Kafai, Uri Wilensky, and others have shown us how code gives us a powerful new way to learn science and mathematics. Bootstrap explicitly teaches mathematics with computing.  Everyone who learns mathematics should also learn computing, explicitly with programming.
  6. As a job skill. The most common argument for teaching computer science in the United States is as a job skill.  The original Code.org video argued that everyone should learn programming because we have a shortage of programmers. That’s just a terrible reason to make every school child learn to program. That’s what Larry Cuban was arguing this last summer. Tax payers should not be funding a Silicon Valley jobs program. Not everyone is going to become a software developer, and it doesn’t make any sense to train everyone for a job that only some will do. But, there’s some great evidence from Chris Scaffidi (that I learned about from Amy Ko’s terrific VL/HCC summary) showing that workers (not software developers) who program make higher wages than those comparable workers who do not. Learning to program gives students new skills that have value in the economy. It’s a social justice issue if we do not make this economic opportunity available to everyone.
  7. To use computers better. This one is a possibility, but we need research to support it. Everyone uses computers all the time these days. Does knowing how the computer works lead to more effective use of the computer?  Are you less likely to make mistakes? Are you more resilient in bouncing back from errors? Can you solve computing problems (those that happen in applications or with hardware, even without programming) more easily?  I bet the answer is yes, but I don’t know the research results that support that argument.
  8. As a medium in which to learn problem-solving. Finally, computer programming is an effective medium in which we can teach problem-solving. Just learning to program doesn’t teach problem-solving skills, but you can use programming if you want to teach problem-solving. Sharon Carver showed this many years ago. She wanted students to learn debugging skills, like being able to take a map and a set of instructions, then figure out where the instructions are wrong. She taught those debugging skills by having students debug Logo programs. Students successfully transferred those debugging skills to the map task. That’s super cool from a cognitive and learning sciences perspective. But her students didn’t learn much programming — she didn’t need much programming to teach that problem solving skill.But here’s the big caveat: They did not learn enough programming for any of the other reasons on this list!  The evidence we have says that you can teach problem-solving with programming, but students won’t gain more than that particular skill. That is a disservice to students.

Certainly there are more reasons than these, and I’ve seen several in the response to this blog post, and some in the comments below.

This was just one slide in Brenda’s talk. Her overall point was much more broader and more significant. I strongly agree with Brenda’s key point: CS for All is a social justice issue. Learning computing is so important that it is unjust to keep it from some students. Currently, CS is disproportionately unavailable to poorer students, to females, and to minority ethnic groups. We need CS for All.

October 18, 2017 at 12:30 pm 28 comments

The Limitations of Computational Thinking: NYTimes

The New York Times ran a pair of articles on computing education yesterday, one on Computational Thinking (linked above and quoted below) and one on the new AP CS Principles exam.  Shriram and I are quoted as offering a more curmudgeonly view on computational thinking.  (Yes, I fixed the name of my institution in the below quote, from what how it is phrased in the actual article.)

Despite his chosen field, Dr. Krishnamurthi worries about the current cultural tendency to view computer science knowledge as supreme, better than that gained in other fields. Right now, he said, “we are just overly intoxicated with computer science.”

It is certainly worth wondering if some applications of computational thinking are trivial, unnecessary or a Stepford Wife-like abdication of devilishly random judgment.

Alexander Torres, a senior majoring in English at Stanford, has noted how the campus’s proximity to Google has lured all but the rare student to computer science courses. He’s a holdout. But “I don’t see myself as having skills missing,” he said. In earning his degree he has practiced critical thinking, problem solving, analysis and making logical arguments. “When you are analyzing a Dickinson or Whitman or Melville, you have to unpack that language and synthesize it back.”

There is no reliable research showing that computing makes one more creative or more able to problem-solve. It won’t make you better at something unless that something is explicitly taught, said Mark Guzdial, a professor in the School of Interactive Computing at Georgia Tech who studies computing in education. “You can’t prove a negative,” he said, but in decades of research no one has found that skills automatically transfer.

April 5, 2017 at 7:00 am 7 comments

Older Posts


Enter your email address to follow this blog and receive notifications of new posts by email.

Join 7,966 other followers

Feeds

Recent Posts

Blog Stats

  • 1,783,873 hits
August 2020
M T W T F S S
 12
3456789
10111213141516
17181920212223
24252627282930
31  

CS Teaching Tips