RacketCon Is Saturday | Hacker News Reader

RacketCon Is Saturday

con.racket-lang.org

158 pointsspdegabrielle49 comments

For the curious, there is an official YouTube channel with the previous editions https://www.youtube.com/@racketlang/playlists (It usually take a few months until the videos are edited and uploaded.)

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

Prototype is in Racket.

Yo! this is cool. I've been doing an interpreted lisp written in OCaml. pricklypear.rocks. https://github.com/sroerick/pricklypear . we are doing cactus driven development. I'll reach out. Would love to compare notes.

Very interesting! Nice to see the postgresql store.

Thank you!

I used ai liberally to write an s-expr language that compiles to c#.

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.

This is cool! Thank you! I'm a fan of C# and dotnet. Nice that you used F#!

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.

If I remember correctly MSIL has the necessary support.

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.

I am pretty sure dotnet doesn't allow any kind of fun (or "tampering" as they call it) with the stack, as a security precaution.

Depends how the MSIL bytecodes are used, and as long as it is done in a way that the verifier is happy, it goes.

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.

After some research I stand corrected, apparently only partial support is possible.

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.

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.

quite elegant, feels like a great balance idiomatic scheme and OO

Thanks for checking it out!

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

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

you lost me at the receiver selector order.

It's a common way to implement OO in Lisp-y languages, and it fits if you're taking Smalltalk as an inspiration. SICP has an example in chapter 3 (IIRC) of doing the same, but the selector had to be quoted as in:

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

Uses an internal lambda for dispatching on messages.

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)

Each call to make-account sets up an environment with a local state variable balance. Within this environment, make-account defines procedures deposit and withdraw that access balance and an additional procedure dispatch that takes a “message” as input and returns one of the two local procedures. The dispatch procedure itself is returned as the value that represents the bank-account object. This is precisely the message-passing style of programming that we saw in 2.4.3, although here we are using it in conjunction with the ability to modify local variables.

3.1.1 Local State Variables

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

A closure, specifically, because closures are a poor man's object.

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

You fool! Objects are a poor man’s closures!

Yup!

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

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

That is what allows multi-dispatch and all the goodies in The Art of Metaobject Protocol (CLOS).

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.

Cool project, thank you for sharing. I've been thinking about something similar lately.

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

RacketCon is Saturday https://con.racket-lang.org

[paraphrased:]

I'm curious: as a fan of Elixir and a language designer myself, what is the value of Racket and other esoteric languages, today, as (industry?) coalesces around AI tools and certain popular languages?

--------------------------

I think the Lisp family of languages are still the productivity boost they always were, especially with a good REPL. They can be as fast and safe as Rust and more expressive than JavaScript doing front end work. The deep support for macros and more really let you mold a program to fit the problem domain. Frontier models are reported to work as effectively with Lisp as any other language, and you can have much more succinct (token efficient) code while having more meaningful abstractions for readability by humans. I expect the two should go very well together. Plus you're dealing with a single language without the complexity of something like Rust or inconsistencies of JavaScript.

Reply on news.ycombinator.com