Popular conceit about learning programming languages

[Bengt Richter]

On Fri, 22 Nov 2002 17:56:37 -0800, Dennis Lee Bieber <wlfraed at ix.netcom.com> wrote:
>Donn Cave fed this fish to the penguins on Friday 22 November 2002 
>10:01 am:
[...]
>
>> So the first challenge may be to learn to think in Python, but then
>> you need to learn to think beyond it.
>>
>        Whereas I prefer to "think in" the abstract, and /then/ apply 
>transforms to map the abstract constructs to the target language.
>
I like this way of putting it, but I took thinking "beyond it" [Python]
to mean thinking in the abstract, so perhaps you are pointing to the same place?

IMO the interesting question is what "beyond-Python" elements are involved in thinking
"in the abstract." ISTM the imagination uses patterns in some representational
medium too, though coupled so closely with our experience of thinking that we
are scarcely aware of the process. I.e., we can infer that there are normally
subconcious processeses underlying our experience of thinking, just as there
are underlying our experience of having control of our bodies.

How does learning Python produce "beyond-Python" elements to think with in the abstract,
that are different from "beyond-Fortran" elements, or "beyond-Lisp" elements, or
even "beyond-assembler" elements?

I think after a time of using a language's representational forms in programming, one's
mind creates mental representations of the essential abstractions involved, apart from
the details of their physical representation syntax.

Fortran has abstractions too, but, e.g., no idea of dictionary per se binding a particular
set of names to a particular set of objects. Learning python gives you the abstract notion
of name->thing relationships to think with. You can get this notion from in Lisp as well, but
in Fortran name->thing relationships are narrowly contrained (for useful purposes) and don't
give you the general abstract notion. OTOH, arrays also have abstract counterparts, and
Fortran and associated libraries gives you some useful things there.

So I would say "thinking in" a language is thinking in the abstract, but restricting oneself
to the abstractions that map easily to representatons in the syntax of the language. The more
powerful the language, the less the restriction.

The best languages are those that will give you the cleanest and most powerful abstractions
to think with, while also providing a clutter-free and natural representation syntax that
lets you map both ways easily. ISTM Python is really excellent in this within its bounds
(which are pretty wide if you include "greater Python" with the neighborhood).

Regards,
Bengt Richter