RacketCon Is Saturday (con.racket-lang.org)

Aye--even if you've reached the point of thinking that the only role of a human is to feed good ideas into the machine, language is a thing that shapes thought--Lisp as a family is a thing different enough from a lang wanting to be a better C/C++ or a better Java that getting your brain thinking in terms of it can help you produce a different set of ideas (some of which may even be good ones). For me personally, it's really opened my mind to functional programming and intelligent use of recursion, in a way that I probably wouldn't have ever had cause to consider if I only ever concerned myself with the minimally convergent set of standard business langs, in the way that all our legacy code had been using them.

Of course, Lisps also seem to have the property of attracting people who genuinely like the practice of programming and, if it clicks with you, it has the property of generally leaving you really excited to write more of it. If you're hauling up and spending real American dollars to spend a weekend packed in a hall full of nerds to chat about a niche programming language, you're probably in that group. Consequent to that, it'd be a mighty small-minded thing to wonder what the point of joy is, when you could just be managing an agent swarm to write more enterprise Go code.

> To add to this, I definitely wouldn't say we've converged on a set of languages in general either!

Absolutely agree. I’d take a guess that a decent chunk, if not majority of “business” applications probably still exist in either Django or Spring Boot. Should all of those be rewritten now “just ‘cause”?

OP is apparently working on a new language and would like some assurance that someone out there might take an interest in it someday. That doesn't sound unreasonable to me.

Yes. And Bash/Shell (surprising to me). Take a look at the 2026 Stack Overflow Developer Survey (Ignoring SQL, HTML, Java, C*, etc):

https://survey.stackoverflow.co/2026/technology/data/languag...

"Which programming, scripting, and markup languages have you done extensive development work in over the past year, which do you want to work with over the next year, and which have you used AI tools or AI agents to work with? Select all that apply in each row."

For "which have you used AI tools or AI agents to work with", Rust and Go were only selected by ~11% of respondents. Whereas the usual functional languages were at ~1% or ~2%. I'd say the OP has a good point, but there is far less Rust and Go development with AI than he supposes.

             Respondents 
                    Percent

  JavaScript 5,419  38.4%
  Python     5,495  39.0%
  Bash/Shell 4,038  28.6%
  TypeScript 4,293  30.4%

  Rust       1,602  11.4%
  Go         1,524  10.8%

  Lisp         133   0.9%
  Elixir       257   1.8%
  Haskell      127   0.9%
  Scala        199   1.4%
  OCaml         96   0.7%

  Java  2,052  14.6%
  C#    2,277  16.2%
  C++   1,595  11.3%
  C     1,120   7.9%

I explicitly asked LLM to write abstract away with a DSL and it did that. LLMs are good at this too.

I'd imagine they would require some hands-on guidance to create more meaningful abstractions and DSLs for humans.

Call it "vibe coding by tiller". Ha.

Also, I think of metalinguistic abstraction as something deeper than macros. At least not limited to macros:

"An important advantage of making the evaluator accessible as a Lisp program is that we can implement alternative evaluation rules by describing these as modifications to the evaluator program."

https://sarabander.github.io/sicp/html/Chapter-4.xhtml

It's a common way to implement OO in Lisp-y languages. 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)

  (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)

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

I want to point out that the order is flexible, as in all things Lisp.

SICP, for instance, uses 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))

and then,

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

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

Very interesting! Nice to see the postgresql store.

Thank you!

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