More assignment/copy novice confusion

[arthur.siegel at rsmi.com]

Hans writes -
>> Arthur Siegel wrote:

>>[binding and references to lists]
>> All of this is far from obvious, but of course does
>> in the end make perfect sense.

>While it is a continuous source of confusion for newbies,
>it is only far from obvious if you're used to the implicit
>copying of other languages.

I am testifying that it is far from obvious even if you have
no other reference point as to how other languages work.

Like most things, once you understand it, it kind of *seems*
obvious.  But the specific issues I raised here, with the
simplest of class structures,  was an issue as *to me*
because in fact and in practice I was continually being bitten.  It did get to
the point where I had an emprirical understanding - I knew how
to get the behavior (usually) that I was looking for, but without
much concept of why things were happening  quite
as they were.

To make another of a series of unprovable statements - it seems
to me that in learning something new at an advanced age, I am
at some disadvantage in terms of how quickly I might pick
things up - I do walk around with more preconceptions of how
things *should* work.  On  the other hand, there is more introspection -
more of an ability to watch myself learn, as I learn. I am simply
reporting that these are the kinds of issues about which I hit my first and
most substantial  brick wall.  I guess it is up to others to assess how much can be
generalized from that about "usability" and documentation issues.

>But in fact, many other languages don't implicitly copy
>either for more complex objects... if you hack up a linked list in C, it doesn't
>copy itself magically... neither do arrays or what C calls
>"strings". So I think Python's concept isn't all that
>far-fetched... in fact, it might be more intuitive than
>most.

This is another place where I as a novice whose experience is limited
to Python (I actually do some Java, based on what I learned from Python,
the transition I can testify was relatively painless - Python *does* serve as
a good foundation- at least as to Java -  has been my general experience).
But the point, going back to the list.remove() behavior on iteration, is that I
am less likely to say - of course, that is the nature of the beast for this kind
of language.  It still seems kind of broken that the language should give me
back results it could *know* is not what I was expecting.  One let's down one's guard,
because there is a general expectation that the compiler only let's
one go so far in the direction of stupidity.  Still seems like, yes I crossed the
stupidity line, but the compiler let me get away with it.  But I am quite adament in not
wanting to see Python move in the direction of design decisions whose
primary purpose is coddling novices.  So in talking about what has given me
difficulty I should re-iterate how much has not, how intuitive much of it
seems - *given*  substantial focus directed toward the effort to understand.

Last point, is that I can only plead that in our usability assessments we
separate out results for those coming to the table with and without that
willingness to extend effort and meet the learning process half way.

Results and conclusions will surely be different for the two groups.

The programming language for people who don't care about programming,
should be something other than  Python, IMO.

Art