Upcoming NSF Computing Education Workshops from Jeff Forbes

Jeff Forbes has just moved back to the National Science Foundation — great news!  He’s asked me to share information on a set of workshops that has just been funded, relevant to this list. People can sign up for the RPP and BPC Departmental Plans workshops now — the rest will have registration information upcoming.

BPC Plans Department Workshop

Award abstract: https://www.nsf.gov/awardsearch/showAward?AWD_ID=1941413

CISE PIs are encouraged to include meaningful BPC plans in proposals submitted to a subset of CISE’s research programs. Nancy Amato (University of Illinois) is hosting a workshop about the development of departmental BPC plans. The workshop is schedule for Nov 13-15 at Univ of Illinois to bring together teams of 2-3 people/department. Register here.

Computing in Undergraduate Education Workshop

Three workshops to “spark a national dialogue about the role of computing in undergraduate education.” The workshops will likely be in Chicago, DC, and Denver. These workshops will hopefully inform the community and NSF as we develop programs like CUE.

See the award abstract for more information https://www.nsf.gov/awardsearch/showAward?AWD_ID=1944777

CS for All RPP Development workshops

http://nnerpp.rice.edu/csforall-workshops/

Career Workshops for Teaching Track Faculty

https://www.nsf.gov/awardsearch/showAward?AWD_ID=1933380

Data Science for All: Designing the Successful Inclusion of Data Science in High School Computer Science

NY Hall of Science will hold a workshop exploring the potential for including authentic data science curricula and hands-on projects in high school CS courses.

https://www.nsf.gov/awardsearch/showAward?AWD_ID=1922898

Women of Color in Tech

https://www.nsf.gov/awardsearch/showAward?AWD_ID=1923245

Workshop – BP in STEM, Computer Science and Engineering through improved Financial Literacy

https://www.nsf.gov/awardsearch/showAward?AWD_ID=1939739

 

September 19, 2019 at 7:00 am Leave a comment

What’s generally good for you vs what meets a need: Balancing explicit instruction vs problem/project-based learning in computer science classes

Lauren Margulieux has posted another of her exceptionally interesting journal article summaries (see post here). Her post summarizes recent article asking which is more effective: Direct instruction or learning through problem-solving-first (like in project-based learning or problem-based learning — or just about any introductory computer science course in any school anywhere)? Direct instruction won by a wide margin.

Lauren points out that there are lots of conditions when problem-solving-first might make sense. In more advanced classes where students have lots of expertise, we should use a different teaching strategy than what we use in introductory classes. When the subject matter isn’t cognitively complex (e.g., memorizing vocabulary words), there is advantages to having the students try to figure it out themselves first. Neither of these conditions are true for introductory computer science.

This is an on-going discussion in computing education. Felienne Hermans had a keynote at the 2019 RStudio Conference where she made an argument for explicit direct instruction (see link here). I made an argument for direct instruction in Blog@CACM last November (see post here). Back in 2017, I recommended balancing direct instruction and projects (see post here), because projects are clearly more motivating and authentic for computer science students, while the literature suggest that direct instruction leads to better learning — even of problem-solving skills.

Lately, I’ve been thinking about this question with a health metaphor. Let me try it here:

Everybody should exercise, right? Exercise provides a wide variety of benefits (listed in a fascinating blog post from Freakonomics from this June), including cardiovascular improvements, better aging, better sleep, and less stress. But if you have a heart problem, you’re going to get treatment for that, right? If you’re having high cholesterol, you should continue to exercise (or even increase it), but you might also be prescribed a statin.  If you have a specific need (like a vitamin deficiency), you address that need.

Students in computing should work on projects. It’s authentic, it’s motivating, and there are likely a wide range of benefits. But if you want to gain specific skills, e.g., you want to achieve learning objectives, teach those directly. Don’t just assign a big project and hope that they learn the right things there. If you want to see specific improvement in specific areas, teach those. So sure, assign projects — but in balance. Meet the students’ needs AND give them opportunities to practice project skills.

And when you teach explicitly: Always, ALWAYS, ALWAYS use active learning techniques like peer instruction. It’s simply unethical to lecture without active learning.

September 16, 2019 at 7:00 am 3 comments

Come talk about the Role of Authentic STEM Learning Experiences in Developing Interest and Competencies for Technology and Computing #STEMforCompTech

I’m on a National Academies committee to write a report about the role of authentic STEM learning experiences in promoting interest and ability in computing.  We’re having an open meeting/workshop (I don’t really know what it’s about yet) in November in DC. Visit this link for more information.

Save_The_Date__November_4th_Workshop- Role_of_Authentic_STEM_Learning_Experiences_in_Developing_Interest_and_Competencies_for_Technology_and_Computing

September 13, 2019 at 10:00 am Leave a comment

Where a Notional Machine Doesn’t Help: JavaScript and the DOM

At the Dagstuhl Seminar on Notional Machines and Programming Language Semantics, I came to a new understanding about where notional machines are not useful and another kind of support is needed.

I joined a breakout group on “Notional Machines for everything else.” There had been discussions about notional machines for popular programming languages for Scratch and Python, and one breakout group was formed around that goal. This group was about exploring where else notional machines could be useful, like trying to understand machine learning, generating proofs, and JavaScript for Web development. Joe Politz was our group leader.

After the first round of discussion, we all decided to focus on JavaScript. We had some serious experts on JavaScript and the DOM in our group, like Shriram Krishnamurthi and Titus Barik. The discussion was amazing! I was learning so much, and I took pages and pages of notes. Everyone noticed my feverish note-taking, so I got elected to report back to the group. That’s this blog post — it’s the work of the whole group (not just me). I just happened to be the guy who made the slides.

We had already come to the realization that there isn’t just one notional machine per language. A notional machine is about helping students understand a computational process, and there can be lots of processes in a given language. So we picked a specific scenario that we were aiming to explain: You (as a student) want to turn the background yellow when the button is clicked.

But the student makes a mistake.

And I came to realize that, without a lot of support:

The problem is that window.bg = "yellow" isn’t wrong. Because there isn’t a previously defined bg property, this assignment simply creates a property bg for the window object. No error. It just doesn’t do what the students wanted. How does the student figure out that the desired property is backgroundColor? Get a list of all bindings on window? There are hundreds or even thousands of them. How do you find backgroundColor among all of those?

The breakout group started listing on the blackboard the things we might need to explain to students to help them understand when went wrong or what might go wrong with clicking on a button to turn the background yellow. It was a long list.

You probably can’t read all of those, so I’ll list a few of them here:

  • What happens if you have two DOM elements with the same ID?
  • Where did window as an object get defined at all?
  • If you have event handlers defined on an object, and you delete the object, what happens to the event handler?
  • What happens if objects higher up in the DOM modify the event triggered by the event click?
  • Something I heard students ask: If my JavaScript changed the DOM, how come my HTML file didn’t change?
  • And Many More

I really had no idea just how complicated JavaScript and the DOM were! Amy Ko looked up the JavaScript definition of what == means (see link here). This isn’t the formal semantics. This is meant to be understandable. It’s insanely complicated.

At this point, Ben Shapiro raised a really interesting side question: What’s the cost of JavaScript’s overly-complicated rules? Is there a way of measuring the lost productivity of bad programming language design?

So, what’s the answer?

I realized that the answer is not a notional machine. The problem is that long list Amy found for us. I can teach part of that list as a notional machine, but I can’t teach all of it with a simplified model. Any simplification I create would be insufficient for the complexity of the reality. And even having a notional machine wouldn’t help if a student typed window.bg = "yellow". The student needs IDE’s and other supports to figure out errors that never trigger an error.

The solution is to reduce complexity to make it teachable.  In an earlier talk at Dagstuhl, Ben Shapiro explained how Shriram and Joe and their collaborators did this with Pyret.  In Pyret, they explicitly disallow some things that Python allows but are way too complicated to explain.

Probably the best idea for JavaScript, following Racket’s lead, is to have language levels. We should teach students a strict subset of JavaScript, where the really complicated things are simply disallowed. The goal is to help students to learn a real subset, then grow the subset.  TypeScript offers an alternative model, because it offers a more sane way of doing JavaScript.  For example, TypeScript’s type checking might help figure out the window.bg bug. There are lots of other languages that are more reasonable and compile to JavaScript — but those are avoiding JavaScript entirely.

The very best idea would be to fix JavaScript and the DOM, but it’s probably too late for that.

This working group was useful to me for two reasons. First, I really do have to teach JavaScript and the DOM (again) in January 2020, and now I have a new sense of the challenges and my options. Second, this was a great example of where a notional machine is not the answer to a pedagogical problem.

Thanks to members of the group who reviewed an earlier draft of this summary.  They’re not responsible for where I still didn’t get the details right.

 

September 9, 2019 at 7:55 am 13 comments

How the Cheesecake Factory is like Healthcare and CS Education

Stephen Dubner of the Freakonomics Podcast did an interview with Atul Gawande, author of the Checklist Manifesto. Atul is a proponent of a methodical process — from a behavioral economist perspective, not from an optimization perspective. People make mistakes, and if we’re methodical (like the use of checklists), we’re less likely to make those mistakes. If we can turn our process into a “recipe,” then we will make fewer mistakes and have more reliable results. Here’s a segment of the interview where he argues for that process in healthcare.

DUBNER: Okay, what’s the difference between a typical healthcare system and say, a restaurant chain like the Cheesecake Factory?

GAWANDE: You’re referring to the article I wrote about the Cheesecake Factory…Basically what I was talking about was the idea that, here’s this restaurant chain. And yes, it’s highly caloric, but the Cheesecake Factorys here have as much business as a medium-sized hospital — $100 million in business a year. And they would cook to order every meal people had. And in order to make that happen, they have to run a whole process that they have real cooks, but then they have managers.

I was talking to one of the managers there about how he would make healthcare work. And his answer was, “Here’s what I would do, but of course you guys do this. I would look to see what the best people are doing. I would find a way to turn that into a recipe, make sure everybody else is doing it, and then see how far we improve and try learning again from that.” He said, “You do that, right?” And we don’t. We don’t do that.

Here’s where Gawande’s approach ties to education. Later in the interview:

DUBNER: And do you ever in the middle of, let’s say, a surgery think about, “Oh, here’s what I will be writing about this day?”

GAWANDE: You know, I don’t really; I’m in the flow. One of the things that I love about surgery is: it is, I have to confess, the least stressful thing I do, because at this point I’ve done thousands of the operations I do. Ninety-seven to 98 percent go pretty much as expected, and the 2 percent that don’t, I know the 10 different ways that are most common that they’ll go wrong and I have approaches to it. So it’s kind of freeing in a certain way.

I think about teaching like this. I have been teaching computing since 1980. I actively seek out new teaching methods. Teaching CS is fun for me — because I know lots of ways to do it, I have choices which keeps it interesting. I have mentioned the fascinating work on measuring teacher PCK (Pedagogical Content Knowledge) by checking how accurately teachers can predict how students will get exam questions wrong. I know lots of ways students can get computer science wrong. I still get surprises, but because I’m familiar with how students can get things wrong, I have a starting place for supporting students in constructing stronger conceptions.

We can teach this. The model of expertise that Gawande describes is achievable for CS teachers. We can teach new CS teachers methods that they can choose from. We can teach them common student mental models of programming, how to diagnose weaker understandings, and ways to help them improve their mental models. We can make a checklist of what a CS teacher needs to know and be able to do.

September 2, 2019 at 7:00 am 8 comments

Holding ourselves to a higher standard: “Language-independent” just doesn’t cut it

My CACM blog post this month (see link here) is a retraction of the term “language-independent” in our work on the FCS1 and SCS1:

There is no language independence here. The FCS1 and SCS1 are multi-lingual which is a remarkable achievement. We might also call them pseudcode-based assessments, which is how they can be multi-lingual, but since a pseudocode-based test isn’t necessarily validated across other languages, “multi-lingual” is a stronger claim than “pseudocode-based.” We do not cover all of any of those languages (Java, MATLAB, or Python), but we do cover the subset most often appearing in an introductory CS course.

They are clearly not language independent. In the great design space of programming languages, Java, MATLAB, and Python cluster together pretty closely. There are much more different programming languages than these — I’m sure it’ll take any reader here just a few moments to generate a half-dozen candidates whose learners would score poorly on the FCS1 and SCS1, from Scratch to Haskell to Prolog.

I only vaguely remember the discussion about using the term “language independence” with Allison many years ago.  I remember her asking me if we should worry about the (relatively few) classes that used languages other than Python, MATLAB, and Java.  I think I told her she needed to graduate. I judged from the perspective of what was being published at the SIGCSE Symposium — Python, MATLAB, and Java was “language independent” enough for the paper to be seen as valuable to SIGCSE reviewers. I don’t remember the details, but I’ll accept the blame for the decision to call FCS1 (and SCS1 later) language independent.

That was a long time ago, before the International Computing Education Research Conference (ICER) was invented.  Since then, we have a computing education research community that aims to answer questions about how people learn computing — period. We’re not just about undergraduate introductory computer science classes. Even at the undergraduate level, we should study the classes (no matter how few) doing something different to see what’s powerful and interesting about them. We should explicitly be exploring unusual (even purpose-invented) languages to understand more of the interaction between programming languages and human cognition.  An insightful PPIG paper from Clayton Lewis (see link here) was recently circulated on Twitter (see tweet) that makes great points about the complexity of measuring that interaction:

The PPIG community should be proud that cognitive dimensions analysis emerged from the work of people in its ranks, Thomas Green, Marian Petre, Alan Blackwell, and others. We should be skeptical of calls to replace its use with A-B trials or other quantitative methods that cannot cope with the complexity of the language design landscape. When results of A-B trials and similar studies are presented, we should diplomatically ask for the mechanisms that are involved to be described. Colleagues who present the results of such trials should be prepared to respond to this request, so that the generalizability of their results can be assessed.

We should not be driven by what’s in classrooms today (see previous post making that argument). We should hold ourselves to a higher standard. Our goal is to create a lasting record of exploration and research for a research community.

That’s why it’s past time for this retraction.

 

August 26, 2019 at 7:00 am Leave a comment

Summarizing findings about block-based programming in computing education

As readers of my blog know, I’m interested in alternative modalities and representations for programming. I’m an avid follower of David Weintrop’s work, especially the work comparing blocks and text for programming (e.g., as discussed in this blog post).

David wrote a piece for CACM summarizing some of his studies on block-based programming in computing education. It has just been published in the August issue.  Here’s the link to the piece — I recommend it.

To understand how learners make sense of the block-based modality and understand the scaffolds that novice programmers find useful, I conducted a series of studies in high-school computer science classrooms. As part of this work, I observed novices writing programs in block-based tools and interviewed them about the experience. Through these interviews and a series of surveys, a picture emerged of what the learners themselves identified as being useful about the block-based approach to programming. Students cited features discussed here such as the shape and visual layout of blocks, the ability to browse available commands, and the ease of the drag-and-drop composition interaction. They also cited the language of the blocks themselves, with one student saying “Java is not in English it’s in Java language, and the blocks are in English, it’s easier to understand.” I also surveyed students after working in both block-based and text-based programming environment and they overwhelmingly reported block-based tools as being easier. These findings show that students themselves see block-based tools as useful and shed light as to why this is the case.

August 19, 2019 at 7:00 am Leave a comment

Older Posts Newer Posts


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

Join 7,062 other followers

Feeds

Recent Posts

Blog Stats

  • 1,690,979 hits
October 2019
M T W T F S S
« Sep    
 123456
78910111213
14151617181920
21222324252627
28293031  

CS Teaching Tips