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.
Thank you. The only thing I really miss in c#/dotnet are delimited continuations. That would have made it possible to have proper effect handlers (now they are only tail resumptive, meaning it can only mock things like file system access and so on) and remove colour from the language entirely.
The colour situation is ok, but us still a bit rough wrt higher order functions.
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.
I am curious how. I thought quite a lot about targeting MSIL, but i found no way of copying, capturing or slicing the call stack. Nor is it possible to reify even the whole stack as a first class object.
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.
In many ways I feel I should have targetted OCaml instead, since I would have gotten a full effect handler system and delimited continuations for free.
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.
dharmatech · · focus · HN ↗
ALOE = Scheme + Smalltalk + Types
<a href="https://github.com/dharmatech/2026-09-02-aloe-racket" rel="nofollow">https://github.com/dharmatech/2026-09-02-aloe-racket
Prototype is in Racket.
bjoli · · focus · HN ↗
<a href="https://bjolang.koketteriet.se/" rel="nofollow">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.
dharmatech · · focus · HN ↗
bjoli · · focus · HN ↗
The colour situation is ok, but us still a bit rough wrt higher order functions.
pjmlp · · focus · HN ↗
<a href="https://news.microsoft.com/source/2001/10/22/massive-industry-and-developer-support-for-microsoft-net-on-display-at-professional-developers-conference-2001" rel="nofollow">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.
bjoli · · focus · HN ↗
pjmlp · · focus · HN ↗
bjoli · · focus · HN ↗
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.
pjmlp · · focus · HN ↗
<a href="https://www.jot.fm/issues/issue_2004_10/article4" rel="nofollow">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.
bjoli · · focus · HN ↗
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.