Gilad Bracha

"The notion of an interface is what truly characterizes objects - not classes, not inheritance, not mutable state. Read William Cook's classic essay for a deep discussion on this." - Gilad Bracha https://gbracha.blogspot.com/2022/06/the-prospect-of-execution-hidden.… http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf

Gilad Bracha gave an interesting talk (or in his words, "[maybe] the best talk I ever gave") called "Utopia and Dystopia: Smalltalk And The Wider World", where he posits a universe where the Smalltalk community has recognized and proactively fixed this problem, along with some other problems that outsiders see when they look at Smalltalk. https://www.youtube.com/watch?v=BDwlEJGP3Mk His blog is also great to follow as a general programming blog, and as it turns out, he wrote a post just two weeks ago where he rehashes some of the content. https://gbracha.blogspot.com/2020/05/bits-of-history-words-of-advice.h…

SML modules are a classic example of a "shadow language" ( https://gbracha.blogspot.com/2014/09/a-domain-of-shadows.html ). I'd like to see an ML-like language where modules/interfaces are normal values, functors are just normal functions, etc. Modeling such a system at the value level is easy enough, but having it run at compile-time introduces some tricky issues (especially around IO).

but I'm waiting for the language that is consistent all the way down. Newspeak is coming... http://gbracha.blogspot.com/

Hm. I have mixed feelings about this project (judging solely from the video presentation). On one hand, it is very impressive, no question about that. The sheer amount and diversity of stuff in it would require a degree of focus that makes me feel envious even after this very superficial examinaton. On the other hand, the choice of which stuff to put in just disagrees with how the boundaries are drawn in my head—I’d would have thought a file monitor and a build system/dependency tracker were separate tools, while expecting at least the simple part of migration boilerplate to be generated. But I guess that’d require hooks into the compiler frontend, which is not just goes against your goal of being relatively compiler-agnostic but is also fantastically difficult for C++. (I wonder if DWARF contains enough data to at least transfer over identically-named fields?.. It’s also something of a bear, but nowhere near a full C++ frontend.) I don’t know how this could be useful to you, sorry. Thank you for showing your project, I’m grateful for the food for thought in any case. Now, can we just all take a moment to appreciate that you needed a Smalltalk-style become:[1] and ended up making an object table, precisely the classic Smalltalk way? In the end it’s either that or precise pointer tracing, there isn’t (AFAIK) a lot of choice, but it’s still amusing to see an ostensibly high-level mechanism reproduced in a very different environment. [1]…

Computer language inventors are torn between a voice whispering “use the language Luke” and and a more gravelly “let your feelings for the compiler grow, embrace the syntax side.” I did a two-day sprint through Zig a month ago and really really liked it. It has some quirks that I would have done differently, but overall I think it’s pretty cool. I just need a good small scale project to try it out on now. My favorite example of the “use the language” ethos is the way Zig does generics. I have hated generics/templates in every language I use them in. They are the gordian knot of confusion that most languages in pursuit of some sort of unified type theory impale themselves on (yes, I’m mashing metaphors here). But Zig just uses its own self to define user types and generics come along for free. It resonates (with me at least) as a realization of what Gilda Bracha has shared about how to reify generics. [1] https://gbracha.blogspot.com/2018/10/reified-generics-search-for-cure.…

I would question your assumption that "clean code" that you describe is really modularization and abstraction. (In particular, separating everything into small scattered pieces, which is IMHO a horrible Java habit that I have to endure now.) I mean, both modules and abstractions should have purpose. The purpose of modules is to "do one task well" so to speak. So if for a typical change you need to modify several of them, you're not modularizing it right. The purpose of abstraction is to provide another "language" which lets you forget certain technical details, while clarifying the bigger picture. Again, unless this language has been designed wrong, you shouldn't have to touch the abstraction. Addendum: Of course, there is also the classic https://gbracha.blogspot.com/2011/06/types-are-anti-modular.html (and we can consider types to be a form of abstraction), so to some extend these things go against one another.

I thought this http://gbracha.blogspot.com/2011/01/maybe-monads-might-not-matter.html… was a fantastic comment. Sending a message on a channel usually costs at least a compare-and-swap or memory fence. This limits their applicability to things above a certain granularity [...] even in Erlang or Scala actors, you wind up passing around lists and other concrete data structures, because it isn't worth constructing those queues _everywhere_. So when is a distributed program's internal communication and IO the right level of granularity? Network IO would seem to be a familiar instance of an Actor model and should map directly. Interestingly, Intel's new Xeon Phi chip http://semiaccurate.com/2012/11/12/a-look-at-the-xeon-phi-cards-and-ha… "looks like a cluster of x86 servers that are on a TCP/IP network, and takes almost no programming expertise to port to."

From whatever little I see, I am already hating it :-) This looks like Java for Javascript, if that makes any kind of sense. We are in the year 2011, PL design has progressed so much since 1990 that such an anachronism is unpardonable. I sincerely wish that companies like Google focus on hiring the right kind of person for designing programming languages. What is frustrating is that there are so many people who can do this job right, yet we are stuck with amateurish programming languages designed by companies like Google. Please try and hire people like Oleg Kiselyov, Simon Marlow, Erik Meijer or some one from the possible hundreds who have worked deep in PL theory for literally decades. On the face of it Gilad Bracha has great credentials, credentials that would make the HR folk happy but one look at some of the stuff he writes and we know things are not going to be good. http://gbracha.blogspot.com/2011/06/types-are-anti-modular.html I think Phil Wadler gave him more respect than was due in the comments :-) Microsoft hired Anders Hejlsberg for .Net which I don't think was a good idea, he is a great engineer but not a PL theory expert. They however "rectified" the situation by hiring Erik Meijer later and his impact via LINQ and F# and improvements in C# is obvious. Not to say that Hejlsberg is not good, but Meijer is better. Getting back on track, I may be wrong but Dart makes me groan. It is one thing to design such a language in 1990, but quite another thing to do it…

> once you use an IDE that actually IS "integrated" as the acronym suggests, you will never turn back. If you're unfamiliar with Smalltalk environments and are wondering what this actually means, watch this 3-minute video showcasing a Smalltalk IDE -- the class browser, method finder, and debugger: http://vimeo.com/27850933 Anything else seems so... primitive by comparison. Smalltalk's great drawback is over-reliance on the image: "If your program misbehaves (and they always do) and corrupts the state of the process, things get tedious. Say you have a test that somehow failed to clean up properly. In a conventional setting, you fix the problem with your code, and run the test again. With an image, you have the added burden of cleaning up the mess your program made. [...] In general, Smalltalk makes it hard to [...] separate the application from the IDE." -- http://gbracha.blogspot.com/2009/10/image-problem.html

Gilad Bracha wrote a fascinating piece on how tail call optimization could be implemented with periodic collection instead of immediately reusing the call frame, it's a fascinating piece: https://gbracha.blogspot.com/2009/12/chased-by-ones-own-tail.html

Glad to hear you liked it :) This is the post that kind of opened my eyes and let me identify the issue: https://gbracha.blogspot.com/2009/07/miracle-of-become.html There are workarounds, of course - now that I know what I'm missing, it's perfectly possible to implement it in most anything! Though, why bother, if there are existing systems that already implement it :) (The other important issue is providing prototypal, dynamic inheritance (like in Self, Io, JS, and ofc LPC). Finally, object persistence - that's something that I didn't consider much until now, but other threads here about MOOs also opened my eyes. Not having to worry about server restarts might be a good thing... I think with these 3 things taken care of you'll get pretty close (maybe even a bit better) to the LPMUD environment.)

And this is one of the reasons Smalltalk did not take off in the 90s. All the useful versions priced themselves for the enterprise or took over the ones tuned for Windows. See Gilad Bracha's view on why Smalltalk did not take off https://gbracha.blogspot.com/2020/05/bits-of-history-words-of-advice.h… for more complete view.

Similar forces hampered the adoption of Smalltalk in the 90s as well [0]. Charging per-seat licenses to use programming languages almost never works, introducing friction that counters needed network effects, especially when prospective users can download a perfectly viable (if not much worse) alternative for free. Sure, there are a few systems bitterly hanging on to this business model - Lispworks, Cincom, Mathematica - but it's clear they are surviving in spite of it. 0. https://gbracha.blogspot.com/2020/05/bits-of-history-words-of-advice.h…

I find passing dependencies via constructor arguments make codebases a lot easier to navigate: it encourages a pattern where you have a single file that wires up the entire system and you can look at that file to get a sense of which modules are talking to which other modules. Gilad Bracha had some interesting posts that talk about this pattern: https://gbracha.blogspot.com/2009/06/ban-on-imports.html?m=1

It doesn't distinguish per se, it is rather a good example of something that a dynamic language can make that in a single call makes invalid all assumptions that JIT might have gathered until that point. As for become: usefulness, Gilad Bracha explains it better than ever will, https://gbracha.blogspot.com/2009/07/miracle-of-become.html

Things like Hiccup and React/JSX were a breath of fresh air next to templating languages like Handlebars/Mustache/Jinja. I prefer to just write simple code instead of learning the idiosyncrasies of yet another DSL. I'm reminded of https://gbracha.blogspot.com/2014/09/a-domain-of-shadows.html.

Here is an interesting blog post by Gilad Bracha on reified generics: https://gbracha.blogspot.com/2018/10/reified-generics-search-for-cure.…

Gilad Bracha (co-author of the Java Language Specification) on "#become:" in Smalltalk (https://gbracha.blogspot.com.au/2009/07/miracle-of-become.html) btw, see the section here on "Blub Paradox" (http://www.paulgraham.com/avg.html ) which means I'm not really competent to comment of C#'s dynamic objects.

FWIW, I made some videos of the demos; these are linked to from https://gbracha.blogspot.com/2017/05/dead-programs-society.html

It's not a new idea (not to knock the OP). http://wiki.erights.org/wiki/Safe_Serialization_Under_Mutual_Suspicion… calls it uneval instead of lave, and attributes it to Jonathan Rees. See http://wiki.erights.org/wiki/Safe_Serialization_Under_Mutual_Suspicion… for more on the security issues -- this was all for the E language, but I guess most of it could carry over to modern Javascript. One aspect that wouldn't: in E when you resolve a promise it becomes (http://gbracha.blogspot.com/2009/07/miracle-of-become.html) the resolution. Data-E uses this to express reference cycles.

It was some things he demonstrated at WGLD meetings; here is a blog post with the same title as his talk: http://gbracha.blogspot.com/2012/11/debug-mode-is-only-mode.html And later: http://gbracha.blogspot.com/2013/04/making-methods-live.html He is giving a keynote at ECOOP on the topic in June.

Gilad Bracha is the language designer behind Dart and Newspeak. The talk itself touches on many interesting things but one point that stuck with me is on DSLs and the 'world of shadows'. In a nutshell he explains why … React >> Angular, Polymer While you have the full power of JavaScript or Dart when you work with an 'internal DSL' architectures like Angular and Polymer or many templating systems have to re-invent many things like scoping, importing, logic and even things like iteration. Related article: http://gbracha.blogspot.de/2014/09/a-domain-of-shadows.html

I think it solves a practical problem for HTML templates. For example, React embeds HTML templates into JavaScript using JSX. Unlike most template languages that generate strings, their templates build a JavaScript tree structure without an intermediate string phase. This is rather hard to do in a practical way without a language extension, since having a separate file for every tiny HTML template is unwieldy. Also, most alternatives involve building a shadow language [1] into the template language which isn't as elegant as writing code in whichever programming language you're already using. [1] http://gbracha.blogspot.com/2014/09/a-domain-of-shadows.html

Smalltalk's "become" is a pretty interesting one... http://gbracha.blogspot.it/2009/07/miracle-of-become.html

newspeak was being ported to javascript, but it sounds like they may have given up because of limitations of javascript: http://gbracha.blogspot.com/2011/03/truthiness-is-out-there.html

related by Hewitt (1973) and Agha: http://gbracha.blogspot.com/2011/01/maybe-monads-might-not-matter.html

And perhaps Self edit: Even though I haven't used it, Newspeak (http://newspeaklanguage.org/) seems really interesting as well. Though I'm not sure if it's still being actively developed. Gilad Bracha's blog (http://gbracha.blogspot.com/search/label/Newspeak) explains a lot of the concepts. I find it especially interesting because like Smalltalk and Lisp it seems to be based on a small set of powerful primitives.

Not about Clojure, and has probaby been posted before, but: http://gbracha.blogspot.com/2011/06/types-are-anti-modular.html

> Its a pity that javascript is so in-grained in client-side web now, as its really a terrible bytecode... Gilad Bracha complains about this at http://gbracha.blogspot.com/2011/03/truthiness-is-out-there.html