Were you using IBM Visual Age Smalltalk?

ALOE = Scheme + Smalltalk + Types

https://github.com/dharmatech/2026-09-02-aloe-racket

Prototype is in Racket.

Thank you!

https://bjolang.koketteriet.se/

It uses local HM inference and traits instead of OO, and the concurrency is based on concurrentML. The design process was mostly about what I dont like about other languages and what I think racket and OCaml does correctly. All default data structures are immutable (using an RRB tree, a champ, b+trees and linked lists) with pretty fast implementations.

Speed wise it is about the same as c# without spans and ref structs, since that is what it compiles to.

Every function that touches IO is compiles in a sync and async variant, so writing "bjoroutines" is most of the time the same as writing regular code.

The GitHub page is borked, since they removed Org mode support a day ago, but the manual and reference can be found on the web page.

The colour situation is ok, but us still a bit rough wrt higher order functions.

https://news.microsoft.com/source/2001/10/22/massive-industr...

I am not around the MSFT Partner CDs with the .NET Framework 1.0 release, however I remember there was a Scheme compiler as part of the original samples.

So maybe target MSIL directly.

For delimited continuations I only managed to find mostly extremely inefficient ways of doing it. CPS transformations on dotnet are, at least if kept to be useful as delcc, slow as molasses.

Which is ultimately why I chose to compile to c# to use asyncmethodbuilder do do the state machine translation for me.

https://www.jot.fm/issues/issue_2004_10/article4

I thought otherwise given my recollection of the samples, and that the platform supports C++, thus quite flexible on the opcodes.

Now I am generating two bodies for every defun that touches any suspending function, using asyncmethodbuilder, meaning I don't get any of the runtimeasync benefits coming in dotnet11.

Hopefully they'll give us a new asyncmethodbuilder that is somewhat more constrained but guarantees runtime async.

Here's a video demo of the code completion in vscode:

https://www.youtube.com/watch?v=YuIjug7elPY

  (my-account 'balance)
  (my-account 'withdraw 10)

We can also create objects that handle deposits as well as withdrawals, and thus we can represent simple bank accounts. Here is a procedure that returns a “bank-account object” with a specified initial balance:

  (define (make-account balance)
    (define (withdraw amount)
      (if (>= balance amount)
          (begin (set! balance 
                       (- balance amount))
                 balance)
          "Insufficient funds"))
    (define (deposit amount)
      (set! balance (+ balance amount))
      balance)
    (define (dispatch m)
      (cond ((eq? m 'withdraw) withdraw)
            ((eq? m 'deposit) deposit)
            (else (error "Unknown request: 
                   MAKE-ACCOUNT" m))))
    dispatch)

3.1.1 Local State Variables

https://sarabander.github.io/sicp/html/3_002e1.xhtml#g_t3_00...

https://wiki.c2.com/?ClosuresAndObjectsAreEquivalent

Closures indeed! A key concept of Scheme that distinguished it from most Lisps at the time:

(LAMBDA ( <identifier list> ) <body> )

Lambda-expressions evaluate to procedures. Unlike most LISP systems, SCHEME does not consider a lambda-expression (an s-expression whose car is the atom LAMBDA) to be a procedure. A lambda-expression only evaluates to a procedure. A lambda-expression should be thought of as a partial description of a procedure; a procedure and a description of it are conceptually distinct objects. A lambda-expression must be “closed” (associated with an environment) to produce a procedure object. Evaluation of a lambda-expression performs such a closure operation.

The resulting procedure takes as many arguments as there are identifiers in the identifier list of the lambda-expression. When the procedure is eventually invoked, the intuitive effect is that the evaluation of the procedure call is equivalent to the evaluation of the <body> in an environment consisting of (a) the environment in which the lambda-expression had been evaluated to produce the procedure, plus (b) the pairing of the identifiers of the <identifier list> with the arguments supplied to the procedure. The pairings (b) take precedence over the environment (a), and to prevent confusion no identifier may appear twice in the <identifier list>. The net effect is to implement ALGOL-style lexical scoping [Naur], and to “solve the funarg problem” [Moses].

THE REVISED REPORT ON SCHEME: A DIALECT OF LISP

B.1. Kernel Magic Forms

https://research.scheme.org/lambda-papers/lambda-papers-revi...

Moar:

3.2 The Environment Model of Evaluation

https://sarabander.github.io/sicp/html/3_002e2.xhtml#g_t3_00...

Here's a video demo of the code completion in vscode:

https://www.youtube.com/watch?v=YuIjug7elPY

You can exchange the order, like on Dylan and Julia, however note how both declare them as if they were regular functions in non-OOP languages.

In SICP, for instance, they use a lot of utility functions to change it for readability sake:

  (define (make-register name)
    (let ((contents '*unassigned*))
      (define (dispatch message)
        (cond ((eq? message 'get) contents)
              ((eq? message 'set)
               (lambda (value) 
                 (set! contents value)))
              (else
               (error "Unknown request: 
                       REGISTER"
                      message))))
      dispatch))

  (define (get-contents register)
    (register 'get))

  (define (set-contents! register value)
    ((register 'set) value))

However. "Send, not apply" - sigh.. how shall I put it.. let's try this - eyes_rolling_so_hard_they_fall_out_of_sockets.png

I've been messing around with a language that I summarize as:

ALOE = Scheme + Smalltalk + Types

https://github.com/dharmatech/2026-09-02-aloe-racket

One of the examples is a very basic computer algebra simplifier:

https://github.com/dharmatech/2026-09-02-aloe-racket/blob/ma...

That simplifier is based on a computer algebra library in Scheme:

https://github.com/dharmatech/mpl

I see you're with PLT. :-)

Since Racket is built on Chez, you might like this. It's an Emacs-like editor built in Chez Scheme:

https://github.com/paveluv/e

I've been messing around with a language that I summarize as:

ALOE = Scheme + Smalltalk + Types

Boids implementation:

https://github.com/dharmatech/2026-09-02-aloe-racket/blob/ma...

https://github.com/dharmatech/2026-09-02-aloe-racket

https://github.com/tqbf/casette

https://github.com/nooga/let-go

Fun fact. It also runs on plan9:

https://github.com/nooga/legmacs/issues/1

Thank you for checking it out! Fair warning, it's vibeslop and I really don't have a clue what I'm doing. I have very little background in compilers or FP or really anything. I'm honestly just shocked at how well it works.

If you want to kick the tires on it or even if you just find it interesting, please feel free to reach out! I'm kind of obsessed with this thing now, and would love and appreciate any feedback

For me, avoiding high histamine foods as well as histamine liberators had helped tremendously.

The theory:

Anti-histamines like Benadryl make you sleepy by blocking histamine.

Well, instead of blocking the histamine, get rid of it in the first place by avoiding histamine foods (for example aged or preserved meats).

The brain histamine in your neurons is primarily synthesized from an amino acid. The histamine levels in neurons are different than the levels in mast cells.

There are a lot of degrees of hand waving in your theory that don’t work.

I definitely haven't looked into the underlying models of histamine to see how things work.

My observation is that, when I avoid histamine related foods, I sleep longer and fall asleep faster. The naive model is what led me to try that. But I totally acknowledge that there's likely way more at play under the hood. And I would like to know more about why this works! Or, at least why it works for me.

Thank you for pointing out the complexity of the underlying mechanism.

Any demos available of the web based browser?