Posts tagged ‘diversity’

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.

February 15, 2021 at 7:00 am 2 comments

Promote diversity by teaching to many goals for computing

My Blog@CACM post for this month is about the working definitions of computing that we are developing in a task force at the University of Michigan see post here). We are charged with identifying the computing education needs for undergraduates in the College of Literature, Sciences, and the Arts (LS&A). My post describes three different goals for computing education, based on what LS&A faculty do with computing and what they want their students to know.

  • Computing for Discovery
  • Computing for Expression
  • Critical Computing

In my post, I described how these are different, and about the challenges of meeting all of these educational needs. The biggest challenge I wonder about is the organizational one. Whose job is it to teach to each of these goals?

In this post, I want to argue from a different direction. All of these have a CS component. These aren’t typically priorities in many CS departments. To have more diversity in computer science, we ought to make them a priority.

There’s CS in All of These

Each of the three LS&A themes represent a significant CS research thrust. We distilled them from discussions with faculty in Literature, Sciences, & the Arts, but students could be interested in these themes and seek a computer science degree and career. I’d expect that these themes are more common among students who enter computing from liberal arts and sciences than from engineering.

Computer scientists often create infrastructure and theory for “Computing for Discovery,” from NeurIPS to ACM SIGSIM. At Georgia Tech, there is a School for Computational Science and Engineering. One of my colleagues in that school was Richard Fujimoto, who studied how to run discrete event simulations in parallel and distributed systems. He does his research so that others (scientists or engineers) could do theirs.

Computer scientists invent and create tools to make “Computing for Expression” possible, presented in places like ACM SIGGRAPH and CHI. Alanson Sample joined U-M CSE the same time I did. He was formerly at Disney Research at Pittsburgh, where some of his team worked on the new Pandora exhibits at Disney World. The animatronic Na’vi were difficult for the animators to control, since the robot representation of the aliens were not meant to be human-like. Alanson’s colleagues created new kinds of design tools to support translating facial animations into robotic actuation for the Na’vi. I love that as an example of computer science enabling a new kind of expression.

Technology Review recently published an accessible summary of the paper that led to Timnit Gebru’s being fired from Google (see link here). I knew about Timnit’s work as a scholar in “Critical Computing.” The TR piece did a terrific job explaining the deep CS ideas in their paper — like the potential fallacies of the language models used by Google and the enormous energy costs of running them. Computer science plays an important part in making thoughtful critiques of existing computing systems and infrastructures.

Supporting Diverse Goals for Diverse Students

Imagine that you are a student who has always dreamed of working at Pixar and building tools for animators. Or you are a student who is concerned about creating sustainable IT infrastructure for your community. You decide to pursue a computer science degree, and now you’re in classes about AVL trees or learning the issues between cache coherence and memory consistency. You might very reasonably drop out, to pursue a degree that move clearly helps you better achieves your goals. The problem is that that those are computer science issues. It’s perfectly reasonable to pursue computing education for those goals, but those might not be the goals that most CS Departments at Universities support.

This does happen exactly as I described. Colleen Lewis and her colleagues showed us how it most often happens with candidates who are from groups under-represented in computer science (see blog about the paper here). These students come to computer science with their goals, and if they don’t see how to achieve their goals with the classes they’re given, they lose interest and drop out. Colleen and her students showed that having goals about community values were were more common among students who were female, Black, or Hispanic than students who were male, white, or Asian.

The draft of the 2020 ACM/IEEE Computing Curriculum report is here. It’s a big document, so I might have missed it, but I don’t see these goals represented in the computer science outcomes. Some of these themes are in information systems or information technology. Some of the media fundamentals are in computer engineering. The core of computer science in the 2020 report is focused on “algorithms and complexity, programming languages, software development fundamentals, and software engineering” (quoting page 28). There is very little in the document about justice, equity, and critical consideration of our computing systems and infrastructure.

A student can certainly start from the core of CS and focus on any of these sets of goals — but do students know that? How do we communicate that to them? This was a real problem when we created the Threads program at Georgia Tech where students identify two “threads” of computing which they will combine to create their BS in CS degree program. A student who chooses Media and Theory may be interested in video compression algorithms, and a student who chooses People and Intelligence might be interested in creating explainable AI, but both of those students will be in the same data structures and discrete math classes. We (mostly Charles Isbell and Bill Leahy) made sure that the foundational classes created the narratives that explained how the foundational concepts connected to these Threads. We wanted students to see how their goals were met by the core of CS.

This might be easier in colleges focused on liberal arts and sciences with smaller classes. At my University, I taught the introduction to computing course to 760 students. We regularly have first year CS courses with over 1000 students. It’s very hard to cater to individual student goals at that scale. What we did at Georgia Tech and what we’re doing in our task force at the University of Michigan is to identify common goals and themes, and provide support and narrative for those. We will not reach all students’ goals. We aim to support more student goals than just software development in large Tech firms.

We do our students a disservice if we do not help them see how they can pursue their goals within our undergraduate programs. A computer science degree from a major University is a big deal. It’s worth a lot in the economic marketplace. Is it fair to deny the degree to students who are engaged and curious about computer science because our CS undergraduate programs focus on one set of goals and ignore the others? Computer science is broader than just what the FAANG companies hire. CS undergraduate degree programs should not just be a Silicon Valley jobs program. Universities should support diversity in CS thoughts and goals if we want to have students from diverse backgrounds in computing.

January 11, 2021 at 7:00 am 2 comments

NSF funds FLIP Alliance to diversify CS professoriate #CSEdWeek

This is an exciting new project from Valerie Taylor (University of Chicago), Charles Isbell (Georgia Tech), and Jeffrey Forbes (Duke University). It’s based on an observation that Charles has made before, that we can diversify CS faculty by impacting just a handful of schools.

The goal of the NSF-funded FLIP (Diversifying Future Leadership in the Professoriate) Alliance is to address the broadening participation challenge of increasing the diversity of the future leadership in the professoriate in computing at research universities as a way to achieve diversity across the field.  In particular, the problem that we address is stark and straightforward: only 4.3% of the current tenure-track faculty in computing at these universities are from underrepresented groups.

The FLIP Alliance solution is equally stark and straightforward: we intentionally bring together the very small number of departments responsible for producing the majority of the professoriate with individuals and organizations that understand how to recruit, retain, and develop students from underrepresented groups in order to create a network that can quickly and radically change the demographic diversity of the professoriate across the entire field.

from CMD-IT FLIP Alliance

December 7, 2017 at 7:00 am 5 comments

Why Some Teams Are Smarter Than Others: Have more women on the team

An argument for diversity is that it leads to better team decisions and designs.  But it turns out that having women on the team at all leads to better group performance.  It’s an important finding to argue why we need more women in CS, which is still a question I hear regularly, “So what if almost all our undergraduates are women?”  Or as one blogger recently put it (see here if you really want to read more of this), “No one in the tech sector right now gives a shit about diversity. There is no reason whatsoever why a lack of diversity in the field would be a problem unless it comes from government quotas and legal threats.”

Instead, the smartest teams were distinguished by three characteristics.

First, their members contributed more equally to the team’s discussions, rather than letting one or two people dominate the group.

Second, their members scored higher on a test called Reading the Mind in the Eyes, which measures how well people can read complex emotional states from images of faces with only the eyes visible.

Finally, teams with more women outperformed teams with more men. Indeed, it appeared that it was not “diversity” (having equal numbers of men and women) that mattered for a team’s intelligence, but simply having more women. This last effect, however, was partly explained by the fact that women, on average, were better at “mindreading” than men.

via Why Some Teams Are Smarter Than Others – NYTimes.com.

February 19, 2015 at 8:07 am 2 comments

New International Conference: Research on Equity and Sustained Participation in Engineering, Computing, and Technology (RESPECT)

Shared from Tiffany Barnes, with her permission.

The engagement of diverse people in an endeavor drives creativity and innovation, but in computing and STEM fields, broadening participation is also a matter of equity. It is critical that we, as the computer science education community, improve inclusion of diverse people, especially those from underrepresented populations. Globally, underrepresentation differs regionally and culturally by gender, race, ethnicity, socio-economic advantage, physical, mental, and cognitive ability, and LGBT status. The need to support diversity becomes even more important for disenfranchised groups with limited legal rights and protections. Lest we think that this is a minority-only issue, consider developing countries or the poor of every nation, with little to no access to education and resources, where computing could help build the economy, health, education, and financial systems.

We invite you to join IEEE Computer’s newly-established Special Technical Community on Broadening Participation (stcbp.org) to create a collective global strategy to research and improve participation and inclusion in computing.

Research on Equity and Sustained Participation in Engineering, Computing, and Technology (RESPECT) is the focus of our first international meeting. Co-located with the STARS Celebration in Charlotte, NC, just after ICER, RESPECT 2015 will be a premier research conference with research papers, experience reports (due March 27), posters and panels (due June 5). We invite all interdisciplinary work that draws on computer science, education, learning sciences, and the social sciences to help us build a strong community, theory, and foundation for broadening participation research.

We hope you will get involved today by joining stcbp.org, submitting to stcbp.org/RESPECT2015, attending RESPECT 2015 August 13-14, or contacting the STC-BP chairs Tiffany Barnes, tiffany.barnes@gmail.com, or George K. Thiruvathukal, gkt@cs.luc.edu.

January 24, 2015 at 8:27 am Leave a comment

How high school students start thinking about code

My colleague Amy Bruckman and her student Betsy diSalvo have a really great project going on this summer, called Glitch.  Betsy is interested in how African-American males engage with technology and why so few pursue computing as a career.  She notes that African-American males play video games more than any other gender-ethnicity demographic groups, and yet are one of the most under-represented groups in computing majors and careers.  To address this discrepancy, Betsy and Amy are training a group of African-American teen age boys to be game testers, and in so doing, getting them to engage with how the games they love are built.

Amy and Betsy are teamed up with Dr. Charles Meadows of Morehouse College, who is teaching the teenagers how to program in Alice.  Betsy wanted them to see some textual code, too, to get them to see how programs like their games are created.  I agreed to teach a few sessions of Alice + Media Computation (like at the Tea Party site) being developed by Barb Ericson, Wanda Dann, and Steve Cooper.  That way, they’d be learning a bit of textual code to work with their Alice worlds.  I decided to do it with Python, so that there’d be less overhead than Java.  (My slides are available, if you’re interested.)

I’ve found it fascinating to work with the Glitch guys.  It’s been many years since I’ve taught high school students, and rarely in a situation with a small number of students.  I get the chance to see what they’re struggling with, and how they tackle problems.  I’m learning a lot about how these students think about code.

They got the idea early on that they can change constants in programs, and things generally keep working, though sometimes in new ways.  One of the students took our function to generate a negative of an image and started changing constants, like this:

def negative(picture):
  for p in getPixels(picture):
    r = getRed(p)
    b = getBlue(p)
    g = getGreen(p)
    #Original: color = makeColor(255-r, 255-g, 255-b)
    color = makeColor(20-r, 5-g, 100-b)
    setColor(p,color)

The result was really interesting. Because the values for red, green, and blue were clamped at 0, the effect was to posterize the image.  Bright colors emerged, and the number of colors were reduced.  I don’t think the student who invented this really understood what he was doing.  It was a positive outcome that rewarded tinkering, poking-around.

Another one of the students wanted to write a function to make an image completely black.  What he wrote was absolutely amazing to me.

def makeBlack(picture):
  for p in getPixels(picture):
    r = getRed(p)
    b = getBlue(p)
    g = getGreen(p)
    #Original: color = makeColor(255-r, 255-g, 255-b)
    color = makeColor(0=r, 0=g, 0=b)
    setColor(p,color)

I asked him to explain what he was doing.  Here’s how I think he understood his program.  He saw the variables r, g, and b as defining a relationship — that r would represent the red channel for the pixel, so changing r would change the pixel’s red value.  He saw 0=r as setting the red value to zero.  Why didn’t he write “r=0“?  He hadn’t quite internalized left-hand side vs. right-hand side.  He completely understood that he needed to make a color with red, green, and blue all zero, and he could explain clearly what he wanted his program to do. He just didn’t understand why his program didn’t work.  I find it amazing that he had such a clear view of what he wanted and how his program should work.

As a group, I asked them to try to figure out what the right “brightness” value should be, in order to make a grayscale function.  Here’s what we started with:

def grayscale(picture):
  for p in getPixels(picture):
    r = getRed(p)
    b = getBlue(p)
    g = getGreen(p)
    brightness = ???
    color = makeColor(brightness,brightness,brightness)
    setColor(p,color)

The question is, what goes in the place of “???”  Somebody guessed “50” and the others shot him down.  That would fill the whole image with the same gray value.  They guessed “r” (the red channel value) and we tried that — you get a good grayscale, but too light.  Then we tried “b” (the blue channel), and it generates a good-but-dark grayscale.  One of the students correctly said, “We want the average of the color parts!”  So I replaced the right hand side with (r + g + b)/3, and the students started groaning.  “You can do that?!?”  Now, I had told them that the right hand side of the equals sign could be any expression, and I had shown them various expressions.  What was clear that they hadn’t made the connection that the right hand side of the “brightness” computation could be an expression involving red, green, and blue.

I had lunch once with Randy Pausch, the year that SIGCSE was in St. Louis.  He told me, “Variables are easy! You should never have to spend more than 10 minutes on them!”  I think he was telling the truth as he saw it — for Carnegie-Mellon University students.  Most students that I see as non-CS major freshmen at Georgia Tech, and these high school students, find variables and expressions to have a lot more facets and complexities than I might have guessed.  These examples are just pieces of the interesting ways in which they think of variables.  If we want to help students to learn to code, we have to spend time to make sure that they get these basic ideas like variables, which to us are “easy,” but aren’t when one is first getting started.

July 5, 2009 at 10:45 pm 16 comments

Women Programming, Just Not In CS

I gave a talk last week where I was attacked for asking students to program in my Media Computation classes.  “Women don’t want to program.  That will drive them away!”  Is it the activity of programming that leads to our lack of diversity, or something else?

My student, Brian Dorn, is studying end-user programmers.  These are professionals who are not software developers, but who do write programs.  In his studies, these are JavaScript (or ActionScript) users who program for Web pages or for Photoshop.  He just completed a round of interviews with his target population.  Biggest surprise?  Lots of members of minority groups, and lots of women.

I don’t want to steal any of Brian’s thunder and report his results early.  I’m not going to get into where Brian got his interviewees and if it was really a valid sample.  I want to raise the possibility: What if that result generalizes?

We know that there are too few women and minorities amongst professional software developers or undergraduates studying computing.  Almost nobody knows much about professionals from other fields who develop software for their own purposes.  The estimates that have been attempted suggest that there are many, many more end-user programmers than professional software developers.  What if that community reflects  the demographics of our overall population?  What if it’s half female and appropriately diverse?

That would suggest that we’re lacking women in our computer science classes and in the field because of perceptions of the classes and the field (whether or not they’re true), not because of the activity.  That’s a radical idea which suggests some very different strategies for those of us working to broaden participation in computing.  It could be that programming really is seen as fun and beautiful, but it’s how we do our classes and the conditions of software development jobs that are at fault for the lack of diversity.  That would be important to know, because it might be easier to change our classes than it is to change the activity within the field.

June 16, 2009 at 9:39 pm 3 comments


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

Join 9,005 other followers

Feeds

Recent Posts

Blog Stats

  • 1,879,148 hits
October 2021
M T W T F S S
 123
45678910
11121314151617
18192021222324
25262728293031

CS Teaching Tips