Ted disagrees with my take on final classes:
It was in my days as a C programmer that I came to realize that the fundamental difference between Smalltalk and C was that in Smalltalk, all reusability derives from inheritance. You want to reuse some code, you inherit from it, plain and simple. Even working through the Cincom Smalltalk manuals, I see that message over and over again. This is not true outside of Smalltalk.Inheritance creates a dependency on the base class type within all derived types, and if for some reason something in the base class type needs to change, every class below it feels the change, potentially breaking what happens.
First off, I'd say that most Smalltakers are somewhat leery of deep inheritance hierarchies now. With dynamic typing, polymorphism makes it easy to create ad-hoc interface matching without having to share a base class. In fact, that makes it easy to avoid the whole "fragile base class" problem entirely (even though it's less of a problem for Smalltalk than it is for static languages). I meet plenty of people who disagree with me on this point - the guy who gave the API talk at ot2004, for instance - I spoke to him briefly on the subject. I'm just not convinced. I know too many Smalltalkers who also know .NET and Java - all of them dislike "final", and all of whom talk about the nasty work-arounds they have to create to deal with the problem (typically, lots of helper classes). I tend to think that anything requiring that level of work-around is probably a bad idea.
Sure, this is a culture clash - but I still think it's a bad idea as well :) I think we'll have to agree to disagree for now