Posts tagged ‘computing education’
England: Time to replace Computer Science with Computing
This is policy wonk stuff, but I find policy fascinating. As a researcher, it’s hard to figure out “How are most people (students, faculty, whatever) in this field thinking about X?” Policy-makers have to figure that out, too, and then have to respond. A change in policy is like a research paper that says, “We found that the status quo wasn’t working anymore.”
The English government has just conducted an independent review of all their school curricula (see report here). The review is critical of how Computer Science is working in English schools today. They say that Computing now pervades all disciplines and “digital literacy” should be taught in an integrated manner. I recommend reading the report — it’s accessible and covers a bunch of important issues, like who is taking CS and where there’s a split between policy and practice.
One of the explicit recommendations is that the government:
Replaces GCSE Computer Science with a Computing GCSE which reflects the full breadth of the Computing curriculum and supports students to develop the digital skills they need.
The government response (linked here) agrees:
We agree with the Review that the computing curriculum should be the main vehicle for teaching about digital literacy, and we are confident that delivering the computing recommendations will provide more pupils with valuable digital skills that are essential for the future.
It is also clear that, in some subjects, digital methods now influence the content and how it is taught. We will work with experts to assess the validity of digital practice in these subjects, the evidence of whether this can be done robustly and whether it merits inclusion in the new curriculum. Where it does, we will include a requirement for the relevant digital content in those subjects’ programmes of study and we will ensure that it aligns with the computing curriculum, to reduce the risk of duplication.
We will also replace the computer science GCSE with a broader offer that reflects the entirety of the computing curriculum whilst continuing to uphold the core principles of computer science such as programming and algorithms, and explore the development of a level 3 qualification in data science and AI.
Bottomline: CS just isn’t the thing anymore. Computing and computing across the curriculum is what is needed.
As a director of a Program in Computing for the Arts and Sciences, and someone who spent 25 years in a College of Computing, I wholly endorse this change and welcome it. As I described in a blog post from a couple of years back, “computer science” was originally invented to be a broad subject to be taught to everyone. Over the last 60 years, “computer science” has become more narrow (e.g., overly emphasizing algorithms while de-emphasizing building and creativity and social impacts, as Sue Sentance describes in this blog post, while “computing” represents a broader perspective. When we think about what should be taught to everyone in secondary school, Computing (and digital literacy, as the reports suggest) are more appropriate than what we now mean when we say Computer Science.
Personally Meaningful Data to Motivate Learning in Data Science and AI
I have written several blog posts about the different ways to implement Media Computation in introductory programming courses. We built JES at Georgia Tech in 2002 and the final release was in 2020. Our introductory course in PCAS that uses Media Computation, COMPFOR 121: Computing for Creative Expression, uses Snap! and Pixel Equations (as described in this blog post). Our Python course (COMPFOR 221: Digital Media with Python) started in Python3 with the JES4Py library, but then we moved to Google Collaboratory notebooks (the libraries for that are available here).
Dave Largent at Ball State continues to teach Media Computation. The students in his course compete in an art show each term for which I’ve served as a judge. Dave let me know that he and his students have extended JES4Py and have released a new library:
I’ve had a couple of undergrad students working with me to redevelop/extend Gordon College’s JES4py package. We’ve published it at PyPI under the name mediaComp (https://pypi.org/project/mediaComp/). Our GitHub is https://github.com/dllargent/mediaComp.
Why is this interesting? Why is anybody teaching with a 20 year old method, and even making new libraries for it?
Maybe because it answers a CS education need that has only grown more important. Data science is a bigger deal now than it was 20 years ago. Ben Shapiro told us in 2018 that machine learning was going to change the CS curriculum, and we needed to think more about data. But what data are interesting to students?
The empirical studies in computing education research are pretty clear: Motivation matters.. Students get frightened off by computer science classes. They find our examples boring. If we can teach the same computing concepts using any data, why not use data that students find interesting?
I’ve heard Jens Mönig, lead architect and developer on Snap!, answer this question several times in several talks. There’s a new interview with him in the most recent ACM Inroads magazine (link) with Jens where he makes the point again. Students are interested in their data. Personal data, data about them, data that they make, data that are relevant to them. The phrase in the Constructionist community is “personally meaningful.”
Media Computation is data manipulation with personally meaningful data — your pictures and sounds, or the pictures and sounds that interest you. There are a lot of pixels and samples in those pictures and sounds. Those are data that matter to the students who care about those pictures and sounds.
Media Computation as an approach is not going to be for everyone. But every computing teacher should answer the meta question, “Why should my students care about these data?”. We often use the Corgis project data to help students find data that are personally meaningful. That’s where you can find the Titanic passenger dataset that Jens talks about in his interview. I am an advisor to API Can Code, which is a curriculum all about doing data science with live data that students might care about.
My point here isn’t that all teachers should use Media Computation. My point is that all computing teachers should engage students with personally meaningful data.
Defining Learner-Centered Design of Computing Education: What I did on my sabbatical
My planned activity during my sabbatical was to revise my 2015 book “Learner-Centered Design of Computing Education.” One of the fixes I wanted to make was a better definition of what “learner-centered design” was. In the new edition, I wrote some formal defining stuff, and then I wrote the below — an extended metaphor to make distinctions between different kinds of “centering” in education. I’m sharing that section here (in its pre-reviewed and pre-edited state). It comes right after defining what the Zone of Proximal Development is and what student performance means.
There are many different kinds of teaching activity that can help a student reach a more sophisticated level of performance. A teacher can model successful performance. The teacher can give feedback on the student’s performance. The teacher can coach or guide a student while attempting a task. They can set expectations in the class which create a social context for success. They can use teaching methods that have a proven research record in promoting engagement and student performance.
Figure 1: A metaphor for teaching contrasting learner-centered and standards-centered
Consider teaching from the top or bottom of the ZPD. Here is a metaphor to make distinctions between two kinds of support in order to create a geography of teaching. Imagine the ZPD as a climbing wall (Figure 1). The student is at the bottom and wants to reach the top. Depicted as grayscale images in this figure, here are two ways a teacher might support the student in scaling this wall:
- The supporter at the bottom can help the student get started, giving them a “boost” or “leg up.”
- The supporter at the top can reach down, and get them the rest of the way to the top of the wall.
The supporter at the bottom is more flexible than the one at the top. She can move to where the student is actually standing. She can help the student scale different parts of the wall or even reach different goals along the wall. She can bend even further if the student is shorter.
But a disadvantage for the supporter at the bottom is that she cannot be absolutely sure that the learner reaches the top. She can meet the student where they are when they first face the wall. She can help them get started on whatever path they choose on the wall.
The supporter at the top can help students who are almost at the top of the wall. He can be sure that students actually reach the learning objective. When he is reaching down, he is in a fixed position. He can help the student reach the objective where he is at, the level that he has already achieved. He can also be sure when a student does not reach this standard – he can see the students who fall, or who do not make it to his level. He is in a better position to decide whether the student is going to achieve the desired objectives.
The supporter at the bottom is more learner-centered. The supporter at the top is more standards-centered. Neither supporter is particularly strong at helping the student in the middle, when the student is challenged to persist, to stay engaged, and to maintain motivation. If the student is not particularly interested in achieving the top of the wall, they are satisfied making it part-way to the objective, then the learner-centered teacher has the most to offer.
Learner-centered teaching is concerned with helping students where they are, helping them to get started, and getting them engaged and motivated to tackle the mid-part. Low enrollment and high withdrawal or failure rates (sometimes called WDF rates) are issues that learner-centered teaching addresses. Learner-centered teaching also addresses issues of diversity, with the goal that all kinds of students can succeed in the class — even those who think that they cannot succeed or do not have the prior background to succeed.
Standards-centered teaching is concerned about making sure that students have what they need to go on, in their studies or in their career. Students who fail the second class because they did not learn enough in the first class is an issue for standards-centered teaching. Talking to industry partners about the desired out- comes is standards-centered. Concern about what graduates can do and achieve is a standards-centered teaching issue.
(I’m skipping some text here about teacher-centered, classroom-centered, and other forms of structuring education.)
I am splitting hairs a bit between child-centered and learner-centered. Learner-centered also starts from the students’ interests and considers the learner’s needs, and is very much about student construction of knowledge in their own minds, since that is how learning takes place. As described in Chapter 2, the knowledge to be learned in learner-centered education is defined by the community of practice. That is external to the learner.
Within the metaphor, I am describing three kinds of teaching: Learner-centered (supporter at the bottom), standards-centered (supporter at the top), and maintaining motivation and engagement (in the middle). Of course, teachers and students have to address all these issues, but it is sometimes useful to focus on one part. Consider this metaphor: If you have heart problems, it is important to go to a cardiovascular specialist. That does not mean that you do not need to care about skeleton, digestion, and skin; you need all of those, but sometimes you can address critical issues or fix problems by specializing. I focus on the first one because it is the most important. I like the way my colleagues Amy Bruckman and Betsy diSalvo put it
Computer science is not that difficult, but wanting to learn it is.
Media Computation in Python running in Google Colab Notebooks
Here’s why I decided to work on yet-another implementation of a Python API that we first developed in 2001, how to get the implementation, and how it’s different.
Why we needed Python MediaComp in the browser
In 2002, we created a course at Georgia Tech called “Introduction to Media Computation.” Georgia Tech required all liberal arts majors to take a course in computer science, but the withdrawal-or-failure rate was high (about 50% for some majors). The core idea of Media Computation (MediaComp) is to program on the digital media in their lives, at different levels of abstraction: pixels in pictures, samples in sounds, frames in video. Students succeeded at the MediaComp course at a much higher rate (about 85%).
We developed MediaComp, studied it, and disseminated it. Barbara Ericson and I wrote textbooks using MediaComp (in Python and Java), and Barb developed “Picture Lab” for AP CS A. I presented a paper at ICER 2012 that summarized the research on MediaComp in the first decade of its use, “Exploring Hypotheses about Media Computation” The effect on retention had been documented at multiple institutions, and the qualitative data suggested that it was because the focus on media made the course seem more “relevant” and thus, more motivating which increased retention. We saw it as a form of contextualized-computing education.
I complained the last time I blogged on MediaComp (in 2021) that it was hard to teach MediaComp in Python today. We had created the JES IDE (Jython Environment for Students), but that required Java (which has been increasingly hard to install) and Jython (which was no longer being actively developed). I said in 2021 that best bet I knew for teaching MediaComp in Python was the JES4Py library.
I started teaching COMPFOR 121: Computing for Creative Expression at the University of Michigan in Fall 2022 based on participatory design with groups of liberal arts faculty. It’s a course that uses teaspoon languages, mostly Snap!, and some work in Python in a Runestone ebook (see ITiCSE 2023 papers on this progression). It covers everything we did in MediaComp at Georgia Tech, and a bunch more. (Snap! is so cool.) The course works (more on that in a blog post in a couple of weeks), but not all liberal arts faculty were happy about us using non-mainstream languages. I mostly heard calls for Unity or Python. I decided to create a MediaComp Python course for PCAS, but instead of being an introduction to computer science, the goal was to provide an introduction to digital media to arts and humanities students, with Python as the manipulation language.
I taught COMPFOR 221: Digital Media in Python in Winter 2024 based on the JES4Py library and the Thonny IDE. The library is great, stitching together other Python multimedia libraries. The contributors have done a marvelous job of replicating the IDE that we had in JES. But it requires students to install Python, and that became a showstopper. I learned that many liberal arts students at the University of Michigan don’t update their OS, and keep very little disk space free. We spent a huge amount of time figuring which version of which library could actually run on their OS, and then which other libraries had to be rolled back to previous versions because of interactions. (Many thanks to Ben Shapiro at U. Washington Seattle and Apple who helped me debug some of these and figure out workarounds.) About a third of the class couldn’t do everything we asked for in the Final Project because we just couldn’t get all the libraries to work on their computers.
We needed a browser-based solution. So I devoted a chunk of my time in Summer 2024 to getting a version of JES4Py to work in Google Colab notebooks. I picked Google Colab because it offered a way for me to make audio players in the notebook (to heard digital sounds) and it easily connected to students’ Google Drives, so that they could use their own photos by simply copying them to the right directory in their Drive. We used it in Fall 2024, and it worked well! Few technical details, and students could do a lot of MediaComp Python. A new lecturer in PCAS is teaching with it now in Winter 2025.
Side note: This was my first time developing code in the post-ChatGPT world. What a wonderful tool! It had read all the documentation, and gave me examples of each thing I needed. Every generated example was wrong somewhere, but it was exactly the right example to tell me how to do what I wanted. It was great for a more experienced (but infrequent) developer like me who could interpret the results, but oof, I’d worry about students being led astray.
Using JES4Py Colab
Here’s a zip file with code and some sample media: https://computinged.wordpress.com/wp-content/uploads/2025/01/mediacomp.zip.
The assumption in the class is that you would have a folder in your Google Drive (“COMPFOR221” for us, mediacomp for the demo below) in which there were two folders: code and mediasources. Whenever students wanted to add another picture or sound (or image sequence for movies), they just copied it to mediasources.
The first cell in all our notebooks looks like this:
from google.colab import drive
drive.mount('/content/drive')
import sys
sys.path.append('/content/drive/My Drive/mediacomp/jes4py_colab')
from jes4py import *
setMediaPath("/content/drive/My Drive/mediacomp/mediasources/")
This code mounts the student’s Google Drive, modifies the sys.path to access the code directory, then imports the jes4py library. Then it sets up media folder to point to the mediasources folder. When you execute it, Google asks you (several times) if you’re really, really sure that you want to use a notebook to manipulate your Google Drive.
Here’s a demo notebook to see how this works. Remember that you’ll need to download the zip file and expand it in your Google Drive before the notebook will work for you, but you can open the notebook without the zip file — you just won’t be able to execute any of the code.
The “Hello World” sequences from JES work fine.
We can manipulate pixels.
And we can manipulate samples (shifting sounds up and down in frequency).
What’s different in JES4Py Colab
The biggest difference with JES4Py (or JES) was that there are no file dialog boxes. So functions like pickAFile() and pickAFolder() don’t work.
The second big difference is that I couldn’t get sound to play as a background process. Instead, audio objects get returned to the Colab notebook, and that generates a player. Functions like blockingPlay() don’t work, since there is no background process to block. Audio took the biggest effort. I had to re-work the way that WAV files were read in so that they could match to the audio object that Colab notebooks understand.
Pictures work really well. I didn’t have to change much from JES4py. I mostly had to fix the show() function. It doesn’t open a new window — it shows the picture in the notebook. Window-oriented JES functions like repaint() don’t work.
Movies work, but they are kind of clunky. An image sequence (directory of picture files numbered in consecutive) can be played as a Movie object, but basically, the notebook just fetches each image and displays it, trying to achieve the given frame rate. Depending on the size of the picture objects and the speed of the network, it can work. To make an image sequence, you create a folder in your mediasources directory to store the image sequence, then generate the images there. Then you can play it back in the notebook. For my students, this was enough to do debugging, and then they used the frames in some other tool (like Adobe Premiere) to generate movie files from the image sequence.
I took a PDF of the JES help files for pictures and sounds and marked them up for changes in JES4Py Colab. They’re available here: Pictures and Sounds.
Disclaimer: The best way to release this would be to set up a GitHub repository, and let people grab it and share revisions. I’m not interested in championing another open source project. I plan to keep this running for our class at the University of Michigan, and I invite anyone else to use the code without warranty or guarantee. I welcome someone else to set up a project and put this in a repository, if they’re interested in being the library owner.
For the reasons liberal arts and sciences majors should learn to program, AI’s not really that big a deal
“It’s the end of Computer Programming as We Know It” wrote Farad Manjoo in the NYTimes last June.
Jensen Huang, CEO of Nvidia, said earlier this year that programming is no longer important:
“It is our job to create computing technology such that nobody has to program. And that the programming language is human,” Jensen Huang told the summit attendees. “Everybody in the world is now a programmer. This is the miracle of artificial intelligence.”
And just this last week, NYtimes asked “Will A.I. Kill Meaningless Jobs? And is that so bad?” And there examples were mostly about…programming.
I read these pieces and saw a narrow definition of programming. They describe coding as a drudgery of carefully transforming requirements into stable, robust applications. But there’s another side of programming — the one that predates the drudgery one. Programming is also a tool to think and learn with.
Back in 2009, I’d written a blog post, “There will always be friction” inspired by an essay by Michael Mateas. I remembered that the argument then was why natural language programming would never quite work (and the argument pretty much still stands). But then I re-read Michael’s essay and realized that he was saying something much deeper than that. He was describing the reasons to program the way that the LSA faculty who talked to our Computing Education Task Force explained how they thought about and used programming.
There are four reasons to learn programming that we heard liberal arts and sciences faculty asking for and which are reflected in Michael’s essay — reasons that ChatGPT don’t change:
- Computational scientists use code as a way to describe models, and they need the exactness and interpretability of code.
- Computational artists need to know code to use it as a medium, in the same way that artists get to know other media (e.g., watercolors, oil painting, sculpture) to develop their skill and their potential to express with the medium.
- Critical computing scholars have to understand code to reason about its effects.
- Software studies scholars study code the way that earlier humanities scholars study text manuscripts, and it’s hard to study something you don’t understand.
I decided to write a Medium essay about those reasons, grounded in Michael’s essay but updated with an AI-framing — see link here. I decided to try Medium for this because it’s a pretty long essay and many subscribers here get these posts via email. I also want to explore other platforms, to see if maybe Medium is better for commenters than WordPress.
There are other reasons that LSA faculty wanted their students to learn programming, but I left out of the essay one other key reason to learn programming that LSA faculty talked to us about: To become a “conversational programmer.”. Some students take programming courses because they want to understand software development as an activity and to improve their communication with professional programmers. LSA faculty liked the idea of “conversational programmer” for their students.
I left it out because that one likely will get changed by ChatGPT, Co-Pilot, and all the other LLMs. If AI changes the task of professional programming, and conversational programmers want to understand professional programming, then yeah, of course, AI is going to change things.
But AI doesn’t change programming for people who want to think with, express with, and reason about code.
What Humanities Scholars Want Students To Know About the Internet: Alternative Paths for Alternative Endpoints
After we got the go-ahead to start developing PCAS (see an update on PCAS here), I had meetings with a wide range of liberal arts and sciences faculty. I’d ask faculty how they used computing in their work and what they wanted their students to know about computing. Some faculty had suggested that I talk to history professor, LaKisha Michelle Simmons. I met with her in January 2023, and she changed how I thought about what we were doing in PCAS.
I told her that I’d heard that she built websites to explain history research to the general public, and she stopped me. “No, no —- my students build websites. I don’t built websites.” I asked her what she would like her students to know about the Internet. “I could teach them about how the Internet works with packets and IP addresses. I could explain about servers and domain names.”
She said no. She was less interested in how the Internet worked. She had three specific things she wanted me to teach students.
- She wanted students to know that there are things called databases.
- That databases, if they are designed well, are easy to index and to find information in.
- Databases could be used to automatically generate Web pages.
Her list explains a huge part of the Web, but was completely orthogonal to what I was thinking about teaching. She wasn’t asking me to teach tools. She wanted me to teach fundamental concepts. She wanted students to have understanding about a set of technologies and ideas, and the students really didn’t need IP addresses and packets to understand them.
The important insight for me was that the computing that she was asking for was a reasonable set, but different from what we normally teach. These are advanced CS ideas in most undergraduate programs, typically coming after a lot of data structures and algorithms. From her perspective, these were fundamental ideas. She didn’t see the need for the stuff we normally teach first.
I put learning objectives related to her points on the whiteboards in my participatory design sessions. This showed up in the upper-right hand corner of the Justice class whiteboard — the most important learning objective. LaKisha gave me the learning objectives, and the humanities scholars who advised me supported what she said. This became a top priority for our class Computing’s Impact on Justice: From Text to the Web.
Figuring out how
During the summer of 2022, a PhD student working with me, Tamara Nelson-Fromm, a group of undergraduate assistants, and I worked at figuring out how to achieve these goals. We had to figure out how to have students work with LaKisha’s three learning objectives, without complicated tools. We were committed to having students program and construct things — we didn’t want this to be a lecture and concepts-only class.
We were already planning on using Snap, and it has built-in support for working with CSV files. Undergraduate Fuchun Wang created a great set of blocks explicitly designed to look like SQL for manipulating CSV files. We used these blocks to talk about queries and database design in the class.
Tamara and I talked a lot about how to make the HTML part work. I had promised our advisors that we would not require LSA students to install anything on their computers in the intro courses. We talked about the possibility of building a teaspoon language for Web page development and for use as templating tool for databases, but I was worried that we were already throwing so many languages at the students.
Then it occurred to us that we could do this all with Snap. We built a set of blocks to represent the structure of an HTML page, like in this example. Since we could define our own control structures in HTML, we could present the pieces of a Web page nested inside other blocks, to mirror the nested structure of the tags.
Those last two blocks were key. The view webpage block displays in the stage the first 50 lines of the input HTML. That’s important so that students see the mapping from blocks to HTML. The open HTML page block opens a browser window and renders the HTML into it. (That was a tricky hack to get working.)
This was enough for us to talk about building Web pages in Snap, viewing the HTML, then rendering the HTML in the browser. Here’s a slide from the class. In deciding what computer science ideas to emphasize, I used the work of Tom Park who studied student errors in HTML and CSS, and found that ideas of hierarchy and encapsulation were a major source of error. Those are important ideas across computing, so I used those as themes across the CS instruction — and the structure we could build in the Snap block helped to present those ideas.
All of that together is enough to build Web pages from database queries. Here’s an example — querying the billionaires database from Forbes for those from Microsoft, then creating a Web page form letter asking them for money.
We use these blocks in both of our classes:
- In the Justice class, students use the HTML blocks to create a resume for a fictional or historical character in a homework assignment. In a bigger project, students design their own database of anything they want, then create two queries. One should return 1-3 items, and should generate a detail page for each of those items. The second query should return several items, and return an overview page for that set of items.
- In the Expression class, building an HTML page is the last homework. They use style rules and have to embed a Snap project so that there’s interactivity in the page. Here’s a slide from the class where we’re showing how adding style rules changes the look-and-feel of an HTML page.
Alternative Paths to Alternative Endpoints
Mike Tissenbaum, David Weintrop, Nathan Holbert, and Tammy Clegg have a paper that I really like called “The case for alternative endpoints in computing education” (BJET link, UIUC repository link). They argue “for why we need more and diverse endpoints to computing education. That many possible endpoints for computing education can be more inclusive, just and equitable than software engineering.” I strongly agree with them, but I learned from this process that there are also alternative paths.
Computer science sequences don’t usually start with databases, HTML, and building web pages from database queries, but that’s what my humanities scholars advisors wanted. Computer science usually starts from algorithms, data structures, and writing robust and secure code, which our scholars did not want. Our PCAS courses are certainly about alternative endpoints — we’re not preparing students to be professional software developers. We’re also showing that we can start from a different place, and introduce “advanced” ideas even in the first class. Computing education isn’t a sequence — it’s a network.
Participatory Design to Set Standards for PCAS Courses
My main activity for the last year has been building two new courses for our new Program in Computing for the Arts and Sciences (PCAS), which I’ve blogged about recently here (with video of a talk about PCAS) and here where I described our launch. Here are the detailed pages describing the courses (e.g., including assignments and examples of students’ work):
- COMPFOR 121: Computing for Creative Expression
- COMPFOR 111: Computing’s Impact on Justice: From Text to the Web
When we got the go-ahead to start developing PCAS last year, the first question was, “Well, what should we teach?” The ACM/IEEE Computing Curriculum volumes weren’t going to be much help. They’re answering the question “What do CS, Software Engineering, Information Technology, etc. majors need to know?” They’re not answering the question, “What do students in liberal arts and sciences need to know about Computing for Discovery, for Expression, and for Justice?”
My starting place was the Computing Education Task Force (CETF) report (see link here) which summarized dozens of hours of interviews and survey results from over 100 faculty. We decided that the first two courses would be on Expression and Justice. There already were classes that introduced programming in a Discovery framing in some places on campus (and my colleague, Gus Evrard, has taken that even farther now — but that’s another blog post). There was nothing for first year students to introduce them to coding in an Expression or Justice context.
When faced with a design problem, I often think “WWBD” — “What Would Betsy Do.” I learned about participatory design working with Betsy DiSalvo at Georgia Tech, and now I reach for those methods often. I created participatory design activities so that Expression and Justice faculty in our College of Literature, Science, and the Arts (LSA) could set the standards for these courses.
I created three Padlets, shared digital whiteboards. A group of people edit a whiteboard, and everyone can see everyone else’s edits.
- One of them was filled with about 20 learning goals derived from the CETF report. These aren’t well-formed learning goals (e.g., not always framed in terms of what students should be able to do). These were what people said when we asked them “What should students in LSA learn about computing?” I wasn’t particularly thorough about this — I just grabbed a bunch that interested me when I reviewed the document and thought about what I might teach.
- I created two more Padlets with possible learning activities for students in these classes. Yvette Granata had recommended several books to me on coding in Expression and Justice contexts, so a lot of the project ideas came out of those. These were things that I was actively considering for the courses.
I ran two big sessions (with some 1:1 discussions afterwards with advisors who couldn’t make the big sessions), one for Expression and one for Justice. These were on-line (via Zoom) with me, Aadarsh Padiyath (PhD student working with me and Barbara Ericson), and a set of advisors. The advisors were faculty who self-identified as working in Computing for Expression or Computing for Justice. The design sessions had the same format.
- I gave the advisors a copy of the learning goals Padlet. (Each session started with the same starting position.) I asked them as a group to move to the right those learning goals they wanted in the class and to move to the left those learning goals that they thought were less important. They did this activity over about 20-30 minutes, talking through their rationale and negotiating placement left-to-right.
- I then gave the advisors a copy of the learning activities Padlet. Again, I asked them to sort them right is important and left is less important.. Again, about 20-30 minutes with lots of discussion.
We got transcripts from the discussion, and Aadarsh produced a terrific set of notes from each session. These were my standards for these courses. This guided me in deciding what goes in and what to de-emphasize in the courses.
Below are the end states of the shared whiteboards. There’s a lot in here. Three things I find interesting:
- Notice where the computer science goals like “Write secure, safe, and robust code” end up.
- Notice what’s in the upper-right corner — I was surprised in both cases.
- Notice that building chatbots is right-shifted for both Expression and Justice. Today, you’d say “Well, of course! ChatGPT!” But I held these sessions in February of 2022. The classes have a lot about chatbots in them, and that put us in a good place for integrating discussions about LLMSs this last semester.
Expression Learning Goals
(To see the full-res version, right-click/control-click on the picture, and open the image a new tab.)
Justice Learning Goals
Expression – Learning Activities
Justice – Learning Activities
These are Standards
The best description of how I used these whiteboards and the discussion notes is that these are my standards. My advisors said very clearly during the sessions — there are too many learning objectives and activities for one course here. Things on the left are not unimportant. They’re just not as important.. I can’t possibly get to everything on these whiteboards in a single semester class designed for arts and humanities students (as the primary audience) with no programming background and with some hesitancy about mathematics.
My advisors were designing in a vacuum. They weren’t going to actually teach this course. Most of them had never seen a course that tried to achieve these objectives for this student audience. So they told me (for Justice), “Yeah, use Jupyter notebooks, and teach HTML and databases and code, all in one semester. And don’t make students install anything on their computers — do it all in the browser.” But they didn’t really have an idea how this might work, or if it was possible. They also didn’t articulate, “You’ll probably to teach about data and iteration and conditionals in here, too.”
It was my job to use these standards as priorities, cover what I could, and fill in with the computer science knowledge to make these do-able. We are also using these to inform future classes, the next classes we make for PCAS. You can compare these whiteboards back up to the course pages at the top of this post to decide how well we did.
Overall, we use participatory design methods a lot as we design for PCAS, to get the input of faculty outside of CS, because these aren’t computer science classes. They are not CS0, CS1, or CS0.5, all of which presume a linear progression towards the goal of being a CS major. Yes, we’re teaching computer science knowledge and skills, but these are classes in Computing for Expression and Computing for Justice. The faculty in those areas are the authorities in what we should teach. They decide what’s important.
Side note: I’ve had these data for over a year, and even presented some of them in a poster at ITiCSE last year. I have trying to figure out how to share them. Maybe this could have been a peer-reviewed publication (conference or journal)? I don’t know. It’s a design activity, and I learned a lot from it, but I don’t know how to write about it as scholarship. I finally decided to write this blog post so that I could share the whole big Padlet whiteboards. Traditional publication venues would be unlikely to let me put these big pictures out there, but I can in a blog post.
My many thanks to my advisors for these classes: Yvette Granata, Catherine Griffiths, M. Remi Yergeau, Tony Bushner, Justin Schell, Jan Van den Bulck, Justin Joque, Sarita Schoenebeck , Nick Henricksen, Maggie Frye, Anne Cong-Huyen, and Matt Bui
Updates: Dr. Barbara Ericson awarded ACM SIGCSE 2022 Outstanding Contributions to Education
March 2-5 is the ACM SIGCSE Technical Symposium for 2022 in Providence, RI. (Schedule is here.) I am absolutely thrilled that my collaborator, co-author, and wife is receiving the Outstanding Contributions to Education award! She is giving a keynote on Friday morning. Her abstract is below.
She’s got more papers there, on CS Awesome, on her ebooks, and on Sisters Rise Up. I’m not going to summarize them here. I’ll let you look them up in the schedule.
A couple of observations about the SIGCSE Awards this year that I love. Both Barb and the Lifetime Service to the Computer Science Education Community awardee, Simon, earned their PhD’s later in life, both within the last 10 years. Barb is the first Assistant Professor to win the Outstanding Contributions award in the 40 year history of the award.
I have one Lightning Talk. The work I’m doing these days is computing education, but it’s not in the mainstream of CS education — I focus on computing education for people who don’t want to study CS. So, I’m doing a five minute lightning talk on Teaspoon languages as provocation to come talk to me about this approach to integrating computing into non-CS subjects. You can see the YouTube version here. This is my attempt to show that each Teaspoon language can be learned in 10 minutes — I describe all of two of them in less than five minutes!
Outstanding Contribution Plenary
Friday, March 4 / 8:15 – 9:45
Ballroom A-E (RICC)
Barbara Ericson (University of Michigan)
Improving Diversity in Computing through Increased Access and Success
My goal is to increase diversity in computing. In this talk I explain why diversity is important to me. My strategy to improve diversity is to increase access and success. This work includes teacher professional development, summer camps, weekend workshops with youth serving organizations, curriculum development, helping states make systemic changes to computing education, publicizing gender and race issues in Advanced Placement Computer Science, creating free and interactive ebooks, testing new types of practice problems/tools, and offering near-peer mentoring programs.
Barbara Ericson is an Assistant Professor in the School of Information at the University of Michigan. She conducts research at the intersection of computing education, the learning sciences and HCI, to improve students’ access to and success in computing. With her husband and colleague, Dr. Mark Guzdial, she received the 2010 ACM Karl V. Karlstrom Outstanding Educator Award for their work on media computation. She was the 2012 winner of the A. Richard Newton Educator Award for her efforts to attract more females to computing. She is also an ACM Distinguished Member for Outstanding Educational Contributions to Computing.
Updates: Developing the University of Michigan LSA Program in Computing for the Arts and Science
This blog is pretty old. I started it in June 2009 — almost 13 years ago. The pace of posting has varied from every day (today, I can’t understand how I ever did that!) to once every couple of months (most recently). There are things happening around here that are worth sharing and might be valuable to some readers, but I’m not finding much time to write. So, the posts the rest of this week will be quick updates with links for more information.
During most of the pandemic, I co-chaired (with Gus Evrard, a Physics professor and computational cosmologist) the Computing Education Task Force (website) for the University of Michigan’s College of Literature, Science, and the Arts (LSA). LSA is huge — about 20K students. (I blogged about this effort in April of last year.) Our job was to figure out what LSA was doing in computing education, and what else was needed. Back in November, I talked here about the three themes that we identified as computing education in LSA:
- Computing for Discovery: Think computational science, or data science + modeling and simulation.
- Computing for Expression: Think chatbots to Pixar to social media to Media Computation.
- Computing for Justice: Think critical computing and everything that C.P. Snow and Peter Naur warned us about computing back in the 1960’s.
Our report was released last month. You can see the release statement here, and the full report here. It’s a big report, covering dozens of interviews, a hundred survey responses, and a huge effort searching over syllabi and course descriptions to find where computing is in LSA. We made recommendations about creating a new program, new courses, new majors and minors, and coordinating computing education across LSA.
Now, we’re in the next phase — acting on the recommendations. LSA bought me out of my teaching for this semester, and it’s my full-time job to define a computing education program for LSA and to create the first courses in the program. We’re calling it the Program for Computing in the Arts and Science (PCAS). I’m designing courses for the Computing for Expression and Computing for Justice themes, in an active dialogue (drawing on the participatory design methods I learned from Betsy DiSalvo) with advisors from across LSA. (There are courses in LSA that can serve as introductions to the Computing for Discovery theme, and Gus is leading the effort to coordinate them.) The plan is to put up the program this summer, and I’ll start teaching the new courses in the Fall.
Computer Science was always supposed to be taught to everyone, and it wasn’t about getting a job: A historical perspective
I gave four keynote talks in the last two months, at SIGITE, Models 2021 Educators’ Symposium, VL/HCC, and CSERC. I’m honored to be invited to them, but I do suspect that four keynotes in six weeks suggest some “personal issues” in planning and saying “No.” Some of these were recorded, but I don’t believe that any of them are publicly available
The keynotes had a similar structure and themes. (A lot easier than four completely different keynotes!) My activities in computing education these days are organized around two main projects:
- Defining computing education for undergraduates in the University of Michigan’s College of Literature, Science, and Arts (see earlier blog post referencing this effort);
- Participatory design of Teaspoon languages (mentioned most recently in this blog post).
My goal was to put both of these efforts in a historical context. My argument is that computer science was originally invented to be taught to everyone, but not for economic advantage. I see the LSA effort and our Teaspoon languages connected to the original goals for computer science. The talks were similar to my SIGCSE 2019 keynote (blog post about that talk here, and video version here), but puts some of the early history in a different perspective. I’m not going to go into the LSA Computing Education effort or Teaspoon languages here. I’m writing this up because I hope that it’s a perspective on the early history that might be useful to others.
I start out with C.P. Snow.
My PhD advisor, Elliot Soloway, would have all of his students read this book, “The Two Cultures.” Snow was a scientist who bemoaned the split between science and humanities in Western culture. Snow mostly blamed the humanities. That wasn’t Elliot’s point for having us read his book. Elliot wanted us to think about “Who could use what we have to teach, but might not even enter our classroom?”
This is George Forsythe. Donald Knuth claims that George Forthye first published the term “computer science” in a paper in the Journal of Engineering Education in 1961. Forsythe argued (in a 1968 article) that the most valuable parts of a scientific or technical education were facility with natural language, mathematics, and computer science.
In 1961, the MIT Sloan School held a symposium on “Computers and the World of the Future.” It was an amazing event. Attendees included Gene Amdahl, John McCarthy, Alan Newell, and Grace Hopper. Martin Greenberger’s book in 1962 included transcripts of all the lectures and all the discussants’ comments.
C.P. Snow’s chapter (with Norbert Wiener of Cybernetics as discussant) predicted a world where software would rule our lives, but the people who wrote the software would be outside the democratic process. He wrote, “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.” He argued that everyone needed to learn about computer science, in order to have democratic control of these processes.
In 1967, Turing laureate Peter Naur made a similar argument (quoting from Michael Caspersen’s paper): “Once informatics has become well established in general education, the mystery surrounding computers in many people’s perceptions will vanish. This must be regarded as perhaps the most important reason for promoting the understanding of informatics. This is a necessary condition for humankind’s supremacy over computers and for ensuring that their use do not become a matter for a small group of experts, but become a usual democratic matter, and thus through the democratic system will lie where it should, with all of us.” The Danish computing curriculum explicitly includes informing students about the risks of technology in society.
Alan Perlis (first ACM Turing Award laureate) made a different argument in his chapter. He suggested that everyone at University should learn to program because it changes how we understand everything else. He argued that you can’t think about integral calculus the same after you learn about computational iteration. He described efforts at Carnegie Tech to build economics models and learn through simulating them. He was foreshadowing modern computational science, and in particular, computational social science.
Perlis’s discussants include J.C.R. Licklider, grandfather of the Internet, and Peter Elias. Michael Mateas has written a fascinating analysis of their discussion (see paper here) which he uses to contextualize his work on teaching computation as an expressive medium.
In 1967, Perlis with Herb Simon and Alan Newell published a definition for computer science in the journal Science. They said that CS was “the study of computers and all the phenomena surrounding them.” I love that definition, but it’s too broad for many computer scientists. I think most people would accept that as a definition for “computing” as a field of study.
Then, we fast forward to 2016 when then-President Obama announced the goal of “CS for All.” He proposed:
Computer science (CS) is a “new basic” skill necessary for economic opportunity and social mobility.
I completely buy the necessity part and the basic skill part, and it’s true that CS can provide economic opportunity and social mobility. But that’s not what Perlis, Simon, Newell, Snow, and Forsythe were arguing for. They were proposing “CS for All” decades before Silicon Valley. There is value in learning computer science that is older and more broadly applicable than the economic benefits.
The first name that many think of when talking about teaching computing to everyone is Seymour Papert. Seymour believed, like Alan Perlis, “that children can learn to program and learning to program can affect the way that they learn everything else.”
The picture in the lower right of this slide is important. On the right is Gary Stager, who kindly shared this picture with me. On the left is Wally Feurzeig who implemented the programming language Logo with Danny Bobrow, when Seymour was a consultant to their group at BBN. In the center is Cynthia Solomon who collaborated with Seymour on the invention of the Turtle (originally a robot, seen at the top) and the development of Logo curriculum.
Cynthia was the lead author of a recent paper describing the history of Logo (see link here), which included the example of early Logo use on the upper right of this slide, which generates random sentences. Logo is named for the Greek word logos for “word.” The first examples of Logo were about manipulating natural language. Logo has always been used as an expressive medium (music, graphics, storytelling, and animation), as well as for learning mathematics (see the great book Turtle Geometry).
This is the context in which I think about the work with the LSA Computing Education Task Force. Our question was: At an R1 University with a Computer Science & Engineering undergraduate degree and an undergraduate BS in Information (with tracks in information analysis and user experience (UX) design), what else might undergraduates need? What are the purposes for computing that are broader and older than the economic advantages of professional software development? We ended up defining three themes of what LSA faculty do with computing and what they want their students to know:
- Computing for Discovery – LSA computational scientists create models and simulate them (not just analyze data that already exists), just as Alan Perlis suggested in 1961.
- Computing for Expression – Computing has created new ways for humans to express themselves, which is important to study and to use to explore, invent, and create new forms of expression, as the Logo community did starting in the 1960’s.
- Computing for Justice – LSA scholars investigate how computing systems can encode and exacerbate inequities, which requires some understand of computing, just as C.P. Snow talked about in 1961.
We develop our Teaspoon languages to meet the needs of teachers in teaching non-CS and even non-STEM classes. We argue that there are computing education learning objectives that we address with Teaspoon languages, even if they don’t include common languages features like for, while, and if statements. A common argument against our work in Teaspoon languages is that we’re undertaking a Sisyphean task. Computing is what it is, programming languages are what they are, and education is not going to be a driving force for changing anything in computing.
And yet, that’s exactly how the desktop user interface was invented.
Alan Kay (another Turing laureate in this story), Adele Goldberg, and Dan Ingalls led the development of Smalltalk in Xerox PARC in the 1970’s. The goal for Smalltalk was to realize Alan’s vision of a Dynabook, using the computer as a tool for learning. The WIMP (overlapping Windows, Icons, Menus, and mouse Pointer) interface was invented in order to achieve computing education goals. For the purposes of education, the user interface that you are using right now was invented.
The Smalltalk work tells us that we don’t have to accept computing as it is. Computing education today focuses mostly on preparing students to be professional software developers, using the tools of professional software development. That’s important and useful, but often eclipses other, broader goals for learning computing. The earliest goals for computing education are different from those in most of today’s computing education. We should question our goals, our tools, and our assumptions. Computing for everyone is likely going to look different than the computing we have today which has been defined for a narrow set of goals and for far fewer people than “all.”
Media Computation today: Runestone, Snap!, Python 3, and a Teaspoon Language
I don’t get to teach Media Computation1 since I moved to the University of Michigan, so I haven’t done as much development on the curriculum and infrastructure as I might like if I were teaching it today. I did get a new version of JES (Jython Environment for Students) released in March 2020 (blog post here), but have rarely even started JES since then.
But using Jython for Media Computation is so 2002. Where is Media Computation going today?
I’ve written a couple of blog posts about where Media Computation is showing up outside of JES and undergraduate CS. Jens Moenig has been doing amazing things with doing Media Computation in Snap! — see this blog post from last year on his Snap!Con keynote talk. SAP is now offering a course From Media Computation to Data Science using Snap! (see link here). Barbara Ericson’s work with Runestone ebooks (see an example blog post here) includes image manipulation in Python inside the browser at an AP CS Principles level (see example here). The amazing CS Awesome ebook that Beryl Hoffman and Jen Rosato have been doing with Barb for AP CS A includes in-browser coding of Java for the Picture Lab (see example here).
I was contacted this last January by Russ Tuck and Jonathan Senning. They’re at Gordon College where they teach Media Computation, but they wanted to do it in Python 3 instead of Jython. You can find it here. It works SO well! I miss having the image and sound explorers, but my basic demos with both images and sounds work exactly as-is, with no code changes. Bravo to the Gordon College team!
Most of my research these days is grounded in Task-Specific Programming languages, which I’ve blogged about here (here’s a thread of examples here and here’s an announcement of funding for the work in social studies). We now refer to the project as Teaspoon Computing or Teaspoon Languages — task-specific programming => TSP => Teaspoon. We’re adding a teaspoon of computing into other subjects. Tammy Shreiner and I have contributed a chapter on Teaspoon computing to a new book by Aman Yadav and Ulf Dalvad Berthelsen (see announcement of the book here).
We have a new Teaspoon language, Pixel Equations, that uses Media Computation to support an Engineering course in a Detroit Public School. Here, students choose a picture as input, then (1) enter the boolean equations for what pixels to select and (2) enter equations for new red, green, and blue values for those pixels. The conditionals and pixel loops are now implicit.
In several of our tools, we’re now exploring bilingual or multilingual interfaces, inspired by Sara Vogel’s work on translanguaging (see paper here) and Manuel Pérez-Quiñones’s recent work on providing interfaces for bilingual users (see his TED talk here and his ACM Interactions paper here). You can see in the screenshot below that colors can be referenced in either English or Spanish names. We’re now running participatory design sessions with teachers using Pixel Equations.
I’m planning a series of blog posts on all our Teaspoon languages work, but it’ll take a while until I get there.
- For new readers, Media Computation is a way of introducing computing by focusing on data abstractions used in digital media. Students write programs to manipulate pixels of a picture (to create photo filters), samples of a sound (e.g., to reverse sounds), characters of a text, and frames of a video (for video special effects). More at http://mediacomputation.org ↩
Announcing the inaugural Illinois Computer Science Summer Teaching Workshop: Guest blog post from Geoffrey Challen
We are excited to invite you to the inaugural Illinois Computer Science Summer Teaching Workshop: https://teaching-workshop.cs.illinois.edu/. The 2021 workshop will be held virtually over two half-days on August 10–11, 2021. The workshop is free to attend, and teaching faculty, research faculty, as well as graduate and undergraduate students are all invited to participate—either by presenting, or by joining the conversation. The deadline to submit an abstract is Tuesday July 20th.
Our goal is to bring together college instructors who are engaged with teaching computer science to discuss best practices, present new ideas, challenge the status quo, propose new directions, debunk existing assumptions, advocate for new approaches, and present surprising or preliminary results. This year’s theme is “How the Pandemic Transformed Our Teaching“, allowing participants to reflect on the difficult year behind us as we prepare to return to classrooms next fall. We are excited to welcome Professors Margo Seltzer (UBC), Tiffani Williams (Illinois), Susan Rodger (Duke), Nate Derbinsky (Northeastern), and David Malan (Harvard) as invited speakers.
Considering the Danish Informatics Curriculum: Comparing National Computer Science Curricula
Michael Caspersen invited me to review a chapter on the Danish Informatics curriculum (see a link here). He asked me to compare it to existing school CS curriculum with which I’m familiar. That was an interesting idea — how does anyone relate curricula across diverse contexts, even between nations? I gave it a shot. I most likely missed, in that there are many curricula that I don’t know or don’t know well enough. I welcome comments on other CS curricula.
The Danish Informatics curriculum is unique for its focus on four competence areas:
- Digital empowerment which describes the ability to review and critique digital artifacts to ask where the strict demands of a computational system may not serve well the messy world in which humans live.
- Digital design and design processes which describes the ways in which designers come to understand the problem domain for which we design digital artifacts.
- Computational thinking and modeling which describes how data and algorithms are used to construct digital solutions and artifacts.
- Technological knowledge and skills which describes the tools (e.g., programming languages) and infrastructures (e.g., computer systems, networking) used to construct digital solutions and artifacts.
I am not familiar with any curriculum that encompasses all four competencies. I’m most familiar with elementary and high school curricula in the United States. Each US state has control over its own school system (i.e., there is no national curriculum) though many are influenced by recommendations from the Computer Science Teachers Association (CSTA) (see link here) and the K12 CS Framework (link here).
In the United States, most computing curricula focus on technological knowledge and skills and computational thinking and modeling. The former is important because the economic argument for computing education in schools is the most salient in the United States. The latter most often appears as a focus on learning computing skills without programming, e.g., like in the CS Unplugged activities from Tim Bell at the University of Canterbury (link).
Modeling is surprising rare in most state curricula. Calls for modeling and simulation are common in US mathematics and science education frameworks like the Next Generation Science Standards (link), but these have influenced few state curricula around computing education. Efforts to integrate computing to serve the needs of mathematics and science education are growing, but only a handful of states actively promote computing education to support mandatory education. For example, Indiana has include computing learning objectives in their state’s science education standards, in order to develop more integrated approaches.
I don’t know of any state curricula that include digital empowerment nor digital design and design processes. These are critically important. Caspersen’s arguments for the Danish Informatics curriculum build on quotes from Henry Kissinger and Peter Naur, but could also build on the work of C.P. Snow and Alan Perlis (the first ACM Turing Award laureate). In 1961, Snow and Perlis both argued for mandatory computing (though at the University level). Perlis argued that computing gave us new ways to understand the world. He would have recognized the digital design and design processes competency area. Snow warned that everyone should learn computing in order to understand how computing is influencing our world. He wrote: “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.” He would recognize the concerns of Kissinger and Naur, and the importance of digital empowerment.
The Danish Informatics curriculum is unique in its breadth and for considering the social aspects of computing artifacts and design. It encompasses important needs for citizens of the 21st Century.
The Bigger Part of Computing Education is outside of Engineering Education
My Blog@CACM post this month is about the differences I’ve seen between computing education and engineering education (see link here). Engineering education has a goal of producing professional engineers. I describe in the post how ASEE is about the profession of engineering, and developing an engineering identity is a critical goal of engineering education. Computing education is about producing software engineers, but that’s only part of what computing education is about. SIGCSE is about learning and teaching of computing, and as computing educators, we teach students with diverse identities. They overlap, but the part of computing education that is outside the intersection with engineering education is much bigger than the part inside.
Computing education for me is about helping people to understand computing (see the Call for Papers for the International Computing Education Research conference) — not just CS education at the undergraduate level. Preparing future software engineers is certainly part of computing education, but sometimes computing educators only see engineering education goals. Computing education has a bigger scope and range than engineering education. Here are three areas where we need to focus on the bigger part outside engineering.
1. K-12 is for everyone. Computing education in elementary and secondary school should be about more than producing software professionals. There are certainly CS teachers who disagree with me. An example is Scott Portnoff’s critique of CS curricula that does not adequately prepare students for the AP CS A exam and the CS major. I agree that we should offer CS courses at secondary school that give students adequate preparation for post-secondary CS education, if students want to go on to a CS major and become a computing professional. But K-12 has to serve everyone, and the most important goals for K-12 CS education are goals for what everyone should learn about computing. We want students:
- To see themselves as capable of doing computer science (the goal of self-efficacy),
- To see the power of the computer in transforming representations, and
- To start on the computer science learning trajectories and discover if they want to learn more.
I am personally much more interested in K-12 teachers using computing to teach everything else better. Computational science and mathematics are powerful for helping scientists and mathematicians gain insight. We should use computing in the same way to advance student learning in STEM, social studies, and other disciplines — without turning those other classes into CS classes. This is the difference that Shuchi Grover is talking about with her two kinds of CT: learning about CS vs using computing to learn other things.
2. Courses for non-CS Majors. I’m co-chairing a task force on computing education for the University of Michigan’s College of Literature, Sciences, & Arts (LSA) (see a blog post on this effort and our website with our NEW preliminary report). I’m learning about the ways that LSA faculty use computing and how they want their students to learn about and use computing. Their purposes are so different from what we teach in classes about computer science or data science. Sure, computational scientists analyze data like data scientists, but they also create models that turn their theories into simulations (which can then generate data). Computational artists use computing to tell engaging stories in new ways. Computational journalists investigate and discover truth with computing. LSA faculty care a great deal about their students critiquing how our computing systems and infrastructure may be unjust and inequitable. (Interesting note: The word “justice” does not appear in the new Computing Curriculum 2020, and the word “equity” appears only once.)
There are computer scientists who tell me that there is only one computer science for all students. Their argument is that better engineering practices help everyone — if those computational scientists, journalists, and artists just programmed like software engineers, the world would be a better place. Their code would be more robust, more secure, and more extensible. That is likely true, but that perspective is misunderstanding the role of code in doing science and making art. You don’t critique the poet for not writing like a journalist or a novelist. These are different activities with different goals.
We should teach non-CS majors with courses that serve their needs, speak to their identities, and support their values. We should not require all artists and scientists to think, act, and program like engineers just to take computing classes.
A CS educator in the Bay area once tried to convince me that the most important purpose for courses for non-CS majors was to identify the potential for being great programmers. He claimed that there are programmers who are two magnitudes better than their peers, and identifying them is the most important thing we can do to support and advance the software companies on which our world economy depends. He argued that we should teach non-CS majors in order to identify and promote future engineers, not for their own purposes. I see his argument, but I do not agree that scientists, journalists, and artists are less important than engineers. As I consider this pandemic, I think about the role that computing has played in medicine, logistics, and media. Of course, we have relied heavily on software engineering, but I don’t believe that it’s more important than all the other roles that computing played.
3. Supporting diverse identities. There is a disconnect between efforts to broaden participation in computing and framing CS classes as engineering education. As I mentioned in my Blog@CACM post, I taught my first EER course this last semester and read a lot of EER papers. A big focus in engineering education is developing an engineering identity, i.e., helping students to see themselves as members of the engineering community of practice and as future professional engineers.
One of my favorite papers that we read this semester was “Feminist Theory in Three Engineering Education Journals: 1995–2008” by Beddoes and Borrego. They define different branches of feminism. “Liberal feminism” is the goal for women to be treated the same as men, to get access to the same jobs at the same pay. “Standpoint feminism” points out that “liberal feminism” is too much about fitting women into the jobs and cultures of men, as opposed to asking how things would be different if created from a feminist standpoint.
The professional identity of software engineering is male and White. That’s true from the demographics of who is in the Tech industry, but it’s also true from a historical perspective on the systemic bias in computing. Computing has become dominated by men, with many studies and books describing how women were forced out (see for example The Computer Boys Take Over and Programmed Inequality). Our tools privilege one part of the world. Every one of our mainstream programming languages is built on English keywords. That’s a barrier for 85% of the people on Earth. (Related point: I recommend Manuel Pérez Quiñones’ TED talk “Why I want My Voice Assistant to Speak Spainglish” in which he suggests that the homogenous background of American software engineers leads to few bilingual user interfaces — surprising when 60% of the human race is.)
There’s the disconnect. We want students in computing with diverse perspectives and identities. But engineering education is about developing an identity as a future professional engineer. Professional software engineering is male and White. How do we prepare diverse students to be future software engineers when that professional identity conflicts with their identities? We should teach computing, even for CS majors, in ways that go beyond the engineering education goal of developing a professional engineering identity.
We might argue that we want everyone to have the opportunity to participate in CS, but that’s taking the “liberal” perspective. Broadening participation should not be about fitting everyone into the same identity. It’s not enough to say that everyone has the chance to learn the programming languages that are based in English, that are grounded in Western epistemologies, and where the contributions of women have been marginalized. We need to find ways to accept and support the unique identities of diverse people.
One way to support a “standpoint” perspective on computing education might be to support activity over identity in our CS curriculum. At Georgia Tech, the undergraduate computer science degree is based on Threads (see website). There are threads for Intelligence, People, Media, Devices, and Theory — eight of them in all. A BS in CS at Georgia Tech is any two threads, so there are 28 paths to a degree. This allows students to define their professional identity in terms of what they are going to DO with computing. “I’m studying People and Devices” is something a student might say who wants to create consumer computational devices like Echo or Roomba. The Threads curriculum allows students to make choices about professional identity, in terms of how they want to contribute to society.
Of course, some of our students want to become software engineers at a FAANG company. That’s great, and we should support them and prepare them for those roles. But we should not require those identities. Computing education is about more than producing software engineers who have the traditional engineering identity.
The Bigger Part of Computing Education. I claimed at the start of this post that “computing education that is outside the intersection with engineering education is much bigger than the part inside.” All the studies I have seen say that’s true. While CS undergraduate enrollment has been exploding, the number of end-user programmers is likely a magnitude larger than the number of professional software developers. K-12 is about 50 million students in the United States, and computing education is available to most of them. The number of computing education students who are NOT seeking an engineering identity or profession is much larger than those who are. That’s the more-than-engineering challenge for computing education.
My thanks to Leo Porter, Cynthia Lee, Adrienne Decker, Briana Morrison, Ben Shapiro, Bahare Naimipour, Tamara Nelson-Fromm, and Amber Solomon who gave me comments on earlier drafts of this post.
Become a Better CS Teacher by Seeing Differently
My Blog@CACM post this month is How I evaluate College Computer Science Teaching. I get a lot of opportunities to read teaching statements and other parts of an academic’s teaching record. I tend to devalue quantitative student evaluations of teaching — they’re biased, and students don’t know what serves them best. What I most value are reports of the methods teachers use when they teach. Teachers who seek out and use the best available methods are mostly likely the best teachers. That is what I look for when I have to review College CS teaching records.
On Twitter, people are most concerned with my comments about office hours. Computer science homework assignments should not be written expecting or requiring everyone in the class to come to office hours in order to complete the assignment. That’s an instructional design problem. If there are questions that are coming up often in office hours, then the teacher should fix the assignment, or add to lecture, or make announcements with the clarification. Guided instruction beats discovery learning, and inquiry learning is improved with instruction. There is no advantage to having everyone in the class discover that they need a certain piece of information or question answered.
My personal experience likely biases me here. I went to Wayne State University in Detroit for undergraduate, and I lived in a northern suburb, five miles up from Eight Mile Road. I drove 30-45 minutes a day each way. (I took the bus sometimes, if the additional time cost was balanced out by the advantage of reading time.) I worked part-time, and usually had two part-time jobs. I don’t remember ever going to office hours. I had no time for office hours. I often did my programming assignments on nights and weekends, when there were no office hours scheduled. If an assignment would have required me to go to office hours, I likely would have failed the assignment. That was a long time ago (early 1980’s) — I was first generation, but not underprivileged. Today, as Manuel pointed out (quoted in this earlier blog post), time constraints (from family and work) are a significant factor for some of our students.
Teachers who require attendance at office hours are not seeing the other demands on their students’ lives. Joe Feldman argues that we ought to be teaching for the non-traditional student, the ones who have family and work demands. If we want diverse students in our classes, we have to learn to teach for the students whose experiences we don’t know and whose time costs we don’t see.
CS teachers get better at what we see
I’m teaching an Engineering Education Research class this semester on “Theoretical and Conceptual Frameworks for Engineering Education Research.” We just read the fabulous chapter in How People Learn on How Experts differ from Novices. One of the themes is on how experts don’t necessarily make good teachers and about the specialized knowledge of teachers (like pedagogical content knowledge). I started searching for papers that did particularly insightful analyses of CS teacher knowledge, and revisited the terrific work of Neil Brown and Amjad Altadmri on “Novice Java Programming Mistakes: Large-Scale Data vs. Educator Beliefs” (see paper here).
Neil and Amjad analyze the massive Blackbox database of keystroke-level data from thousands of students learning Java. They identify the most common mistakes that students make in Java. My favorite analyses in the paper are where they rank these common mistakes by time to fix. An error with curly brackets is very common, but is also very easy to fix. Errors that can take much longer (or might stymie a student completely) include errors with logical operators (ANDs and ORs), void vs non-void return values, and typing issues (e.g., using == on strings vs .equals).
The more controversial part of their analysis is when they ask CS teachers what students get wrong. Teachers’ predictions of the most common errors are not accurate. They’re not accurate when considered in aggregate (e.g., which errors did more teachers vote for) nor when considering the years of experience of a teacher.
Neil and Amjad contrast their findings with work by Phil Sadler and colleagues showing that teacher efficacy is related to their ability to predict student errors (see blog post here).
If one assumes that educator experience must make a difference to educator efficacy, then this would imply that ranking student mistakes is, therefore, unrelated to educator efficacy. However, work from Sadler et al. 2013 in physics found that “a teacher’s ability to identify students’ most common wrong answer on multiple-choice items . . . is an additional measure of science teacher competence.” Although picking answers to a multiple-choice question is not exactly the same as programming mistakes, there is a conflict here—either the Sadler et al. result does not transfer and ranking common student mistakes is not a measure of programming teacher competence, or experience has no effect on teacher competence. The first option seems more likely. (Emphasis added.)
I don’t see a conflict in that sentence. I believe both options are true, with some additional detail. Ranking common student compiler mistakes is not a measure of programming teacher competence. And experience has no effect on teacher competence on things they don’t see or practice.
Expertise is developed from deliberate practice. We get better at the things we work at. CS teachers certainly get better (become more competent) at teaching. Why would that have anything to do with knowing what compiler errors that Java students are getting? Teachers rarely see what compiler errors their students are getting, especially in higher-education with our enormous classes.
When I taught Media Computation, I thought I became pretty good at knowing what errors students got in Python. I worked side-by-side students many times over many years as they worked on their Python programs. But that’s still a biased sample. I had 200-300 students a semester. I might have worked with maybe 10% of those students. I did not have any visibility on what most students were getting wrong in Python. I probably would have failed a similar test on predicting the most common errors in Python based on my personal experience. I’m sure I’d do much better when I rely on studies of students programming in Python (like the study of common errors when students write methods in Python) — research studies let me see differently.
Here at the University of Michigan, I mostly teach a user interface software class on Web front-end programming in JavaScript. I am quite confident that I do NOT know what JavaScript errors my students get. I have 260-360 students a semester. Few come to office hours with JavaScript errors. I rarely see anybody’s code.
I do see exams and quizzes. I know that my students struggle with understanding the Observer Design pattern and MVC. I know that they often misunderstand the Universal Design Principles. I know that CSS and dealing with Java asynchronous processing is hard because that’s where I most often get regrade requests. There I’ll find that there is some unexpected way to get a given effect, and I often have to give points back because their approach works too. I get better at teaching these things every semester.
CS teachers can be expected to become more competent at what they see and focus on. Student compiler errors are rarely what they see. They may see more conceptual or design issues, so that’s where we would expect to see increased teacher competence. To developer teacher competence beyond what we see, we have to rely on research studies that go beyond personal experience.
CS teachers need to get better at teaching those we don’t see
The same principle applies to why we don’t improve the diversity of our CS classes. CS teachers don’t see the students who aren’t there. How do you figure out how to teacher to recruit and retain women and students from Black, Latino/Latina, and indigenous groups if they’re not in your classes? We need to rely on research studies, using others’ eyes and others’ experiences.
Our CS classes are huge. It’s hard to see that we’re keeping students out and that we’re sending a message that students “don’t belong,” when all we see are huge numbers. And when we have these huge classes, we want the majority of students to succeed. We teach to the average, with maybe individual teacher preference for the better students. We rarely teach explicitly to empower and advantage the marginalized students. They are invisible in the sea of (mostly male, mostly white or Asian) faces.
I have had the opportunity over the last few months to look at several CS departments’ diversity data. What’s most discouraging is that the problem is rarely recruitment. The problem is retention. There were more diverse students in the first classes or in the enrolled population — but they withdrew, failed, or dropped out. They were barely visible to the CS teachers, in the sea of huge classes, and they become completely invisible. We didn’t teach in a way that kept these students in our classes.
Our challenge is to teach for those who we don’t easily see. We have to become more competent at teaching to recruit those who aren’t there and retain those students who are lost in our large numbers. We easily become more competent at teaching for the students we see. We need to become more competent at teaching for diversity. We do that by relying on research and better teaching methods, like those I talk about in my Blog@CACM post.
Computing Ed Research - Guzdial's Take 
Recent Comments