Prototype Languages are a Failed Experiment
I remember reading long ago - maybe from Hejlsberg? - that Java's checked exceptions were a "failed experiment". Most people agree, and as much as I still like checked exceptions (and I can back that with tons of code...), it's a fact, in the sense that Java's experiment failed to convince most people - which you can assert by looking at newer languages. Not a single other programming language adopted this trait of Java. Language designers make decisions with various motivations, but you won't find checked exceptions in any kind of post-Java language, no matter if it's created by PhD researchers, big corporations, free software hackers with their different itches, or monkeys with their infinite typewriters.
The failure is bigger: I have fond memories of Eiffel, I didn't use it professionally but played a bit, Meyer's OOSE book was my first Bible (I mean it, as in, adoration-to-sacred-commandments). But the heretics have won and DbC is a mostly dead idea. Heck, even Java 1.4's modest assert is virtually unknown and unused.
[Personal note: I've used Pic%, a prototype-based OO language built on top of Pico, that one being a Scheme-like academic language. I was lucky enough to have Pico's creator Theo D'Hondt as professor in my MSc (EMOOSE ftw!), where I spent long nights in assignments to modify Pic%'s metacircular implementation.]
Wikipedia summarizes the criticism for prototype-based languages, but misses one item that seems important to me: prototypes are highly coupled to dynamic typing. I know of no prototype-based language that's fully and strictly static-typed; I mean not using qualifications like "optional", "lenient", "runtime", "partial", etc. Class-based languages, on the other hand, can be perfect matches for either static or dynamic typesystems (or anything in between). Henry Lieberman's seminal paper on prototype languages shows that delegation is more powerful than inheritance; this has been widely read and quoted as "prototype languages are more powerful than class-based", but that's bollocks, remarkably with the modern crop of OO languages and techniques, that both support delegation pretty well and deemphasize inheritance compared to the first-generation OOPL's. Today, the comparison boils down to the fact that prototype-based languages are much less flexible in the critical aspect of compatibility with different typesystem strategies.
Prototype, n., from greek "primitive form". RIP.