Subject: Re: dynamic redefinition of classes From: Erik Naggum <firstname.lastname@example.org> Date: 1998/11/06 Newsgroups: comp.lang.lisp.franz,comp.lang.lisp,comp.lang.clos Message-ID: <email@example.com> * Barry Margolin <firstname.lastname@example.org> | I think learning by comparing and contrasting is the way to go, as it | allows you to build from a foundation rather than starting from scratch. 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.) #:Erik -- The Microsoft Dating Program -- where do you want to crash tonight?