How to Teach Computational Literacy/Thinking: Wolfram’s Language and’s Response

October 31, 2016 at 7:18 am 9 comments

Stephen Wolfram has published an essay arguing for a programming language as key to teaching computational literacy. He says computational thinking — I think he means the same thing as I do with CL instead of CT. I agree with him, and made a similar argument in my book. He goes on to argue that Wolfram Language (and the Mathematica infrastructure behind it) is particularly good for this.

But how does one “tell a computer” anything? One has to have a language. And the great thing is that today with the Wolfram Language we’re in a position to communicate very directly with computers about things we think about. The Wolfram Language is knowledge based: it knows about things in the world—like cities, or species, or songs, or photos we take—and it knows how to compute with them. And as soon as we have an idea that we can formulate computationally, the point is that the language lets us express it, and then—thanks to 30 years of technology development—lets us as automatically as possible actually execute the idea. The Wolfram Language is a programming language. So when you write in it, you’re doing programming. But it’s a new kind of programming. It’s programming in which one’s as directly as possible expressing computational thinking—rather than just telling the computer step-by-step what low-level operations it should do. It’s programming where humans—including kids—provide the ideas, then it’s up to the computer and the Wolfram Language to handle the details of how they get executed. Programming—and programming education—have traditionally been about telling a computer at a low level what to do. But thanks to all the technology we’ve built in the Wolfram Language, one doesn’t have to do that any more. One can express things at a much higher level—so one can concentrate on computational thinking, not mere programming. Yes, there’s certainly a need for some number of software engineers in the world who can write low-level programs in languages like C++ or Java or JavaScript—and can handle the details of loops and declarations. But that number is tiny compared to the number of people who need to be able to think computationally.

Source: How to Teach Computational Thinking—Stephen Wolfram Blog

He may be right. I don’t know of any studies of the Wolfram Language in any setting. The idea of providing a programming language with such rich knowledge behind it is intriguing and promising — so much there for just about any kind of inquiry, for any kind of context.

Hadi Partovi, CEO of, wrote an essay in response, where he similarly agreed with Wolfram on the issues of what we’re trying to teach and the importance of a programming language to teach those concepts. I disagree with Hadi on his critique of Wolfram, which is that the Wolfram Language is functional and lacks loops and declarations, and is inappropriate for use with learners. It’s totally true that most professional software engineers use procedural programming. But that doesn’t mean we have to. 

If we’re teaching computational literacy or computational thinking, it’s not clear why the practices of professional software engineers should influence what we teach or how we teach it. That’s not what we are teaching. I argue that we need to take a learner-centered approach, where we recognize that learners are not professionals or experts, and particularly in computing, may not want to become professional software engineers.
What gets used in daily practice by professionals is the result of historical and cultural factors that in no way imply that we made choices optimized what is best for learners. Fortran won over Lisp because (in part) we didn’t know how to compile Lisp efficiently, but we do now and we know how to teach Lisp well. C++ and then Java won over Pascal because of perceptions of what industry wanted, not because of data and not because Pascal was shown to be ineffective for learners. What we know about what is “natural” for learners when they are first thinking about programming strongly implies that Wolfram’s functional structures are easier for learners than loops and declarations. We should strive to make decisions for what we use in classrooms based on evidence, not on what is professional practice, nor what we decide based on social defense mechanisms.

More importantly, there is no “best” platform for teaching computer science. As a functional programming language, the Wolfram Language is fantastic for data analysis and exploration, but it can’t be used to create a traditional “app.” Most professional software engineers use procedural programming, using exactly the same concepts that Wolfram criticizes: loops, conditionals, event-handlers, and such. Without these concepts, none of today’s software would function. The debate about which is better—functional vs procedural programming—has raged for decades without an answer.

Source: The Keys to a Well Rounded Computer Science Education | EdSurge News

Entry filed under: Uncategorized. Tags: , , , .

ECEP and White House Symposium on State Implementation of CS for All What research will you do for #CSforAll? White House call for commitments

9 Comments Add your own

  • 1. rademi  |  October 31, 2016 at 9:27 am

    I think the distinction between “functional” and “procedural” programming is overpopularized, and – as such – has gotten to the point where it can be misdirecting.

    The “real” issue here, in my mind, has to do with how computer instructions get translated to the physical (or at least electronic) level of abstraction.

    And, for that, I imagine that history is a good guide. The things which were worked out earlier tend to be easier for students to put into action.

    But I would argue that the insights which come from seeing how one interfaces between these different levels of abstraction are crucial for academic rigor.

    That said, a much bigger issue has to do with hooking computing devices up to sensors and driving external devices. This turns out to be incredibly frustrating in the “microsoft world”, because the abstractions are not suitable for dealing with timing.

    And that, I’m afraid, is what the “functional”/”procedural” battle distracts from. Physics, music, engineering, etc. are all academic disciplines which could benefit from abstractions which help the user build computerized timing systems. And there’s massive amounts of theory here.

    But literally every major programming environment is at best awkward for this kind of thing. The cultural emphasis seems to be on micro-optimizations rather than on useful results.

    There are significant exceptions, of course. But as a trend, this is worrying.

  • 2. Ashok Bakthavathsalam  |  November 1, 2016 at 5:56 am

    Is the Wolfram Language open source? Or does it even matter?

  • 3. gasstationwithoutpumps  |  November 1, 2016 at 11:06 am

    Students learn to program either because they are forced to (the CS for All approach), or because they want to be able to do something that computers will enable them to do. Whether a particular programming language or paradigm is appropriate for them depends on what it is that they want to do.

    For some, game development is a driving motivation (don’t look to Wolfram language for that). For others being able to build and control physical devices (robots, for example) is a motivation. Don’t look to Wolfram language for that). For some, analyzing and visualizing big data sets is a motivation (Wolfram language may help there).

    I don’t think we do learners a service when we assume that there is “one best way” to teach them. They have different goals and there are different paths to those goals.

    • 4. Mark Guzdial  |  November 1, 2016 at 11:12 am

      Strongly agreed! If a student wants to become part of the software engineering community of practice, then the Wolfram language is probably not the right choice. If you want to use computing to answer questions, Wolfram language might be great. Critiquing the Wolfram language because it doesn’t look like software engineering tools presumes why you’re learning programming.

      • 5. gasstationwithoutpumps  |  November 1, 2016 at 12:08 pm

        At the university level, students may know they want to “become part of the software engineering community of practice”, but I was thinking of younger students. Students who might want to write video games or program robotic toys, just because it is fun. I’m thinking more of hobbyist programmers in the Maker movement than of software engineers.

        There are some things that the Wolfram language enables that are valuable in a school context (I can see lots of use for examining census data, for example), but I don’t see a lot of things that many students will do on their own, just for fun. Of course, I don’t know much about the Wolfram language, so I may be missing the fun parts.

  • 6. joshg  |  November 1, 2016 at 11:28 am

    Uh, the no-loops critique isn’t even true. Wolfram Language has a For statement that works pretty much like you’d expect.

    For[i=0, i<10,i=i+1,

  • 7. paul muad'octopus (@OhMeadhbh)  |  November 1, 2016 at 1:11 pm

    I took this as more of a statement about the mental models programming helps you build. Sure, learning to code has the benefit of allowing you to build stuff (games, robots, etc.) but it also introduces people to the concept of interpreting the world according to an algorithm.

    When I was a kid, we learned Aristotelian logic, then yammered on about Kant for a while before finally diving into Russell, Hilbert and Gödel (I was on the logic track.) The argument was made that logic, philosophy, science and even literary criticism would give us the mental tools to interpret events in the world. And for the most part, I think that’s been a good thing.

    I look at teaching people to code from a similarly pedagogical perspective. Teaching people to code is a lot like teaching them to work out logic problems in that it gives a different set of mental models to hang abstract reasoning on. Perhaps most importantly, teaching people how to code puts students in an environment where they are likely to develop an intuitive understanding of the limits of software and of algorithms. (And how easy it is to mess up the implementation.)

    The difference between logic (as it was taught to me in my academic career) and coding is that coding has much more obvious, immediate applicability. And heck, you could even use Prolog to teach someone logic.

    So… to conclude… lemme say the benefit of teaching more people to code is a) they’re hopefully more likely to distinguish problems which can easily be solved with algorithms from them what can’t and b) they might learn a thing or two about how to craft programs to help them solve problems they encounter. From this perspective, things like the Wolfram tool stack (alpha, wolfram language, mathematica, etc.) is probably pretty decent… it exports abstractions you can use to quickly construct sample problems to introduce concepts that are physically significant or relateable from high school mathematics. You can *then* go on to frighten people with bits, bytes, floats, packed arrays of chars and data structures.

  • 8. paul muad'octopus (@OhMeadhbh)  |  November 1, 2016 at 1:15 pm

    also. check out inform 7’s language for building interactive fiction. it’s an interesting application of declarative programming.

  • 9. David Young  |  November 1, 2016 at 11:18 pm

    As a sophomore in high school in 1993, I was a 3D computer graphics enthusiast, and I used Wolfram’s Mathematica to find derivatives that I needed for the programs that I was writing for fun. I did not own a Mathematica license, so I could only use it on a handful of computers at school, or at a friend’s house.

    As a HS sophomore, I hadn’t studied calculus, yet. So when I did not have access to Mathematica, which was most of the time, the way that I found a derivative was “the limit as delta-x approaches zero of f of x plus delta-x …”. This is a rather tedious way to find the vector normal to a point on a bicubic Bezier surface, but I tried….

    Many of the languages of industry are hard to use in much the same way that the definition of a derivative is. They operate at the wrong level of abstraction for 99% of problems. Nevertheless, a lot of programmers reach for C and build a teetering tower of abstraction on it to reach the level of their problem, instead of starting from a weight-bearing level of abstraction and lowering themselves down. It has always seemed to me that Mathematica contained a lot of weight-bearing abstractions. It looks to me like a more reasonable place to start to teach programming than a procedural language of industry.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Trackback this post  |  Subscribe to the comments via RSS Feed

Recent Posts

October 2016
« Sep   Nov »


Blog Stats

  • 1,374,692 hits

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

Join 4,653 other followers

CS Teaching Tips

%d bloggers like this: