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.

Frameworks and Standards can be limiting and long-lasting: Alan Kay was right

Through the K-12 CS Framework process (December 2016, see the post here), Alan Kay kept saying that we needed real computer science and that the Framework shouldn’t be about consensus (see post here). I disagreed with him. I saw it as a negotiation between academic CS and K-12 CS.

I was wrong.

Now that I can see standards efforts rolling out, and can see what’s actually going into teacher professional development, I realize that Alan was right. Standards are being written to come up to but rarely surpass the Framework. All those ideas like bits and processes that I argued about — they were not in the Framework, so they are not appearing in Standards. The Framework serves to limit what’s taught.

Teachers are experts on what is teachable, but that’s not what a Framework is supposed to be about. A Framework should be about what the field is about, about what’s important to know. Yes, it needs to be a consensus document, but not a consensus about what goes into classrooms. That’s the role of Standards. A Framework should be a consensus about what computing is.

I think what drove a lot of our thinking about the Framework is that it should be achievable.  There was a sense that states and organizations (like CSTA and ISTE) should be able to write standards that (a) meet the Framework’s goals and (b) could be measurably achieved in professional development — “Yup, the teachers understand that.” As I learn about the mathematics and science frameworks, it seems that their goal was to describe the field — they didn’t worry about achievable.  Rather, the goal was that the Framework should be aspirational. “When we get education right for all children, it should look like this.”

Standards are political documents (something Mike Lach taught me and that Joan Ferrini-Mundy told ECEP), based on Frameworks. Because the K-12 CS Framework is expected to reflect the end state goal, Standards are being written a step below those. Frameworks describe the goals, and Standards describe our current plans towards those goals. Since the Framework is not aiming to describe Computer Science, neither do the state Standards that I’m seeing.

I told Alan about this realization a few weeks ago, and then the Georgia Standards came out for review (see page here). They are a case in point. Standards are political documents. It matters who was in the room to define these documents in this way.

Here’s the exemplar standard from the Grade 6-8 band:

Use technology resources to increase self-direction and self-regulation in learning, including for problem solving and collaboration (e.g., using the Internet to access online resources, edit documents collaboratively)

Can technology resources increase self-direction and self-regulation in learning? Maybe — I don’t know of any literature that shows that. But even if it can, why are these in the Computer Science standards?

The K-2 band comparable Standard is even more vague:

Recognize that technology provides the opportunity to enhance relevance, increase confidence, offer authentic choice, and produce positive impacts in learning.

I have no idea if computers can “increase confidence,” but given what we know about self-efficacy and motivation, I don’t think that’s a common outcome. Why is this in the Computer Science Standards?

There are lots of uses of the word “information.” None of them define information. The closest is here (again, grades 6-8), which lists a bunch of big ideas (“logic, sets, and functions”) but the verb is only that students should be able to “discuss” them:

Evaluate the storage and representation of data; Analyze how data is collected with both computational and non-computational tools and processes

1. Discuss binary numbers, logic, sets, and functions and their application to computer science
2. Explain that searches may be enhanced by using Boolean logic (e.g., using “not”, “or”, “and”)

What’s missing in the Framework is also missing in the Georgia standards.

• The word “bit” doesn’t appear anywhere in these standards — if there is no information, then it makes sense that students don’t need bits.
• The word “process” does, but mostly in the phrase “design process.” Then it shows up in the Grade 6-8 band, but in highly technical forms: “process isolation” and “boot process.”
• There are no names: No Turing, no Hopper. There is no history, so no grounding in where computer science came from and what the big and deep ideas are.

There are strange phrases like “binary language,” which I don’t understand.

This is from Georgia, where there is a strong video game development lobby. Thus, all students are expected (by Grades 6-8) to:

Develop a plan to create, design, and build a game with digital content for a specific target market.

And

Develop a visual model of a game from the Game Design Document (GDD).

And

Create a functional game, using a game development platform, based on the storyboards, wireframes, and comprehensive layout.

It’s clear that the Georgia Standards are the result of a political process.

The bottom line is that I now wish that we had made sure that the K-12 CS Framework reflected computer scientists’ understanding of Computer Science. It instead reflected K-12 classroom computer science as defined in 2016. They presume languages like Scratch and curricula like AP CS Principles.  That’s reasonable in Standards that describe what goes into the classroom tomorrow, but Frameworks should describe a broader, longer-range thinking. Our

There are no plans that I’m aware of to define a new Framework. The Standards are still just being developed for many states, so they’re going to last for years. This is what Computer Science will be in the United States for the next couple decades, at least.

Vote for SIGCSE’s Top 10 Papers of the first 50 years

The ACM Special Interest Group in CS Education (SIGCSE) has created a new “Test of Time” award.  They are trying to define the top 10 papers of SIGCSE’s first 50 years.  You can see the list and vote here.

Because SIGCSE is celebrating their 50th anniversary, ALL SIGCSE conference papers are freely available in the ACM Digital Library through the Symposium (Feb 27-March 2 in Minneapolis).

I don’t know all the papers on the list, but I’m happy that some of my favorites are there. Just mentioning a few:

• The paper introducing Scratch to the world.
• The Multi-Institutional, Multi-National (MIMN) study supporting the value of Peer Instruction in CS classes.
• The paper on CSin3, on which my student, Katie Cunningham, is one of the authors.
• The paper introducing Alice.
• The 2001 paper on factors leading to success and failure in CS1 (which I still cite pretty regularly).
• The Defensive Climate paper, which I cite even more regularly.

I do encourage you to check them all out, vote, and download as many papers as you can while they’re all free.

 

 

Do we know how to teach secure programming to K-12 students and end-user programmers?

I wrote my CACM Blog post this month on the terrific discussion that Shriram started in my recent post inspired by Annette Vee’s book (see original post here), “The ethical responsibilities of the student or end-user programmer.” I asked several others, besides the participants in the comment thread, about what responsibility they thought students and end-user programmers bore for their code.

One more issue to consider, which is more computing education-specific than the general issue in the CACM Blog. If we decided that K-12 students and end-user programmers need to know how to write secure programs, could we? Do we know how? We could tell students, “You’re responsible,” but that alone doesn’t do any good.

Simply teaching about security is unlikely to do much good. I wrote a blog post back in 2013 about the failings of financial literacy education (see post here) which is still useful to me when thinking about computing education. We can teach people not to make mistakes, or we can try to make it impossible to make mistakes. The latter tends to be more effective and cheaper than the former.

What would it take to get students to use best practices for writing secure programs and to test their programs for security vulnerabilities? In other words, how could you change the practice of K-12 student programmers and end-user programmers? This is a much harder problem than setting a learning objective like “Students should be able to sum all the elements in an array.” Security is a meta-learning objective. It’s about changing practice in all aspects of other learning objectives.

What it would take to get CS teachers to teach to improve security practices? Consider for example an idea generally accepted to be good practice: We could teach students to write and use unit tests. Will they when not required to? Will they write good unit tests and understand why they’re good? In most introductory courses for CS majors, students don’t write unit tests. That’s not because it’s not a good idea. It’s because we can’t convince all the CS teachers that it’s a good idea, so they don’t require it. How much harder will it be to teach K-12 CS teachers (or even science or mathematics teachers who might be integrating CS) to use unit tests — or to teach secure programming practices?

I have often wondered: Why don’t introductory students use debuggers, or use visualization tools effectively (see Juha Sorva’s excellent dissertation for a description of how student use visualizers)? My hypothesis is that debuggers and visualizers presume that the user has an adequate mental model of the notional machine. The debugging options Step In or Step Over only make sense if you have some understanding of what a function or method call does. If you don’t, then those options are completely foreign to you. You don’t use something that you don’t understand, at least, not when your goal is to develop your understanding.

Secure programming is similar. You can only write secure programs when you can envision alternative worlds where users type the wrong input, or are explicitly trying to break your program, or worse, are trying to do harm to your users (what security people sometimes call adversarial thinking). Most K-12 and end-user programmers are just trying to get their programs work in a perfect world. They simply don’t have a model of the world where any of those other things can happen. Writing secure programs is a meta-objective, and I don’t think we know how to achieve it for programmers other than professional software developers.

A little bit of computing goes a long way, and not everyone needs software engineering: The SIGCSE 50th Anniversary issue of ACM Inroads

This year is the 50th SIGCSE Technical Symposium, and Jane Prey was guest editor for a special issue of ACM Inroads on 50 years of ACM SIGCSE. You can see the current issue here, but yes, it’s behind a paywall — ACM Inroads is meant to be a membership benefit.

I’m really fascinated by this issue. Sally Fincher does a nice job telling the story of ICER. I enjoyed Susan Rodgers’ and Valerie Barr’s reflections. I’m still trying to understand all of Zach Dodds’ references in his SIGCSE 2065 future-retrospective. I found some of the articles frustrating and disagreed with some of the claims (e.g., I don’t think it’s true that AP CS enrollments plummeted after introducing Java), but discussion can be good for the community.

I was asked to write a piece about What we care about now, and what we’ll care about in the future. My bottom line is a claim that John Maloney (of Squeak, Scratch, and GP fame) reminded me is a favorite phrase of the great Logo (and many other things) designer, Brian Silverman: A little bit of computing goes a long way.

The important part of Scratch is that computationalists find value in it, i.e., that they can make something that they care about in Scratch. What we see in Scratch is the same process we see among the computationalists in computational photography, journalism, and science. They don’t need all of computer science. They can find value and make something useful with just some parts of computing. Scratch projects smell wonderful to Scratch computationalists.

There’s been a thread on Twitter recently about the use of software engineering principles to critique Scratch projects (see the thread starting here). Researchers in software engineering claim that Scratch code “smells,” e.g., has bad practices associated with it. There’s even a website that will analyze your Scratch project in terms of these software engineering practices, DrScratch.  The website claims that it is measuring computational thinking skills — I see no evidence of that at all.

These software engineering researchers are misunderstanding users and genres of programming. They ought to read Turkle and Papert’s Epistemological Pluralism and the Revaluation of the Concrete. People code for different purposes, with different ways of appropriating code. The standards of the software engineer are not appropriate to apply to children. Not everybody is going to be a professional software developer, and they don’t need to be.

Increasingly, people are only going to use parts of computer science, and they will achieve fluency in those. That’s a wonderful and powerful thing. A little bit of computing goes a long way.