Gilad Bracha

> 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>

I can only point you to the doc, which you may have already seen: https://www.bracha.org/newspeak-modules.pdf It is worth asking on the forum to see if there is some exisiting code to show this in practice.

On the topic of modules, I recommend reading about modules in Newspeak: https://bracha.org/newspeak-modules.pdf Modules (which are just top level classes and contain nested classes) have no import statement and no hard linked external dependencies. When you instantiate the module (~class) you pass in dependencies it needs.

>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 still regret the death of Strongtalk --- a gradually typed Smalltalk variant. It gave you dynamic types, when you wanted them; and Smalltalk is pretty much the most dynamic of dynamically typed languages. And it gave you static types, when you want them; including proper parametric types and polymorphism. So you got the best of both worlds. http://www.bracha.org/nwst.html

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?

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…

Gilad Bracha is working on that with Newspeak: https://www.bracha.org/Site/Newspeak.html

The "Mirrors" system by Bracha and Ungar [0] is intended to address this IIUC. It's obviously a big, very messy problem, but without a good meta system, languages are forced to grow large and messy on their own in order to be appropriate for a wide variety of programming tasks, or to overuse compile-time macros/templating to similarly hairy effect. 0. https://bracha.org/mirrors.pdf

Getters and setters are not a "concept" in OOP. They're just a naming convention that is occasionally built into language syntax for brevity. FP people constantly miss something fundamental about OOP. Objects only exist at runtime. Any facility that provides powerful tools to deal with objects has to be runtime-oriented and would require corresponding language support. E.g. Mirrors: https://bracha.org/mirrors.pdf

Gilad is strongly into dynamic type systems and pluggable types (Dart 1.0, Typescript and so on). http://bracha.org/Site/Papers.html

Gilad left Google last July and is now at Tensyr. Source: http://bracha.org/cv.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 couldn't help reading the emphasized "types" in "optional types" as a yell for the Typescript developers Dart was saying this before it was cool! Historically, Dart was (in part) born out of Gilad Bracha's Pluggable Type Systems[1] paper, so the concept of optional types is the very heart of Dart, and was so long before TypeScript. [1]: http://bracha.org/pluggableTypesPosition.pdf

The comments under the "Feeble Typing" section make it clear the author has never seen or read Gilad talk about optional typing. For one example, read http://bracha.org/pluggable-types.pdf

Newspeak looks really fascinating. Relavent paper: http://bracha.org/newspeak.pdf

Yeah, but that picture on the website doesn't really make me want to try it, benefits of the language nothwithstanding... :-( (http://bracha.org/Site/Newspeak.html)

Clickable: Paper http://bracha.org/hopscotch-wasdett.pdf Presentation (also covers NewSpeak) http://langnetsymposium.com/2009/talks/08-GiladBracha-Hopscotch.html

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.

Came here to mention MyPy and optional typing, the preferable term Gradual Typing means something distinctly different. http://mypy-lang.org/about.html Dropbox employs the creator of MyPy but it isn't a creation of dropbox. Type Systems as Macros http://www.ccs.neu.edu/home/stchang/pubs/ckg-popl2017.pdf Pluggable Type Systems http://bracha.org/pluggableTypesPosition.pdf Propositions as Types http://homepages.inf.ed.ac.uk/wadler/papers/propositions-as-types/prop… https://www.youtube.com/watch?v=IOiZatlZtGU