As best I can tell mixins still use classes. Though Weinberg didn’t really talk about programming, I think what you are saying kind of fits in with where I think programming is heading: the ability to change representation more easily.

Re: static typing mixins being superior to dynamic typing

I don’t see your point. As far as I’m concerned you’re defeating yourself. You’re trying to reach a state where you can change the representation of something at will (re-classify it), but you’re using a static type system which has a tendency to lock down representation. Your goal would be more easily achieved using a dynamic type system. Even the mixin strategy is easier to implement in a dynamic language (incidentally, the mixin strategy was invented by the Lisp community).

As for me, I find that expressing my intent is more easily achieved in a dynamic language, because I can express my algorithm using the representation I want, without type markers cluttering it up. I find that with languages that are statically typed I tend to focus more on how the computer will execute my process, and I’m forced to represent it that way. I often end up adding comments saying “This is what my process does here,” because the code is just telling the computer what to do. It’s not telling me what it’s doing. Granted, type specifiers are still valuable in some contexts, and I still use them, but I’m glad I’m not forced to use them everywhere.

I think languages like Groovy have a future because they give the programmer a choice of where and when to lock down representation with static types.

David Weinberge is advocating multiple classification systems; each useful for it’s own purpose. Classification is useful, as it speeds understanding by associating with similar objects. Albeit multiple classification can seem more complicated, it is rare to need more than one classification for any given purpose; leaving the user with only one relevant classification.

Extrapolating David Weinberge to programming: He is saying the class hierarchies are the Dewey Decimal system in programming, and we should be going to a mixin system which is more useful for our particular (and changing) purposes.

A static typing mixin system is superior to dynamic typing for the fact it communicates more about the intended use of objects to other programmers (and the compiler).

I’ve seen other presentations by Kay, so I’m usually familiar with most of what he discusses. He’s always good to listen to though. He continually amazes me. A couple things he said were prophetic in this video. In the midst of the “browser wars”, he predicted that Microsoft would not take over the web. Nor would Java/CORBA, and he gave his reasons. He also gave the keys to “the semantic web”, conceptually, which has been a hot topic over the last year or two–but this was 10 years ago. When he talked about “every object having its own URL”, it made me think of REST, at least what I’ve heard about it. Even though he said, “This is something that will need to be worked on over the next 10 years”, it’s something we’re still working on.

As for static vs. dynamic typing, I refer you to an article you linked to a while back, called “The Art of Lisp & Writing”. I really enjoyed that article, incidentally. I commented to a friend several months ago that writing code in Smalltalk “felt like writing”. I’d say the same about Lisp, though I need to get more familiar with it. Richard Campbell said that the problem with statically typed systems is they force you to make decisions early, and the problem with that is there are not only the domain-driven requirements, but there are also the system requirements that are realized once the system is built. You don’t realize them until then, so it’s better to work in a “medium” that is maleable. It’s much harder to change things in a statically typed system. He said it’s better to introduce static typing once you have a mature product, when you want to “lock down” certain aspects of the app. Just a guess, but it sounds like this is where mattias’s suggestion about Typed Scheme comes in handy. The thought that came to mind for me when Campbell said this was the Groovy language. It allows a spectrum of development ranging from complete dynamic typing to pure static typing. In fact you can use Groovy to program in straight Java if you want.

As for pragmatics, take a look at Typed Scheme from PLT. It is an explicitly typed language that we constructed over the past year, with the goal of porting systems module by module from an untyped world to a typed world. Naturally as you port your systems, you want to change as little as possible, granted that you have to declare types for function headers. One thing we therefore do accommodate — in a type-safe manner — is the idea that a variable (function parameter) can assume different types in a function body. Specifically, the type depends on the control dominator of the variable (which predicates dominate the flow of control to the variable occurrence). So you have categories yet they are flexible.

Thus far we have ported a few thousand lines of code — small scripts (100-500 lines), medium size libraries (300-1000 lines) and an application (some 3000 lines). The person who ported the programs is a student who hadn’t programmed in Scheme before. It is amazing how easy it is for him to port code and how little code he has to modify or add. We are pretty sure that the code base is representative but we are in the process of conducting additional experiments. We’ll report this somewhere and hopefully soon.

The conclusion I can offer after 20 years of soft typing research is that many dynamically
typed programs do satisfy a type discipline but it is *not* the one that static typing would
superimpose on dynamically typed programs. These things are as practical as Turning machines, so take appropriate statements with a huge grain (ocean?) of salt.

As for the “dynamic type” discussion, I find very appealing Kay’s speech. First of, it is of my understanding that classifying an object is making a compromise with how we perceive the object at a given moment. As our perception changes, we might find out latter that the taxonomy must be modified. Since our perception changes constantly, inflexible classification is, by itself, a huge problem. Of course, I think that would be the case as well with static typing.

Other line Kay says that strikes me in the deep is about constructing complex systems. I think it goes something like this: finding out how things interact with each other (rather than precisely classifying the things) is what makes possible to build and grow complex systems.