Gilad Bracha, a programming language researcher, publishes papers on Newspeak, Smalltalk, pluggable type systems, and mirrors.
Commenters point to his Newspeak module design, which has no imports or hard-linked dependencies, and mourn the loss of the gradually typed Strongtalk.
He's all over the place, and as other commenters have mentioned some of it is a little ridiculous. However, there are a few great kernels.
I am guessing that one of the reasons that Test-Driven Development is popular is that it also exposes object interactions during development.
This is exactly right. The reason TDD is useful goes right back to the fact that Well Factored Programs Cannot be Understood Statically [0].
Type systems cannot deal well with the fact that programs change, and that different bits of complex systems may not be consistent.
Oh my this is exactly right. Most of my work is doing integrations with a variety of APIs. I try to do as much as possible in JavaScript because it's dynamic nature papers over the major issues in nearly every "enterprise" API. I'm very excited about the prospect of pluggable types [1] that he mentions.
I challenge you, however, to name a single programming language mechanism that supports change.
The first I've ever seen was just yesterday [2], but even that is just a tool attached to a language ecosystem, not a part of the ecosystem itself.
I like to think that one day, when we grow up, perhaps we will think of the model as being the source code.
I think this is already the case in many circles. For instance, domain-driven design makes it a priority.
...we have difficulty distinguishing real and accidental complexity.
This might be the most insightful statement in the article. I'd be intersted in readin gmore…
I have a feeling that Dart may be some version of Bracha's Newspeak. If you read his blog post on Javascript's failings, you'll see him talk about how they are already trying hard to have Newspeak fill the gap:
http://gbracha.blogspot.com/2011/03/truthiness-is-out-there.html
There is also an uncanny link between the features Dart highlights -- security, optional typing, modularity -- and Newspeak. The timing of Newspeak development and Google's Dart also coincide perfectly. The blog post talks about a Javascript compiler, pluggable type system, IDE (Brightly?) all being in the works.
Newspeak's pluggable type system sounds similar to what is known about Dart. For instance,
http://bracha.org/newspeak.pdf
> We also intend to extend Newspeak with an optional type system and a framework for pluggable types , enabling the language to enjoy most benefits of static type systems without incurring their limitations.
It also seems like a smart engineering choice to base whatever Dart is heavily on some proven language, even if there is a new VM. Given that Newspeak is Bracha's most recent attempt and it's goals are so well aligned, it's hard to imagine he'd start from scratch.
>I think that's a vision of OO that not many OO programs that I've seen actually follow.
Maybe not, but it absolutely was part of the original vision. This is why Smalltalk 80 implements if/else statements and loops as methods, rather than keywords. A boolean in smalltalk is not just a value. It's a latent algorithm for choosing between two blocks of code at some later point in time. It's also a latent algorithm for operating on other booleans via binary logic methods. Until you start seeing objects this way, you will not be able to appreciate the elegance of object-oriented programming.
Here are some examples of how this can work in non-trivial scenarios:
http://www.vpri.org/pdf/tr2007003_ometa.pdf
https://bracha.org/executableGrammars.pdf
I don't think they had any such "realization" about a superiority of static typing, especially as research indicates that there are tradeoffs between dynamic and static typing, not that there is superiority of one or the other model. Both Bracha and Felleisen tend to fall in the soft [1] or gradual [2] typing camp, after all. See, for example, Bracha's paper on pluggable type systems [3].
As for retrofitting a type system into a dynamically typed language, Dart had gradual typing from the beginning (with types being checked at runtime), so it's an entirely different beast from (say) Ruby or Python.
[1] http://wiki.c2.com/?SoftTyping
[2] https://en.wikipedia.org/wiki/Gradual_typing
[3] http://bracha.org/pluggableTypesPosition.pdf
I'm glad that you like it, maybe you can explain to me: Newspeak is a Smalltalk variant, and, if I understand:
http://bracha.org/newspeak-101.pdf
it can currently work only in its own IDE, which, IMHO, immensely reduces the possibilities for its application.
Even if we get "a kind of smalltalk in a browser" who's going to use it? Imagine, all that goodness I have in my favorite editor, just goes away. I'm supposed to click around in some IDE modifying some classes with something, only to change something that works only in that same single IDE? What should be the real use of it all?
> we run [your custom code] inside a wasm-based sandbox, a compiled version of the QuickJS VM (yes, it's JS-in-JS).
I'm curious about why. Is sychronicity the only reason? (And is it really worth it? `await` makes asynchronous code paths pretty unobtrusive.) Mirrors[1][2] are pretty interesting.
(Not sure that I agree that compile-to-WASM makes for JS-in-JS. WASM isn't JS. Why do people keep conflating them?[3])
1. <https://bracha.org/mirrors.pdf>
2. <http://www.wirfs-brock.com/allen/posts/228>
3. <https://news.ycombinator.com/item?id=29754432>