At hospitals, hand-washing is far less common than our knowledge of germ theory says it ought to be. What’s most surprising is that doctors, the ones with the most education in the hospital, are the least likely to wash their hands often enough. The podcast describes how one hospital was able to improve their hand-washing rates through other behavioral methods, like shaming those who didn’t wash their hands and providing evidence that their hands were likely to be filled with bacteria. More education doesn’t necessarily lead to behavioral change.

Much more important was the segment on financial illiteracy. First, they present the work of Annamuria Lusardia who has directly measured the amazing financial illiteracy in our country. There is evidence that much of the Great Recession was caused by poor financial decisions by individuals. Less than a third of the over-50-year-old Americans that Lusardia studied could correctly answer the question, “If you put $100 in a savings account with 2% annual interest, at the end of five years you will have (a) less than $102, (b) exactly $102, or (c) more than $102?” More mathematics background did lead to more success on her questions, but she calls for a much more concerted effort in financial education. Her arguments are supported by some pretty influential officials, like Fed Reserve Chair Ben Bernanke and former Secretary of the Treasury Paul O’Neill. It makes sense: If people lack knowledge, we should teach them.

Lauren Willis strongly disagrees, and she’s got the data to back up her argument. She has a 2008 paper with the shocking title, Against Financial Literacy Education that I highly recommend. She presents evidence that financial literacy education has not worked — not that it couldn’t work, but it isn’t working. She cited several studies that showed negative effects of financial education. For example, high school students who participated in the Jump$start program become much more confident about their ability to make financial decisions, and yet made worse decisions than those students who did not participate in the program.

The problem is that financial decisions are just too complicated, and education (especially universal education) is expensive to do well (though Willis doesn’t offer an estimated cost). Educational curricula (even if tested successful) is not always implemented well. The gap between education in teen years and making decisions in your 40’s and 50’s is huge. Instead of education, we should try to prevent damage from ignorance. Willis suggests that we should create a cadre professional of financial advisors and make them available to everyone (for some “pro bono”), and that we should increase regulation of financial markets so that there are fewer riskier investments for the general public. It costs the entire society enormously when large numbers of people make poor financial decisions, and it’s even more expensive to provide enough education to prevent the cost of all that ignorance.

This was a radical idea for me. Education is not free, and sometimes it’s cheaper to prevent the damage of ignorance than correcting the ignorance.

Implications for Computing Literacy Education

I share the vision of Andy DiSessa and others of computing as a kind of literacy, and a goal of “Computing for All” where everyone has the knowledge and facility to build programs (for modeling, simulations, data analyses, etc.) for their needs. Let’s call that a goal of “Universal Computing Literacy,” and we can consider the costs of using education to reach that goal, e.g., “Universal Computing Education to achieve Universal Computing Literacy.”

Computing may be even more complicated than finance. Willis talks about the myriad terms that people need to know to make good financial decisions (like “adjustable rate mortgages”), but they are at least compounds of English words! I attended a student talk this week, where terms like “D3” and “GreaseMonkey” were bandied about like they were common knowledge. We invent so much language all the time.

What could we possibly teach today in high school that will be useful in even five or ten years, when those students are in their careers, to be able to build something that they could use? “We’ll teach conceptual knowledge so that they can pick up any tools or languages they need.” We have no idea how to achieve this goal in computer science. It takes an enormous effort to develop transferable knowledge, and progress in computing changes the target task all the time. I have a PhD in Computer Science, and it takes me way too much effort to pick up JavaScript libraries that I might want to use — far more effort than a non-technical person will be willing to put in.

Universal education is always going to be expensive, and some things are worth it. Text illiteracy and innumeracy are very expensive for our society. We need to address those, and we’re not doing a great job at that yet. Computing education to achieve real literacy is just not as important.

Barb sees a benefit in Universal Computing Education, but not to achieve Universal Computing Literacy. We need to make computing education available everywhere for broadening participation in computing. To get computing into every school, Barb argues that we haveto make it requiredfor everyone. Without the requirement, schools won’t go to the effort of including it. Without a requirement, female and URM students who might not see themselves in computing, would never even give it a chance. In response to my argument about cost, she argues that the computing education for everyone doesn’t have to be effective. We don’t have to achieve lifelong literacy for everyone. Merely, it has to give everyone exposure, to give everyone the opportunity to discover a love for computing. Those that find that love will educate themselves and/or will pursue more educational opportunities later. I heard Mike Eisenberg give a talk once many years ago, where he said something that still sticks with me: that the point of school is to give everyone the opportunity to find out what they’re passionate about. For that reason, we have to give everyone the chance to discover computing, and requiring it may be the only way to reach that goal.

It’s always possible that we’ll figure out to educate more effectively at lower cost. For example, integrating computing literacy education into mathematics and science classes may be cheaper — students will be using it in context, teachers in STEM are better prepared to learn and teach computing, and we may improve mathematics and science teaching along the way. My argument about being too expensive is based on what we know now how to do. Economic arguments are often changed by improved science (see Malthus).

As Willis suggests for financial literacy, we in computing literacy are probably going to be more successful for less cost by focusing on the demand side of the equation. We need to make computing easier, and make tools and languages that are more accessible, as Alan Kay, Andy Ko, and the Racket folks are doing. We have to figure out how to change computing so that it’s possible to learn and use it over an entire career, without a PhD in Computer Science. We have to figure out how to get these tools into use so that students see use of such tools as authentic and not a “toy.”

“Computing for All” is an important goal. “Access to Computing Education for All” is critical. “Universal Computing Education to achieve Universal Computing Literacy” is likely to be ineffective and will be very expensive. On the other hand, requiring computing education may be the only way to broaden participation in computing.

Mark – I may be missing something… you wrote “that the point of school is not to give everyone the opportunity to find out what they’re passionate about. For that reason, we have to give everyone the chance to discover computing, and requiring it may be the only way to reach that goal.” It seems that to me to “give everyone the chance” is the same as “giving everyone the opportunity”, so isn’t Eisenberg’s quotation the exact opposite of your follow-up statement “for that reason…” Maybe it’s too late and I’m not thinking clearly. I am awake enough to full agree with your statement, but not Eisenberg’s at least the way it’s stated.

As a side note regarding how hard it is for even technical people to learn some new developments. My perception is that developers of tools for development seem to be making things harder rather than easier these days. More powerful and flexible perhaps but at a cost of making things harder to learn and to use. The exception being tools for real beginners (AppInventor, Alice, Scratch, etc). But this means that the gap between beginner tools and professional tools is getting larger and making the transition becomes much harder.

So I was frustrated initially reading this and found myself in disagreement, but then when you turned to Barb’s comments, I was nodding in complete agreement (you two balance each other nicely). Here are my thoughts: Right or wrong, I never truly looked at school (high school, college, etc.) as a time / place where I needed to learn everything. Rather, I learned how to learn, how to process, how to think. Later in life, resources (books, people, the internet) are readily available, but if I don’t possess the skills to find what I need, and reason about it critically, then that information is meaningless. So, we do need to expose all kids to computing not so they can all become perfectly computer literate, but so that they can learn to problem solve and think critically (something best learned in math and computer science classes) and have exposure to see if they want to pursue it further.

I disagree, Ann. Computing doesn’t teach most people to problem-solve nor think critically — we’ve got decades of evidence on this, since that claim was made for Logo. Computing can be used to teach people some problem-solving skills (as Sharon Carver showed), but in general, that doesn’t happen. I believe you that it worked for you in that way, but you’re not an average learner. The trick in this argument is thinking about “universal” — there’s a pretty big spread in “everyone.” I do agree that computing courses are important for people to get the chance to discover their beauty, joy, and awe in computing.

So I’m relying more on my experiences and what I’ve seen in students, but they are problem solving when programming. In fact, I feel that’s the point of beginning languages like Scratch and Alice – put together pre-made steps to accomplish a larger goal. While the kids may not see it as problem solving, that’s exactly what it is. Watch some middle school kids figure out what they want to do and then the steps needed to make it happen.

Right — that’s why the early Logo folks claimed what they did. Programming is clearly problem-solving. The problem is that the problem-solving in Logo (or any other programming language) doesn’t transfer elsewhere. Students don’t see debugging steps in a recipe or directions on a map as being at all the same as debugging a program (to use examples from some of the prior literature). Sure, it’s problem-solving, but if the problem-solving only gets used for programming, did they really learn problem-solving? If you can only use the knowledge in that classroom in that context, how much learning happened?

I am wondering if learning knowledge is different than learning a problem-solving skill. A student may not directly apply their knowledge of a programming language or system in another course, but the training that takes place in learning to program does train the brain to think about solving a problem in an algorithmic way and solve daily problems with that approach when needed. I am thinking that problem-solving requires a set of tools (like a tool box) and algorithmic problem-solving is one of those tools that should be there. I see computing education as providing this tool and training.

There’s no evidence that I’ve ever heard of that suggests “the training that takes place in learning to program does train the brain to think about solving a problem in an algorithmic way and solve daily problems with that approach when needed.” From Kurland & Pea to Palumbo, there has been no measurable impact on problem-solving in any other domain after learning programming.

Here’s a thought experiment: think of the best programmers you know. Are they also the best at problem-solving all other parts of their lives? Are they above average in problem-solving in any other domain besides programming?

Yes, some of the best programmers I know also are good writers (able to construct logical arguments, properly structured, and get the punctuation right). Some are also quite good at math problem solving and electronics design problems. Some are good chess players.

They tend to be good in highly structured domains, less good in domains that require political or social skills.

I don’t know that learning programming improved their problem-solving skills, though. I think it more likely that having good problem-solving skills improved their programming.

Perhaps it would be OK to look for near transfer instead of far transfer. One question we got asked by an instructional technology director when introducing Scalable Game Design into “his” curriculum was: Will I be able to walk up to a student and ask “Now that you made Space Invaders, can you also make a science simulation?” I did think that was a great question but I certainly did not know the answer. I thought AgentSheets is pretty good to make games and simulations. Lets explore this. So we built a framework called Computational Thinking Pattern Analysis based on ideas borrowed from phenomenology describing object interactions such as collision. We then collected games and simulations built by over 10,000 students and looked for evidence of transfer. We found some interesting things. For instance, most students actually could build simulations after creating a couple of games and they even enjoyed it. However, just as Roy [Pea] previously showed the expected Logo (or programming in general) far transfer does not just happen. Typically only when teachers were very explicit about mapping the computational thinking patterns to the application, that is game design or simulation building, was there a good chance of transfer. I can hear my school of Ed colleagues shriek now. They do not want me to use the dreaded “transfer” word at all. I think I am allowed to say that students acquired skills in the context of game design which later they could leverage for simulation building. To me this sounds pretty promising.

Alex, that starts to sound like the computationally literacy I’d like to see. I do wonder about transfer into career, but that is further transfer, as you say. How hard is it to construct classes where this happens? How much fidelity do you get to your curriculum? How much professional development do the teachers need? Bottomline: How much would it cost to do this everywhere?

“We have to figure out how to change computing so that it’s possible to learn and use it over an entire career, without a PhD in Computer Science.”

This is a follow up to your earlier quote that it’s hard for you to use Javascript libraries:

“I have a PhD in Computer Science, and it takes me way too much effort to pick up JavaScript libraries that I might want to use — far more effort than a non-technical person will be willing to put in.”

First, I think you’re conflating “computing” (learn and use it) with “programming” (pick up Javascript libraries). I’ve had the same experience with Javascript, but I don’t think it’s because it’s necessarily hard, I think it’s because I’m trying to learn it without putting in the time, and hoping that by reading 20 Stackoverflow posts I’ll figure things out. That’s not the case of Javascript being hard, that’s the case of me thinking I should be able to learn it easily, without really putting in the time or being efficient in my learning. The same thing happened when I tried to “pick up” scheme/continuations, if you don’t really steep yourself in a non-trivial task, you don’t get it easily. I tried to do word-working without getting experience, it didn’t work. In the case of Javascript and programming in general perhaps it’s because, I think, that some programming is intrinsically hard. I’ve had concurrency bugs in Scratch that I only figured out because I have experience with concurrent programming. I don’t think students would figure these bugs out.

It’s not that we need to make programming easier, we need to build experience with simple environments and we need to allow students to see the power of what they could do if they put in the time. Programming is hard when the problem you are trying to solve is hard. I’m currently watching 60 Duke students get tremendously excited about using either Scratch or Javascript to solve a problem they want to solve, not one I gave them. These are not students who will continue with programming, nor do I think they want to (in general). But they’ll appreciate what’s hard and they’ll see that they could do some of it.

I advocate for cyber-literate citizens, not a society where everyone who puts in 20-50 hours of programming in Scratch or even Python thinks they know how to solve a problem by programming. Most of the people I know, most of the students I teach, aren’t programming outside of class. We shouldn’t encourage them to unless that’s what they want to do, but we should allow them to see what they could do if they knew how to program and wanted to continue with it. This is about opportunities and letting students know that there is something they might want to study.

I wonder about the cost of providing this: “we need to build experience with simple environments and we need to allow students to see the power of what they could do if they put in the time.” You are an award-winning teacher at a highly-selective school. Trying to provide the experience you describe to everyone, to create a cyber-literate society (a lower bar than my computing literacy goal), may still be too expensive to be practical. How much of that cyber-literacy will be remembered into career, and what would we expect to see in terms of behavioral evidence that someone actually is cyber-literate?

I’m a bit more optimistic about general computing education for several reasons. To begin, I don’t like the comparison to finance. Over time, finance has become increasingly difficult. Even simple bank accounts (or introductory finance) have become more complex. People no longer buy stocks to earn dividends; instead, they buy stock based on nebulous ideas of value; much of that value is simply perception. Don’t get me started on derivatives. In contrast, computing is becoming easier. Java and Python is easier than C and C++. Scratch, Alice and Greenfoot are significant improvements over Basic, Logo and Pascal. We are getting better and better at teaching programming (more research, more teacher training, better learning environments and support material). Learning to program can be done in microworlds with immediate (visual) feedback. That said, programming is not trivial. We try to teach mathematics (Algebra, Geometry, Trigonometry) to average people for many years (my guess is most high school graduates had about 5 years of math past basic multiplication, fractions, etc.). Yet, the general math knowledge is pretty poor when compared to what mathematics majors are comfortable with. That’s okay. We may not get to the point where CS majors are impressed with what the average person knows about programming. That’s okay. I’m sure English majors are exasperated by YouTube comments. It doesn’t mean we should give up. Even slight improvements over time (e.g., increasing the number of people who have access to a single programming class in high school) can have significant effects. More general literacy will lead to more interest, which will lead to more majors, more awareness, more educators, etc.

I am not sure programing has become much easier but it certainly has become much more interesting. Drawing a circle on the screen in Logo must have felt like real entertainment in the sixties but is not considered particularly gripping by the kids today. Today programming could be used, for instance, to make cool 3D games running in browsers or create mobile apps.

But what about programming being easier now? People seem to have massively overblown expectations from drag and drop programming. I feel we may have contributed to this perception by creating (with AgentSheets almost 20 years ago) one of the first educational drag and drop programming environments. The extend to which this expectation is exaggerated is best described through an analogy to natural languages. Imagine that somebody is told that an important syntactic rule of the English language is that a well-formed sentence must contain a noun and a verb. Imagine further that the same person is now instructed to write a best selling novel. Clearly, this would make little sense. The fact that this person could create a syntactically correct sentence would in no way imply that sentences produced would be meaningful, or interesting. The same problem applies to programing languages. We have only solved the almost trivial syntax problem. Now it is time to tackle to much harder semantic problem of programming. Don’t get me wrong. Having solved the syntax problem was important and has enabled many to use programming to create something. However, the problem is that something quite often really is not much at all. I am not sure where the boundary is between just something and something interesting but my benchmark would be that if you could have built that something as a PowerPoint animation, well, then you probably did not learn much about programming.

Hi Alex, I’ve just been rereading your stuff. Quite inspirational. I’m currently working on what could be the next step in introductory programming environments; I’m not 100% convinced it will work yet, but it is looking promising. I’ll share more once it starts to work. As part of that, I am doing a background literature search, trying to steal ideas from the better projects and building on the progress we’ve made. Checking my notes, I do think we’ve made significant progress in several areas: (1) Minimizing Syntax Errors: Drag-and-drop is certainly a big one here for novice programming environments, but less obfuscated syntax (e.g., Python) and command completion and syntax highlighting also help general purpose languages be more comprehensible. (2) Visibility: In novice environments, the commands are usually highlighted when they are executed, letting a user more easily debug what is going wrong. For general-purpose languages, debuggers have gotten significantly better. (3) Abstraction: While object-oriented programming is hard, programming with objects to some extent makes things easier to understand for Alice, Scratch and Greenfoot. (4) Sharing Code: While I’m not convinced that code created by novices is that useful for novices (though publishing code to an audience can be motivational), there are so many code resources available for general-purpose programming on the Net. (5) Motivating Tasks / Problems: From lilypad Arduino to Mediacomp to Looking Glass, the huge problem of motivating students is being attacked head on.

That said, I don’t think we are at the end. I agree with you wholeheartedly that drag-and-drop is not a panacea; it was just a good step in the right direction. Coincidentally, my programming environment will not use drag-and-drop. One thing that I do find missing in the literature is critique of systems. While I like Scratch, there are things I hate about it. For a system that has existed so long and has had such impact, there really should be a good critique. I can’t find one.

It strikes me that the issues brought up by Lauren Willis for financial education, and it’s potential dangers vs. expenses might just not exist when it comes to computer science. While I’m not contesting that one can’t do a lot of damage with cs, it’s significantly harder to accomplish, and usually comes from active intent rather than accident or ignorance.

However, on the other hand, unlike in finances where incredibly complex systems require a large amount of understanding, both of math and the rules within the systems, CS can allow for just a small peak to greatly increase someone’s understanding of the digital world we live in. Learning just that a few lines of code can lead to an image manipulation, to take a random example that has nothing to do with anyone’s work or anything, allows folks a much greater opportunity to gain insight into the way all programming works. A “You mean it’s all just WORDS?” moment, if you like. And furthermore, that simple experience of programming, even in the span of a single course, can easily give folks a similar chance to understand core concepts like how dumb computers are (they do exactly what you tell them to do), how simple it can be to do small things with cs, and how those small things can be actually useful in one’s day to day life.

I don’t think there’s any reason therefore to contest the fact that everyone should be exposed to CS, and that if not literacy, than at least understanding of the way that such systems work can be incredibly beneficial to an individual. And unlike any course that taught financial literacy, a required computer science course, by the nature of computer science, would be unlikely to be as dangerous to the student or society as a whole.

Thanks Mark, this was a great post. I think your point boils down to this: universal literacy is expensive to get right and we might not have the resources or capacity to achieve it, even if we can figure out how to do it well. After all, we can just barely achieve universal literacy in reading, writing, and arithmetic, even with everyone on board. Universal computing education is a much taller order.

This perspective can seem a bit cynical, but I actually think it’s quite constructive: it allows to consider the full range of alternatives, many of which might even be more effective that formal computing education. We can embed high quality computing education in the context of people’s work (end-user programming); we can embed it in games that people volunteer to play; we embed it in every other subject of learning, including not only STEM subjects, but also the humanities and social sciences. And if we manage to infuse society with computing education everywhere except formal education, we might achieve just as much or more literacy than formal education could.

The tricky part about embedding is computing education is that it’s an entirely different form of instruction. It requires designers of learning materials and technologies to “shatter and scatter” concepts and instruction throughout an experience, rather than build upon concepts in a sequence appropriate for computing. It’s harder to assess learning. It’s harder to engage learners without the extrinsic force of compulsory coursework.

Thanks, Andy. One concern with the “shatter and scatter” strategy (which is a fun phrase) is how to make it work so that women and under-represented minorities get the same opportunity to experience computing. A distributed approach could easily only reach the privileged groups.

I’ve been thinking, writing, and re-writing my response to this blog post for days, and finally Andy has phrased it much better than I could have.
My thinking now is to continue to push for all to have *access* to computing education (real computing, not application literacy), but to ease off on the mandate of *requiring* computing education, for several reasons. One, the “bag is already full.” What we now ask high school students to learn before they ever get to college is a lot and continues to expand. And most expansion comes at the expense of another discipline, setting up turf wars. Second, because in general the educational requirements are set up at the state level, that means 50+ battles to be fought. Then there is the cost-where to find and train the educators, etc.
Instead, what if we embed computing into the other disciplines? Would it not be more cost effective to have a computing teacher at each high school who taught one (or two) classes of “real” computing (computational thinking, programming, whatever) but also team taught one unit within all the science / math / English classes as well? Simulations in science, data exploration and decision making in math, story-telling in English?
With well developed curriculum tools the computing teacher handles the computing aspects which the discipline teacher handles the discipline content. Students (and discipline teachers) are exposed to what computing can do yet we haven’t added to the bag or increased the overall cost (other than initial and continuing curriculum development – which I see being done by cs ed researchers!).

Bri, I think that you’ve raised the bar for the level of competence for high-school CS teachers too far—it is hard enough getting teachers who have the minimal competence in CS needed to teach intro courses in CS. Finding ones who can also teach science, math, and English will reduce the pool to a vanishingly small level—particularly the inclusion of English, as there are few teachers who can include computation in a meaningful way in high school English classes.

Incorporating programming into physics classes is coming (which means that maybe 1–5% of physics teachers are using that approach to teaching physics). Using simulations written by others in physics classes is already pretty common, and does not require a computing teaching.

We are seeing a growth of interactive tools in geometry classes (with Geogebra being the most commonly mentioned), and a lot of teachers are exploring using computational tools to teach math better. It seems that once they learn how to use the tools well enough to create their own, though, they leave teaching and become software developers or curriculum developers (based on the small sample of math bloggers that I’ve been following).

This was certainly interesting reading and got me thinking that I am on the same page as Barbara. I think we need to allow students to be exposed to the concepts, the ideas, to play, to find out if they like learning to code or manipulate. It is also important to demystify the language so that you can recognize ‘nerdy strutting’ and not be bothered by it. It is the opportunity of access that is important. You have certainly got many people reflecting with this blog.

Another difference that might make the comparison between financial education and CS education more problematic is that the people designing financial systems and products don’t have much of an incentive to make them easy to understand or compare. If I was being slightly less charitable I would say they have more of an incentive to make them as obscure and hard to understand as possible. This is probably part of the reason why any education in this area would have to be extremely effective or it would end up doing more harm than good as those with only a partial level of understanding would be lulled in to a false sense of security.

One of the many reasons I’d like to see more people with a better understanding of Computing is that it gives us all a way of being able to argue coherently when systems are created that do more to oppress rather than support us. Increasingly many of the people I speak to are quietly unsettled about what’s happening to them in their workplaces as a result of computer based technology but don’t have any real meaningful frame of reference to help clearly articulate their concerns. It’s not just the older generation either but a whole spectrum of ages.

For comparison, one of the historical periods where a widely useful trans-formative technology was known only to a technical elite and controlled by those in power was the written word during the middle (dark) ages. A written instruction such as a law still needed a human agent to carry it out and could still be subject to interpretation and possible subversion. The computer code that now controls our systems and increasingly regulates peoples workflow on the other hand has no such moderating influence.

I, similar to Ann Drobnis, was uneasy until you mentioned Barb’s comments. I want all students, not just the privileged, to have the opportunity to discover computer science since I believe it is our only hope to achieve the goal of broadening participation. Mark, thanks for continuing the public discussion of this important topic.

Regarding transfer, Peter Rich and his colleagues in the BYU Dept of Education are working on a theory of “convergent cognition”, which is a form of transfer. They are trying to identify structural conditions between disciplines that enable transfer. So far, they have been looking at transfer between spoken languages and transfer between math and CS (in the latter case, looking at work we’ve done with Racket and Bootstrap). See Rich, P. J., Leatham, K., & Wright, G. (2012) Convergent Cognition. Instructional Science. DOI: 10.1007/s11251-­012-­9240-­7.

When we dream of transfer of problem solving skills from programming to other domains, I often feel we fail to articulate what specific problem-solving skills we think students have developed sufficiently to enable transfer (“problem solving” is horribly vague). Our group is currently doing studies on whether the very concrete design process that we teach in Bootstrap (that came from How to Design Programs) helps students better solve algebra word problems. The entire premise is based on a very concrete problem-solving strategy, and whether the process of writing small programs and the process of solving algebra word problems have enough structural similarity to enable transfer _through that concrete process_. If transfer is possible, I think it has to start small and very concrete. I don’t find these features in a lot of the earlier transfer-from-programming literature.

To me, the interesting analogies to Willis’ concerns about financial literacy education (I also listened to the podcast) lie in aspects of CS in which a little education leads to dangerous impacts on self and others. I’m surprised nobody has yet mentioned security or privacy — look at the number of apps that get created with nasty security/privacy holes because people have enough knowledge to make apps that run, but not to make apps that work safely. Learning to write safe/secure/etc code against current frameworks takes a lot of time. Would better frameworks help? Sure. But that raises the more interesting question: to what extent are we (as a computing community) working to make IDEs for “the lightly-educated programmer who wants to release non-dangerous apps to the world”?

I appreciate the implications the original podcast has for universal computing literacy. Personally, I’m more struck by its implications for the partly-educated community that Mark and many of his students target in their work. All the drag-and-drop and other “beginner friendly” efforts we have don’t help self-driven novices write safer Javascript apps. How economically feasible is that education (especially when security is only of secondary interest to getting a working application)?

Thanks for the link! The convergent cognition idea is really interesting. I wonder if it would explain the results of Idit Harel and Yasmin Kafai in combining programming in Logo with learning fractions (Idit) then science (Yasmin). Sharon Carver’s work which did show transfer from programming to map debugging did build from small, concrete steps (modeled in the GRAPES cognitive modeling system). The kind of transfer you describe is also predicted by Mark Singley and John Anderson’s work.

I’m trying to parse the last sentence in your comment: “How economically feasible is that education (especially when security is only of secondary interest to getting a working application)?” Which education is “that education”? To become “partly-educated”? Or to learn to write secure applications? I’m assuming that you’re referring to App Inventor. Neither Scratch nor Alice let you build apps, and I don’t think you can build anything with them where the question of security arises. Is it possible to build Android apps with App Inventor that have security holes?

Kathi, are you of the opinion that end-user programmers need to be concerned with security when building things in JavaScript? Isn’t JavaScript already sand-boxed?

By “that education”, I meant one that would result in programmers writing safe/secure/reliable programs. I’m not thinking of novice-friendly languages here, but rather novices working in the professional-strength languages that many apps (web, phone/ whatever) are built in. I’ve never looked at the potential for security holes through AppInventor, but given that security holes often arise from bad program architecture or poor data handling, I’d expect that such holes are achievable in any current language.

Sandboxing only constrains Javascript code that runs in the browser. A host of possible problems remain. A Javascript program can call out to a third-party tool (such as Flash) that is not confined to the sandbox. The Javascript code can leak data, or include other third-party code that is malicious (via mashups). Javascript can be used to write server-side code, or (increasingly often) browser extensions, neither of which are confined to sandboxes. If someone is interested in the details here, http://www.jswebtools.org/ has a blog and papers discussing security issues around Javascript.

In the context of the transfer discussion, some of the problems I’ve listed arise because programmers reuse skills developed in a language in new contexts with very different constraints. Safe programming requires developers to have the experience or instinct to ask about how the language behaves differently in the new context, even with the same syntax and apparent semantics. Talk about another dimension around transfer!

[…] looking. For example: would you dare to consider if education itself is worthwhile? This paper (via Guzdial) suggests that education to instill financial literacy is costly and harmful to the students (it […]