On Nov 27, 2009, at 12:19 AM, Alan Blackwell wrote:

So to summarise this whole discussion, based on text of your
previous message, it seems that you would like to know what
aspect of computer programming is, or ever could be "automatic,
without requiring conscious thought ... or rational processes"

Is that right?

Sort of.

People presumably don't take CS1 papers unless they think they
might do well, yet CS1 papers notoriously have a very high failure
rate.  Clearly programming _isn't_ intuitive for most people, but
people who are _now_ programmers often feel strongly that it is.
Why?  Is there something we can use to reduce the CS1 failure rate?

Anthony Robins
recently noticed
that the characteristic bimodal distribution of outcomes in CS1
can be explained by a very simple statistical model.
(Roughly speaking: a series of topics where failure at any point makes
later failure more likely, success makes later success more likely.)

So if, for example, you "get" variables-and-assignments easily,
that makes it more likely that you will "get" Java 'for' loops,
and that makes it more likely that you will "get" how to work with

So what makes it easier for someone to "get" variables-and-assignments?

I've mentioned trying to teach surveying students a bit about Visual
Basic, and I originally thought "this won't be too bad, because they
ALREADY know about boxes that can hold numbers, and can hold different
numbers at different times.  In fact they already know about giving a
name to a box, this is something Excel lets you do, and you can use a
name in a formula.  Since they already know formulas, named boxes,
and changing what's in a box, all I really need to get across is
comments, loops, and user-defined functions."

Wrong.  I still think that spreadsheets *ought* to make programming
more "intuitive", but I'm not seeing much evidence of it.  While
Excel lets you bind a name to a cell, this is not something students
have ever actually done.  There IS some transfer from the idea of
"cell              coordinates     edit" to
"memory element    address         address"
so I think they're "getting" some of that.

The result found more often than any other is that the need to
use recursion as a control strategy is the greatest single
obstacle to the practical use of most popular declarative

The most popular declarative language is SQL.
Perhaps the fact that it doesn't use recursion may be a factor
in its success?

Haskell experts advocate a higher-level style where most of
your code is free of explicit loops, not completely unlike
using LINQ.

Is the "intuitiveness" of recursion something we can CHANGE
by providing the right experiences?

As far as I remember, Shaaron Ainsworth and
Judith Good both made some progress on that in their respective

I've just spent the last 40 minutes searching, with
no success.  Do you know of links to those theses?

Reply via email to