huh?  if by "starting from scratch" you mean forgetting understanding, I
  don't understand how it woulb e possible to forget understanding.  it has
  never happened to me.  I forget details, particulars, individual rules,
  but I don't forget anything in the web of understanding that forms how I
  approach things both new and old.

  e.g., the specific syntax and the concrete semantics of one language are
  useless in the extreme when learning another and should be ignored, not
  used a basis for comparison.  the idea of expressability of the concepts
  through various general means remains, however.  when you first learned
  to program, you needed to learn the concepts of flow control, variables,
  evaluation order, operator precedence, types, etc.  these _concepts_ have
  different expression in each language, optimized differently according to
  perceived frequency of need, and you can obviously not avoid employing
  your _understanding_ of these concepts, but you ought to suppress your
  memory of the particulars, and I think that is fundamentally necessary
  when learning a new instance of something when you know an old instance.
  it is really hard to discover subtle differences when you expect things
  that appear the same to be the same, but aren't.

  "it is better to know what it is, than to believe it is what it appears
  to be".  short motto-like statement has hung framed on my father's office
  wall since I was kid, and it has shaped much of my thinking -- I find it
  infuriatingly frustrating when people hold the reverse view.

  incidentally, I think the idea of suppressing memory in order to learn is
  general advice.  remembering is a great time-saver when dealing with the
  already-known world.  abstraction and understanding is, however, what you
  will need and capitalize on when dealing with the to-be-known world, and
  if you remember at the wrong times, you will not recognize that something
  is sufficiently different from what you were used to to become anything
  but confused and frustrated by the differences when you stumble upon them.

  I think the subtle differences between Scheme and Common Lisp despite the
  many glaring similarities is a prime example of this, and we see students
  who continue to write in Scheme despite talking to a Common Lisp system
  all the time.  I attribute this to the problem of learning similar things
  through comparisons that yield false positives.  by effectively assuming
  the negative, I remove the danger of the false positives.

  now, _after_ you have figured out how something works in two different
  languages, you may compare them and reach valid and informed conclusions,
  but as a means of learning something new?  no way it will save you time
  and effort.  on the contrary -- the more you believe things to be the
  same, the less likely you are to stop and reconsider that view.

| In many ways C++ is closer to traditional OO, whose archetype is
| Smalltalk, than CLOS is.

  I guess it must be my education from the University of Oslo, but I heard
  that SIMULA was the first language to earn the "object-oriented" merit
  badge, as early as 1967.  SIMULA started out as a language to express
  simulation (complete with co-routines, absent in other object-oriented
  languages), and grew into an object-performs-action-language, which is
  the model employed in C++ (Bjarne was very influenced by SIMULA), and I
  don't think this is even close to the message-passing model of Smalltalk
  and Flavors.  (I actually find the object-performs-action-paradigm
  lacking in abstraction power, since I don't think that way to begin with.
  both message-passing and generic functions work well with me, though.)