1. 27
  1.  

  2. 3

    A personal take on Dan Ingalls’ statement and the reason why it did not materialize is that some effect akin to linguistic relativity may be a real thing on computer science and no language covers every problem domain with exactly the same conciseness and effectiveness.

    I would pretty much like to see a Smalltalk-like environment where (1) object instances could run asynchronously by default and (2) particular classes or methods could be implemented in different languages.

    That is pretty much feasible, but not a reality yet. The next best thing to that are Unix environments.

    1. 2

      Smalltalk on graalvm should be pretty close?

      https://www.javaadvent.com/2019/12/smalltalk-with-the-graalvm.html

      Another take would be Gemstone/S - it runs smalltalk on the (object database) server, but AFAIK it’s possible to interact via java apis too ?

      https://gemtalksystems.com/products/gs64/

      https://gemtalksystems.com/products/gbj/

      They also made the maglev ruby vm - for ruby on gemstone - but I think the project is dead? http://maglev.github.io/

      1. 2

        From what I could understand, those are mostly language implementations over a common VM—please correct me if I’m wrong. What I really meant is an environment where an object could be implemented in, say, a Pascal-like language and another in a LISP, and they would still be able to talk to each other. Or, even further than that, different methods of a same object are implemented in different languages.

        1. 3

          The graalvm sort of does this with native compilation and talk across languages (calling Java and c from smalltalk, for example). Gemstone is more a single vm that allows in station of objects from different languages.

          Ed: graal and truffle together, from the link:

          Just like all other GraalVM languages, GraalSqueak provides a Polyglot API for evaluating code of other languages and for sharing data and objects between them. What’s interesting here is that you can even interact with something like Javascript’s Math module and invoke its min function with arguments from Smalltalk and Python. Additionally, the base language of our PolyglotWorkspace can be changed via its context menu. This means the tool can also be used in the same way for all other languages supported by the underlying GraalVM.

          1. 2

            Interesting. I wonder if integration with the system browser would be too hard, along with some form of annotation to individual methods in order to allow them to be implemented in different languages.

            1. 2

              You mean the smalltalk browser? The video displays browsing python objects in the browser.

              1. 2

                I watched two videos, one where code was interpreted in a workspace, another of a Jupyter-like notebook with support to several languages (very cool, btw). I will ckeck the other videos, thanks.

      2. 2

        Concern #1 is handled by io, but io is pretty dead unfortunately. It’s a shame: I found it a lot easier to pick up & use than smalltalk.

        1. 2

          I never played with io. How does it compare to Smalltalk (or even to an Unix system) interaction-wise?

          1. 4

            Like Smalltalk, it’s very much centered around passing messages between objects as its primary metaphor. It has a prototype object system, and a decent REPL. Spawning a coroutine is a matter of adding a single character to an object name in order to make the message passing async.

            Unfortunately, I ran into some weird behavior with regard to this – io tries to figure out whether or not all coroutines will terminate by analyzing branching, but some of my code had false positives & exited early.