by DonHopkins | 2025-10-25 23:02:10+00:00
One of my all time favorite and most influential papers! ("You're soaking in jit!")

But I always thought "dynamic deoptimization" should have been called "pessimization".

https://news.ycombinator.com/item?id=33527561

DonHopkins on Nov 9, 2022 | next [–]

A Conversation with Bjarne Stroustrup, Carl Hewitt, and Dave Ungar

https://web.archive.org/web/20150428011217/http://channel9.m...

https://donhopkins.com/home/movies/BjarneCarlDaveLangNEXT_mi...

They have a fascinating (and polite, respectful) argument about shared memory, message passing, locks, synchronization, and lock free message passing!

https://news.ycombinator.com/item?id=45315685

DonHopkins 35 days ago | parent | context | favorite | on: Help us raise $200k to free JavaScript from Oracle

SelfishScript. JavaScript credits Self as inspiration, but misses all the important things about Self.

JavaScript copied:

The name "Java", cynically chosen for marketing misdirection, not technical truth.

The word "prototype" from Self, but turned it into a quirky pseudo-class system. Instead of living objects delegating naturally, with multiple inheritance dynamically changeable at runtime, JavaScript glued on a weird constructor-function pattern that always confuses people, with constructors you have to call with new but can also uselessly call as normal functional foot-guns.

JavaScript missed:

The fluid, live object experience (JavaScript dev environments were never designed around exploration like Self’s Morphic).

The elegance of uniformity (JavaScript bolted on primitives, type coercions, and special cases everywhere).

The idea that the environment mattered as much as the language. Netscape didn’t ship with the kind of rich, reflective tools that made Self shine.

And most important of all: Self's simplicity! The original Self paper (Ungar & Smith, 1987, “Self: The Power of Simplicity”) was all about stripping away everything unnecessary until only a uniform, minimal object model remained. The title wasn’t ornamental, it was the thesis.

Simplicity. Uniformity. Minimal semantics. A clean consistent model you can hold in your head. Less semantic baggage frustrating JIT compiler optimization. Dynamic de-optimization (or pessimization as I like to call it).

Self proved that expressive power comes from radical simplicity.

JavaScript showed that market dominance comes from compromise (worse is better, the selfish gene).

JavaScript should be called SelfishScript because it claimed Self’s legacy but betrayed its central insight: that simplicity is not just aesthetic, it’s the whole design philosophy.

senderpath [Dave Ungar] 33 days ago [–]

Yes, indeed! It's a design philosophy, and one that the market does not always reward. I suspect that for many, it is either not salient, or unimportant. Design is subjective, and multi-dimensional.

Thank you, Don for seeing and writing about this dimension.

https://news.ycombinator.com/item?id=33527618

DonHopkins on Nov 9, 2022 | parent | context | favorite | on: The influence of Self

I wrote this in a discussion with Tom Lord in 2006 (a couple years before Lars Bak developed V8 at Google), after I ran into Dave when he was interviewing at Laszlo Systems, and he showed a demo of his latest Self system:

>I just ran into Dave Ungar (of Self fame), and mentioned how ironic it was that JavaScript pointed to Self as its inspirational prototype (vis-a-vis JavaScript's prototype based object system), but JavaScript totally missed the boat on efficient compile-ability, which is the most interesting thing about Self. (I mean, anybody can make a prototype oop system that runs slow, but it takes a fucking genius to come up all the brilliant stuff in Self, like the aggressive inlining compiler (it has no byte code interpreter, just a bad-ass compiler), incremental compilation, polymorphic inline cache, coupled with dynamic de-optimization to make it debuggable). He gave a cool Self demo of writing a straightforward factorial function, then editing the source to the system's multiplication operator, so it would return a different result if you multiplied something by 1,000,000. Then he showed how it affected the factorial function, as well as the rest of the system, which incrementally recompiled itself as needed. All that and perfect debuggability, too! About JavaScript, he retorted that it was actually possible to efficiently compile JavaScript if you were really devious enough. Too bad the art of designing languages so you don't have to be devious in order to compile them, was lost of so many popular bad language designers (PHP, JavaScript, Perl, etc).

https://en.wikipedia.org/wiki/V8_(JavaScript_engine)