Archive for April, 2019

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

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

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

David says:

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

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

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

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

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

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

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

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

The tension between HCI and Computational Thinking

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

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

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

A New Definition for Computational Thinking

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

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

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

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

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

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

 

April 29, 2019 at 7:00 am 11 comments

Congratulations to Chris Stephenson, Outstanding Contribution to ACM Awardee 2018

A well-deserved honor!  Chris has done so much for computing education, from CSTA to her great work at Google. Congratulations!

stephenson_5836051

CITATION

For advancing K-12 CS education by founding and developing the Computer Science Teachers Association and incorporating its mission and membership into the ACM professional community.

Dr. Chris Stephenson has expanded the definition of the professional computing community to include K-12 computer science (CS) teachers and education partners, supporting ACM’s mission to increase the diversity and perspectives of the community. Chris’s work in architecting, founding and nurturing the Computer Science Teachers Association (CSTA) in partnership with ACM into a professional international organization with more than 22,000 members dedicated to supporting teachers and pursuing excellence in K-12 CS education is widely recognized. Her scholarly research contributions, including work on computational thinking in K-12 education, the inaugural CSTA K-12 Computer Science Standards and the Running on Empty and Bugs in the System reports, have led to projects, initiatives and policy changes that have deeply and positively impacted K-12 education and educators globally.

 

From this web page.

 

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

What we want kids to learn through coding: Requirements for task-specific programming languages for learning

Marina Umaschi Bers has an essay from last year that I’ve been thinking about more since the discussion about task-specific programming languages (see previous post here). Her essay is: What Kids Can Learn Through Coding.

In creating her ScratchJr kitten, Liana practiced some of the most powerful ideas of computer sciences:

  • She learned that a programing language has a set of rules in which symbols represent actions.
  • She understood that her choices had an impact on what was happening on the screen.
  • She was able to create a sequence of programming blocks to represent a complex behavior (such as appearing and disappearing).
  • She used logic to correctly order the blocks in a sequence.
  • She practiced and applied the concept of patterns, which she had learned earlier during math time in class.

ScratchJr is just what the name suggests — a programming language like Scratch, but made even simpler and aimed at young children.  See a description of activities with ScratchJr here.

What I particularly like about Marina’s list is how it connects to the learning trajectories work that I’ve been talking about here and highlighted in my 2019 SIGCSE Keynote (as described in Ann Leftwich’s tweet). Ideas like “Precision and completeness are important when instructions in advance” are hard to learn. Knowing that the computer requires precision and isn’t trying to understand you like a human is really the first step to getting past Roy Pea’s “Superbug.” These are important ideas to learn. I’ll bet that most students don’t have that insight (even when they get to undergraduate education). That would be an interesting research question — what percentage of University students know ideas like the importance of precision and completeness in computer instructions?

I have a hypothesis that these fundamental ideas (what Marina is pointing out, what Katie Rich et al. are noting in their learning trajectories) even transfer. These aren’t higher-order thinking skills. This isn’t about learning a programming language to be used across the curriculum. Rather, these concepts are about recognizing, “The nature of programming.” I bet that students will learn these and remember them in new contexts, because it’s about what the computer and programming is. Once you learn that computer instructions require precision and completeness, I predict that you always remember that programming has that requirement.

What else do we want students to get from coding?

Please note that I’m not talking about “computational thinking.” I’m setting aside the possibility of more general “mindset” benefits.  Right now, I’m thinking in pragmatic and measurable terms.  We can measure students learning the concepts in the trajectories.  We can measure if those concepts are retained and applied later.

This is why task-specific programming languages are interesting to me. The goal isn’t “learning programming” (and I’ll argue in a few weeks that that isn’t a thing). The goal is using code to improve learning about something other than programming skills. Notice the term that Marina uses in her essay: “the most powerful ideas of computer sciences.” She’s not teaching students how to program. She is teaching them what programming is.

A task-specific programming language used in an educational context should improve learning in that context. It should provide some leverage that wasn’t there previously (i.e., without the computer).

  • For the social studies educators with whom I am working, programming allowed them to build visualizations to highlight the features that they wanted to highlight, from large data sets. They found it easier to get the visualization they wanted via code than via Excel (or so they told us). The programming managed scale (e.g., if you had three data points, you could graph them by hand pretty easily).
  • The programming language can find mistakes that the student might not notice, and provide feedback. That’s how I’m trying to use programming in a history class. A program can represent an argument. A computer can find gaps and weaknesses in an argument that a student might not see.
  • The Bootstrap folks argue for the value of rigor. I think they’re referring to the specificity that a program requires. Writing a program requires students to specify a problem and a solution in detail, and can lead to greater insight.
  • A program can make something “real.” Bootstrap: Algebra works, in part, because the students’ algebra makes a video game. It breathes life into the mathematics. That a program executes is a powerful motivator.

I think what Alan was telling me in the comments to an earlier blog post about task-specific programming and again in the blog post on multiple languages in schools is that it should also lead to generativity. If I teach you a programming language that solves your task and doesn’t connect to more powerful ideas and languages, then I have taught you a dead-end solution. I might achieve the goals I’ve identified earlier, but I’m not helping you to solve the next problems or the problems you’re going to face next year or next class. I’m not sure right now how to achieve that goal, but I recognize the value of it.

What are other requirements for the use of task-specific languages for learners?

April 22, 2019 at 7:00 am 2 comments

A Task-Specific Programming Language for Web Scraping in which learners are successful very quickly

One of the papers that has most influenced my thinking about task-specific programming languages is Rousillon: Scraping Distributed Hierarchical Web Data by Sarah Chasins, Maria Mueller, and Rastislav Bodik.

Rousillon is a programming by demonstration system that generates a program in Helena, a task-specific programming language for Web scraping (grabbing data out of Web pages). Below is a flow diagram describing how Rousillon generates a program in Helena.

Check out the Helena program at the far right of that diagram. Yeah, it’s a block-based programming language — for adults. The choice of blocks was made explicitly to avoid syntax errors. If the user wants to modify the synthesized code, she is guided to what can be changed — change a slot in a block, or delete or move a block.  It’s a purposeful choice to improve the user experience of programming with Helena.

Helena doesn’t do statistics. It doesn’t do visualizations. It does one thing extremely well.  Maybe it’s competition for R, because people do use R for Web scraping.  But it’s far easier to do web-scraping in Helena.

The below graph is the one that blew me away. They ran a study comparing Rousillon and Selenium, a comparable Web data scraping system. Everybody using Rousillon completed both tasks in a few minutes. Most people using Selenium couldn’t finish the tasks (if the bar goes all the way up to the top, people ran out of time before completing).

But here’s the part that is just astonishing. Notice the black border on some of the Selenium bars in that graph? Those are the people who knew Selenium already. NONE of the Rousillon users knew the language before hand. That time for the Rousillon users includes training — and they still beat out the Selenium users.  A task that a trained Selenium user can solve in 25 minutes, a complete novice can solve with Rousillon and Helena in 10 minutes.

Here’s a goal for task-specific programming languages for adult end-users: It should be easily learned. End-users want to be able to succeed at simple tasks nearly immediately. They want to achieve their task, and any time spent learning is time away from completing the task. It’s about reducing the costs of integrating programming into the adult’s context.

The goal isn’t exactly the same when we’re talking about learners in non-CS classes. I think it’s about balancing two challenges:

  • If the learning is generative and will be used again, then some additional learning is valuable. For example, learning about vectors in MATLAB and lists in Racket make sense — you’ll use them whenever you will use either language. It’s a concept that can be applied whenever you use those languages. (I have a blog post that talks about generativity and other goals for task-specific programming languages next week.)
  • But we don’t want to turn algebra, history, or economics classes into CS classes. We don’t want to make mathematics or social studies teachers feel like like they’re now teaching CS. When is it too much CS that you’re teaching?  Perhaps a rule of thumb is when the teacher is teaching more than they could learn in a single professional development session. That’s just a guess.

April 15, 2019 at 7:00 am 3 comments

European Best Practices in Education Award: Focus on Inclusive Education

I know several members of the awards committee this year, and was asked to share this broadly.

Best Practices in Education Award

2019 Edition
‘Inclusive Education’

Presented by Informatics Europe
Sponsored by Microsoft

Call for Submissions Now Open
***********************************************************************

Informatics Europe proudly announces its 2019 Best Practices in Education Award devoted to initiatives targeting Inclusive Education of different student groups such as the elderly, immigrants or people with functional diversity.

The Informatics Europe Best Practices in Education Award recognizes outstanding European educational initiatives that improve the quality of Informatics teaching and the attractiveness of the discipline, and can be applied and extended beyond their institutions of origin.

The Award rewards a successful teaching effort in Europe that:

  • has made a measurable difference in informatics education;
  • is widely applicable and useful for the teaching community;
  • has made a measurable impact in its original institution and beyond.

Examples of impact include course results, e-accessibility frameworks and techniques, such as guidelines or frameworks based on robotics; traditional and online courses, learners’ projects, textbooks, professional development, and influence on the curriculum of other institutions/countries. The initiatives are not limited to programming but include design and use of technology.

The 2019 Award is devoted to outstanding European educational innovations that address Inclusion in Informatics teaching in the classroom or beyond, at school or university level, or outside of institutions. Innovation maybe technology-based (for example using instructional technologies, MOOCs, learning analytics, etc.) or pedagogical. The Award honours original contributions that focus on innovative Informatics teaching practice toward Inclusion.

Experiences and reports showing how to use software or hardware tools in order to improve inclusion and learning in other disciplines than informatics will not be considered.

The Award is sponsored by Microsoft and carries a prize of EUR 5,000.

Submissions:

The Award can be given to an individual or to a group. To be eligible, participants must be located in one of the member or candidate member countries of the Council of Europe (www.coe.int), or Israel. Members of the Informatics Europe Education Working Group and of the Award Committee are not eligible.
The Award Committee will review and evaluate each proposal. It reserves the right to split the prize between at most two different proposals (individuals or teams).

Proposals should be submitted only at:

https://easychair.org/conferences/?conf=iebpea2019

The proposal should include:

  • Names and addresses of the applicant or applicants;
  • Indication of whether the submission is on behalf of an individual or a group;
  • Description of the achievements (max 5 pages);
  • Evidence of availability of the outcomes of the initiative to the teaching community (max 2 pages);
  • Evidence of impact (max 5 pages);
  • A reference list (which may include URLs of supporting material);
  • One or two letters of support. The letters of support may come for example from school or university management, associations, or colleagues in the same or another institution.

Deadlines:

  • Proposal: June 1, 2019
  • Notification of winner(s): August 1, 2019

The Award will be presented at the 15th European Computer Science Summit, in Rome, October 28-30, 2019, where a representative of the winning institution will be invited to give a talk on their achievements.

Award Committee:

  • Letizia Jaccheri, Norwegian University of Science and Technology, Norway (Chair)
  • Michal Armoni, Weizmann Institute of Science, Israel
  • Tone Bratteteig, University of Oslo, Norway
  • Sharon Lynn Chu, University of Florida, US
  • Michael Kölling, King’s College London, UK
  • Monica Landoni, Università della Svizzera italiana, Switzerland
  • Gabriela Marcu, University of Michigan, US
  • Jan Vahrenhold, University of Münster, Germany

Further inquiries:

education-award@informatics-europe.org

April 12, 2019 at 7:00 am 1 comment

Why we should explore more than one programming language across the curriculum

Ben duBoulay and I wrote the history chapter for the new Cambridge University Press Handbook of Computing Education Research (mentioned here).  A common theme has been the search for the “best language” to learn programming.  We see that from the 1960’s on up.

One of the criteria for “best language” is one that could be used across the curriculum, in different classes and for different problems.  I was reminded of that when we recently ran a participatory design session with social science teachers.  We heard the message that they want the same language to use in history, English, mathematics, and science. The closest we ever got was Logo.

But now, I’m not sure that that’s the right goal, for two reasons:

  1. We have no evidence currently that language-specific programming knowledge will transfer, nor how to achieve it.  If you use one language to learn algebra (e.g., Bootstrap Algebra), do students use or even reference the language when they get to (say) science class?  Maybe we could design a language with algebra-specific representations and biology-specific representations and history-specific representations and so on, but it might make the language unnecessarily complex and abstract to make it cover a range of domain constructs.  My bet is that the fundamental computational ideas do transfer.  If you learn that the order of language elements matters and the specificity of those language elements matter (two early learning goals as described in the learning trajectories work), I’ll bet that you’ll use those later. Those aren’t about the programming language. Those are about programming and the nature of programs.
  2. School is so much more diverse and heterogeneous than adult life. I’ll bet that most of you reading took physics and biology at some point in our lives.  I don’t know about you, but I rarely use F=ma or the difference between mitosis and meiosis in daily life.  On a daily basis, we tend to solve problems within a small range of domains. But our students do take science and math and history and English all in the same day.  In adult life, there are different programming languages for different kinds of problems and different domains (as Philip Guo has been talking about in his talks recently). Why shouldn’t that be true for K-12, too?

The key is to make the languages simple enough that there’s little overhead in learning them. As one of the teachers in our study put it, “one step up from Excel.” Scratch fits that goal in terms of usability, but I don’t think it’s a one-size-fits-all solution to computing across the curriculum.  It doesn’t meet the needs of all tasks and domains in the school curriculum. Rather, we should explore some multi-lingual solutions, with some task-specific programming languages, and think hard about creating transfer between them.

The single language solution makes sense if the language is hard to learn. You don’t want to pay that effort more than once. But if the language fits the domain and task, learning time can be minimal — and if well-designed, the part that you have to learn transfers to other languages.

 

April 8, 2019 at 7:00 am 21 comments

Opportunities to explore research questions with Code.org: Guest post from Baker Franke

I wrote my Blog@CACM column this month as a response to the 60 Minutes segment on Code.org with Hadi Partovi, “Five Research Questions Raised by a Pre-Mortem on the 60 Minutes Segment on Code.org.” Baker Franke, research and evaluation manager at Code.org (see Felienne’s blog post about Baker here) responded on Facebook with an invitation to engage with Code.org on these (and other) research questions.  He provided me with a longer form of his Facebook post, which I’m sharing here with his permission. Thanks, Baker!

Hi Mark,
These are all of course great questions and ones we really hope the community takes up. Some are things we’re actively tracking or working on with other research partners. So, some questions are actually more at the mid-mortem stage 🙂 or at least we can see trends. If you’d like me to share something I’m more than happy to.
But for anyone out there who would like to dig in a little bit more please consider becoming a research partner. I recently gave a flash talk at the SPLICE workshop at SIGCSE ‘19 about how we do research partnerships. Here is a working document about Research Partnerships at Code.org. It explains with a bit more detail how we work with researchers and the kinds of data we do and don’t have. If you have ideas for killer research projects that make use of our platform let us (read: me) know.

To offer a little something, I’ll take the bait on Mark’s first hypothesis: “Students with Code.org accounts don’t actually use the Code.org resources.” Answer: depends how you count! Actually it’s more like: depends where you want to draw the line on a full spectrum of activity we can log. We do try to track the difference between just visiting the site, logging in, doing an activity, starting a course with a teacher, and doing more. (Of course nothing would replace a well-designed implementation study, did I mention our research partnership program?)

For example, in CS Fundamentals (K5), we’ve been looking at students who “start” the course (defined in next paragraph) v. those who reach a basic level of “coding proficiency,” but understanding and defining this is tricky and is an ongoing project (click this link to learn more about how we define it)Mark_Guzdial_Guest_Blog_Post_-_Google_DocsWe also track what we call “course started” v. “fully enrolled”. “Course started” is defined as a student user who (1) completes any single activity within one of our full courses (i.e. CSF, CSD, CSP, but not hour of code) and (2) who is in a teacher-section with 5 or more other students. Some exploratory analysis has shown that >= 5 students filters out a lot of noise that is probably not school-related activity. “Fully enrolled” is a metric that we’re also continuing to refine, and is a bit of misnomer because we can’t actually see what course the student is enrolled in at their school, but it means something like: “system activity data is indicative of this person probably actually going through the course in a classroom with a teacher.” We calculate it based on a student account (1) being in a section of >= 5 students (2) reaching a threshold of activity within each unit of the course — different thresholds for each unit depending on size, amount of unplugged, etc. — (3) over all units in the course. I think the important thing to highlight about these metrics is that they’re focused on activity indicative of students in classrooms, not just any old activity. Here are the numbers for the most recently completed school year.

Mark_Guzdial_Guest_Blog_Post_-_Google_Docs-v2

Right now, our definition for “fully enrolled” is admittedly rough, and we’re going to refine it based on what we’re seeing in actual classrooms and publish a definition later this year with better numbers, but these numbers give a high level idea of what we’re seeing.

So do students with Code.org accounts use the resources? Yeah, a lot do. It’s tempting to compare these numbers to, say, MOOC completion rates, but we’re not really a MOOC because our curricula aren’t actually online courses. It would be hard for a student to go through our courses without a teacher and a classroom of schoolmates. The difference between “started” and “fully enrolled” could be a teacher only using one unit of a course or a few activities. So where’s the line? Another way to slice this would be to look at started v. completed for students of teachers who went through our PD program. Wouldn’t that be interesting? Want to find out more? Did I mention our Research Partnership Program?

Baker
baker@code.org

April 5, 2019 at 7:00 am Leave a comment

Older Posts


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

Join 6,246 other followers

Feeds

Recent Posts

Blog Stats

  • 1,655,074 hits
April 2019
M T W T F S S
« Mar   May »
1234567
891011121314
15161718192021
22232425262728
2930  

CS Teaching Tips