Rhombus Language 1.0 | Hacker News Reader

Rhombus Language 1.0

blog.racket-lang.org

234 pointsDecabytes113 comments

I’ve written a little library Rhombus.

I think my favorite thing is the `…` operator. Go check it out. It’s not like the splat operator in other languages, though it does give that feel initially. It’s much more general: it works with nested data structures and can take the place of a `map` operation.

The best part of `…` is that it is not a built-in thing—it’s just a macro! The magic is that Rhombus lets you define different macros depending on whether or not the macro identifier appears in binding context (left side of `=`), expression context, or some other contexts. IIRC you can even define your own contexts too.

Rhombus takes the best-in-class macro system of Racket and somehow finds a way to improve upon it. I say this after researching and comparing detailed metaprogramming features across a dozen different languages. Rhombus is a very neat little language.

Last thing: Rhombus’ main data type, the list, is implemented with an RRB tree. RRB trees support structural sharing, functional updates, and have O(log n) iterate, insert, delete, append, and arbitrary read operations. The constant factor on that is tiny: I think it’s like log_16 or log_32. They’re designed to be very cache friendly. Super cool data structure.

> I say this after researching and comparing detailed metaprogramming features across a dozen different languages.

I’m very interested in this. What was your research approach? Are there resources you can recommend beyond the documentation for individual languages?

Here's the paper I wrote: https://lambdaland.org/files/2024_ecoop_type_tailoring.pdf

Lots and lots of documentation, some experimentation, and asking people. :)

Thanks!

Finally someone uses the rrb tree as their main data structure! I implemented it for c# and the performance tradeoff compared to List<> was smaller than i had thought.

https://github.com/bjoli/RrbList/tree/main/src/Collections

Interesting.

Just a little nitpick on the repo root: "This is not the readme you want, Please go to the src directory." => But there is no readme in src directory

Thanks! I havet always been linking to the Collections subdir so I have missed this dumb issue. Will fix next time I use a computer. Might be some time though.

If you have any questions about the trees, feel free to ask.

> I think my favorite thing is the `…` operator. Go check it out.

I appreciate your enthusiasm. But three dots are really hard to google. Can you provide a link?

Some info here: https://docs.racket-lang.org/rhombus-reference/Repetitions.h...

That's both extremely neat and, for the time being, extremely hard for me to get my head around. I got it round monads, so I imagine it's just a matter of time!

> I think my favorite thing is the `…` operator. Go check it out. It’s not like the splat operator in other languages, though it does give that feel initially. It’s much more general: it works with nested data structures and can take the place of a `map` operation.

Something akin to `destructuring-bind' in Common Lisp?

I was not very involved in this. I still prefer s-expressions.

Anyway, my main initial concern was how to make good macros without s-expressions. There is a nice video by Matthew Flatt in RacketCon 2023. The first 6 minutes and 20 seconds are internal stuff, so skip to the 380s that I added in this link: https://www.youtube.com/watch?v=OLgEL4esYU0&t=380s He takes like another 6 minutes to explain the general idea and make some wishes, and then at the 12m mark he defines macros in Rhombus and makes the wish real in just 2m (with some enhancements later).

I mean, M-expression was proposed right from the start.

Then there is nothing special about having the brackets around. To start with, text can be just as readable:

    ( + 1 2 ) 
    do plus 1 2 go

And one can use stack base syntax, or define a static default arity to infix notation, example two, so `times plus 1 2 3` is not ambiguous and is really clearly like (1+2)*3 with such a convention. Then you can shift arity with reserved word so `unary plus 1` is like `+1` or `arity 5 action one two three four`, or going back to explicit marker like `(` and `)` or `do` and `go` to group stuffs without explicitly quantified numbering.

Related. Others?

Summer Rhombus picture competition 2026 - https://news.ycombinator.com/item?id=48546270 - June 2026 (2 comments)

Rhombus Language - https://news.ycombinator.com/item?id=43394881 - March 2025 (158 comments)

Rhombus: Macro-extensible language with conventional syntax built on Racket - https://news.ycombinator.com/item?id=41151439 - Aug 2024 (97 comments)

State of Rhombus (programming language) - https://news.ycombinator.com/item?id=30314109 - Feb 2022 (17 comments)

Feedback:

"Modern programming languages reflect a consensus on the most important programming concepts, including lexically scoped variables, closures, objects, pattern matching, and type parametricity. Why, then, yet another programming language?"

I love this as a start. More programming languages need to start the conversation this way.

However, it whiffs after this when it fails to answer the question. Or at least fails to answer it in a way I understand. The next paragraph should not start with "Beyond the basics, there are still more good ideas for programming constructs than can fit in any one language specification." - cut straight to what the "programming constructs" are.

This section ends with "approachable" and "extensible". These are nothing. When considering the reasons for a language, look at the negation. Nobody writes a language to be "unapproachable"... well, unless you're on the esolang wiki, but that's not really what we're talking about here. Nobody really wants to stick "non-extensible" on their language either... where we all disagree is in the how one extends things. As someone reading this screen to decide if I'm interested these attributes mean nothing to me.

The page does get around to making it clear that there is a huge focus on macros, which is something, but it takes a while to get there.

That's a legitimate selling point. It's especially a selling point if you can explain clearly how this is different from just using Scheme directly. I have no idea if your language does this but I've long thought that it would be interesting to have a macro-focused language that went all-in on making them debuggable. Have the language compiler and runtime support dynamically exploring them, expanding them in your editor, re-contracting them, full debugging support, just go all-in on supporting that work flow. That would be an example of that sort of thing.

Welcome to the Racket stepper: https://docs.racket-lang.org/stepper/

...and the Racket syntax-parse macro system: https://docs.racket-lang.org/syntax/stxparse.html

> When considering the reasons for a language, look at the negation. Nobody writes a language to be "unapproachable"… Nobody really wants to stick "non-extensible" on their language…

And yet, unapproachable languages and non-extensible languages exist. More specifically, there are languages where approachability and extensibility formed no part of the design goals and it shows.

I'm coming from Go, so apologies in advance if these questions seem a little weird:

How do I distribute my Rhombus programs? Can I cross compile to other architectures/OSs, ideally with a static binary?

What about libraries? Is there a good package manager? I presume from the post that the library ecosystem is pretty immature (maybe the Racket ecosystem is larger). Can I easily build a CRUD web app?

Is concurrency easy to make correct? Are tests easy to write? Tests involving concurrency? Race detection?

Dev experience: is it statically typed? I couldn't really tell from a quick search. Will the build system make a fast feedback loop for me and LLMs? Is it IDE friendly (auto complete, find all references, etc)? Is there language server support so I can bring my own editor? Will the macros mean I have to learn a bunch of DSLs to use anyone's library? Do the DSLs have IDE support?

Wow that's a lot of questions ;) It looks like a fun language in any case. And the fact that its even possible to make a Pythonic language on top of a LISP is its own showcase for Racket's power

> How do I distribute my Rhombus programs? Can I cross compile to other architectures/OSs, ideally with a static binary?

You can compile them inside DrRacket and distribute the .exe or equivalent. I used that a few times to send programs written in Racket to coworkers that are not programmers (remember to add an icon so it looks professional).

You can use the command line too, and it support cross compiling, but I never used it https://docs.racket-lang.org/raco-cross/index.html

> What about libraries? Is there a good package manager? I presume from the post that the library ecosystem is pretty immature (maybe the Racket ecosystem is larger).

Some libraries have been ported to make them more idiomatic, in particular changing the name of the functions and fixing the different meaning of "list". Anyway, you can import any library of Racket from Rhombus and vice versa https://docs.racket-lang.org/rhombus-guide/Modules.html

> Can I easily build a CRUD web app?

Sorry, I never tried.

> Dev experience: is it statically typed? I couldn't really tell from a quick search.

It's optional. You can add statically types when you want and the code will be more efficient and get compile time errors. Or avoid them and get run time error.

> Will the build system make a fast feedback loop for me and LLMs?

Sorry, I never tried.

> Is it IDE friendly (auto complete, find all references, etc)? Is there language server support so I can bring my own editor?

auto complete: no (I think)

find all references: yes

> Will the macros mean I have to learn a bunch of DSLs to use anyone's library? Do the DSLs have IDE support?

Most macros try to blend with the language and be invisible, but it's possible to write weird and bad macros too. Most libraries should not define weird macros.

Anyway, some internal parts of Racket like `for` or `match` are implemented in Racket and are like two complete DSLs on their own.

Thank you! I appreciate your taking the time to reply

>>> Is there a good package manager?

I forgot this one. https://pkgs.racket-lang.org/

Many of them are in the "main distribution" that is what is installed by default. Most packages only include the bindings for Racket, but as I said before they can be used from Rhombus too. I expect people to slowly add the bindings for Rhombus.

You can read about Shrubbery, just adding the Rhombus syntax in Racket:

https://docs.racket-lang.org/shrubbery/index.html

What with the term itself, is that some monthy python reference or related to tree algebraic structure?

Matthew Flatt picked “shrubbery” because it’s tree-like but not fully expanded, so it tends to be more broad/flat than deep like a tree. Hence also the term “enforrestation” when you fully expanded it.

I think the Monty Python reference is just a happy coincidence.

Nice to get so much insightful feedbacks. That's the kind of exchange that make HN still sometime interesting.

The knights who say Ni demand a shrubbery.

More like the Knights who say Nil

Once you have a bicameral syntax*, is there much point left in formal language theory? For instance, why would you still need complicated notions like LR(k) grammars (which Wikipedia confuses with LR(k) parsers)? I ask out of genuine confusion: I've been reading about formal grammars, and have even added to Wikipedia - but I'm still puzzled as to why PL designers might choose to have hard-to-parse syntaxes. Why don't people instead adopt an intermediate syntax like Rhombus's shrubbery notation†?

* - https://parentheticallyspeaking.org/articles/bicameral-not-h...

† - https://docs.racket-lang.org/shrubbery/index.html?fam=Rhombu...

I'd love to get a talk on this at the 2027 Carolina Code Conference (polyglot and cybersecurity). Call for Speakers will open in January.

https://carolina.codes

Looks like a real conference - but the first thing you see is a large image of Rick Astley ?!

We do a "Lyrical Code" T-shirt where people submit song lyrics as code in their favorite language and then we pull verses from different languages to make a polyglot t-shirt. Last year at the conference, attendees voted for Never Gonna Give You Up as this year's song.

2023 - Don't Stop Believing

https://github.com/brightball/carolina-code-conf-lyrical-cha...

2024 - Bohemian Rhapsody

https://github.com/brightball/carolina-code-conf-lyrical-cha...

2025 - All Star

https://github.com/brightball/carolina-code-conf-lyrical-cha...

You can see the final version of the shirt here.

https://blog.carolina.codes/i/148154944/youre-an-all-star

We're a little low on PR's this year unfortunately though. I don't know if it's all the AI or something else but we usually have about a dozen entries by now and we've only got 2 for some reason this year.

Rhombus is designed to be

* approachable and easy to use for everyday purposes, with a readable indentation syntax; and

* uniquely customisable with an _open-compiler API_ that is accessible to a wide audience.

Racket is already approachable and easy to use for everyday purposes

A lot of people hate sexprs. Even seemingly reasonable folks.

I imagined they have met students that really struggle with the syntax, while grokking the concepts easily.

I myself have heard "the parentheses are hard to balance" and "after a while you dont even see the parentheses" enough times that I think maybe both can be correct.

My editor balances my parentheses (Emacs Paredit). I rarely think about them. I just think structurally and the editor manages the details.

It really feels like, "when I move through the wasteland, I only focus on the path and GPS is guiding me well".

For some reasons, people tend to prefer having a walk in a forest rather than in z wasteland.

Look, if you’re committed to Blub, don’t let me talk you out of it.

> when I move through the wasteland

You got that exactly backwards. A non-lisper unavoidably has to deal with tons of syntactic and semantic clues - parens, colons & semicolons, square brackets, indentation & white-space, special chars, static type annotations, lsp servers and tree-sitter parsers. Lisp only needs two things - a [small] set of structural idioms, and a live REPL.

> A lot of people hate sexprs

In all my time I have never come across a single Lisper, neither in person nor online, and I know far more than a few dozens, who once grokked the REPL-driven workflow and the structural editing idioms only to later, for whatever reason, suddenly start disliking or even hating s-expressions.

All that so-called "hatred" stems from unfamiliarity. People fuss about Lisps lacking static types, without a single clue about how a "true" REPL trades them off for something different. They compare it to a Python or C# REPL and think "it ain't a big deal". Well, the Lisp REPL is quite different, and yes, a major deal - every single part of the Read-Eval-Print-Loop differs. They complain about "hard to deal with parentheses" and "I can't refactor without types" while having no clue how amazingly nice structural editing is in practice, that you never even think about parens - you only see structure, order and reason.

well, i guess i know what the grandparent was talking about when they said 'I myself have heard [...] "after a while you dont even see the parentheses" enough times [...]'. Thanks for the example.

As I said, i think they have been teaching long enough to have a pretty good basis for the claim that racket's syntax can be a problem.

I am firmly in the "after a while you don't see the parentheses" camp, but I have a friend who I respect a lot who works in clojure (with Emacs/cider/paredit) that just doesn't like it.

I mean, I prefer sexprs above all other syntaxes, and I have had people tell me I just need to get used to indentation syntax or whatever they fancy.

> In all my time I have never come across a single Lisper, neither in person nor online, and I know far more than a few dozens, who once grokked the REPL-driven workflow and the structural editing idioms only to later, for whatever reason, suddenly start disliking or even hating s-expressions.

And we've never seen bullet holes in these parts of the plane, so there's no point putting armour there.

It's not about survivorship bias, it's about notation. It's like "hating Leibniz's dy/dx because Newton's dot notation already exists" and I'm arguing that people don't just "hate the notation", they simply misunderstand the principles of calculus. I'm not saying that notation preferences don't have consequences, but in this case, I've seen far too often the evidence that programmers ignore the underlying ideas outright, simply because they didn't like the notation on first sight.

> It's not about survivorship bias, it's about notation. It's like "hating Leibniz's dy/dx because Newton's dot notation already exists" and I'm arguing that people don't just "hate the notation", they simply misunderstand the principles of calculus.

Ok but where is the dot notation? If this is the only notation available for those ideas, how can you be sure that it's the ideas that are the problem and not the notation?

> I've seen far too often the evidence that programmers ignore the underlying ideas outright, simply because they didn't like the notation on first sight.

Then why are you opposed to people presenting the ideas with different notation, if the ideas are what you think is valuable?

> why are you opposed to people presenting the ideas with different notation

What are you talking about? I'm not opposed to anything, I don't know where that conclusion comes from. I'm just trying to explain why people hate s-expressions. Because of the unfamiliarity. I remember the time before I convinced myself to give Lisp a try - I'd look at it with all my previous knowledge of other programming languages and just didn't see it. I thought it was "unreadable", "weird", and had no merits in the "modern" world of computing. I was convinced that Lisp is archaic and there's no practical reason to use it. I was wrong on all counts. Learning Lisp and using it in real projects made me appreciate programming more, it taught me things that I haven't imagined before, my only regret that I didn't do it sooner.

> I'm not opposed to anything, I don't know where that conclusion comes from. I'm just trying to explain why people hate s-expressions.

You seemed to be implicitly claiming that there was no point presenting the ideas with a different syntax.

You're making very strident claims based on very little evidence. Maybe you're right, but I think we should at least entertain the possibility that people who think they hate s-expressions actually do hate s-expressions - which would be an ample explanation for why those people never got into Lisp.

I expanded on it here https://news.ycombinator.com/item?id=48689592

This is survivorship bias. People who don't like s-expr aren't lispers.

I've used Lisp before. I can read s-expr code. Unfamiliarity is not the issue. I just don't like them. I don't like Haskell/ML either, and I've written large projects in both, so it's not a Lisp-specific thing.

Considering your experience and preferences, what do you like?

No answer from the OC - I suppose they just hate everything :) I guess, with enough experience you kind of start disliking every single motherfucking PL. I don't hate programming languages, but gosh, some code I've seen - I just can't help it but I wish to talk to whoever wrote that piece and ask them: "were you okay when you did that?".

> I just don't like them

That is what I don't get. I have used many different languages, and often is not the syntax that I don't like - I may dislike the semantics, the runtime, the tooling, but syntax, really how? It's like "I hate Greek alphabet", even though this is a weird comparison - alphabet is a flat bag of arbitrary symbols with no structural role, so disliking it sounds incoherent by construction. I just can't ever get over "s-expressions hate", in such a way like: "What are you even talking about? There's practically zero syntax in Lisp."

That's precisely the issue: there is only one syntactic form. Everything blends together and ends up looking the same. It makes my eyes hurt.

I have quite the opposite effect. I don't "hate" programming languages, but honestly, sometimes I don't understand how the fuck we (people) managed to build layers and layers of complexity (both syntactic and semantic) for things that can be concisely and simply explained as simple Lisp forms.

I get bonkers hysterical laughs sometimes, grabbing a piece of Java, Typescript or Python and asking an LLM how a similar code would look in Clojure. That doesn't universally yield "better" results; sometimes, the code may look certifiably more cryptic than the original - brute-forcing an algorithm into Lisp can look very terse, but that's up to the coder - I am capable of writing cryptic yet functioning code in any language.

This is your comment but with "zero syntax":

  I just don't like them

  That is what I dont get I have used many different languages. and often is not the syntax that I dont like . I may dislike the semantics. the runtime. the tooling. but syntax. really how. It.s like. I hate Greek alphabet. even though this is a weird comparison . alphabet is a flat bag of arbitrary symbols with no structural role. so disliking it sounds incoherent by construction. I just cant ever get over .sexpressions hate. in such a way like. What are you even talking about. Theres practically zero syntax in Lisp.

I can only think of the word disingenuous when I can see someone outright refusing the possible downsides of s-expressions (you probably meant zero syntax since it's still possible to have syntatic s-expressions.).

I never said s-expressions have no downsides, I merely tried to explain why I think people hate them. They do have downsides - diffing and merging and complex macros are good examples - but calling Lisp code outright "unreadable" is equally disingenuous. There are trade-offs, but they are not without benefits, and often the benefits do outweigh the cons. It's just sad that people choose to completely ignore them simply because they have visceral reaction to the unfamiliar visual structure.

> I never said s-expressions have no downsides

You didn't say it directly, but it's implied from what all you said in this thread, just as no one in this thread said "outright unreadable". Up until now, there's no acknowledgement of the downsides and you refuse to even understand the dissenting point of view. If you truly do acknowledge the downsides, you would (try to) understand why people "hate" it. But no, "people are too incoherent to not like the beautiful perfection of s-expressions" as the lines in between would say.

Look, it is very simple. Compare it to natural languages. Unfamiliarity with a language may evoke aversion and even hatred, yet anyone who reaches fluency in a foreign language just "magically" stops hating it. The language becomes a pragmatic tool to use, that's all. Some may argue, saying something like: "well, my friend who knows Russian says he hates it". You dig a little further and you discover that the friend hates Russian now because they were born in Ukraine, and before 2014 they had no issues with it. Turns out they don't really hate the language, do they? They don't hate phonology, morphology, syntax - they "hate" the culture, the idioms, the orthogonal stuff, right?

Save the time and resources spent on learning (let's for the sake of the argument imagine we get it for free), there are zero downsides to reaching fluency in a foreign language. Zero. Sure, one still may prefer reading Tolstoy, Bulgakov and Dostoevsky in English, even though they'd probably agree - to unveil the full gamut of emotions, it needs to be read in Russian, simply because there are tons of interesting twists of phrases that are just inconceivable to be translated precisely. Same can be said about English - James Joyce's puns and phonetic play just don't port well; Beckett's rhythmic English is delicate; Carroll's wordplay and Victorian logic-games in "Alice" are extremely English-specific.

Alas, learning a natural language to fluency may take a lifetime. That's why we don't go around screaming "Learn Spanish if you want to understand Borges, Márquez and Cortázar!". Yet at the same time, nobody in the right mind would ever join a discussion only to say "I hate Spanish, it's weird and hard to read".

And just like there are no downsides to acquiring a natural language (once again, let's say you get it free - ignore the time cost), there are really no big drawbacks to getting fluency in Lisp. It is universally better to know it (even if you don't use it every day) than not knowing it at all. Lisp teaches you that most syntax is noise. Once you internalize that, you write better code in any language because you're not cargo-culting idioms - you understand why they exist.

I'm not saying Lisp is universally better than the alternatives. I'm just saying that it has tremendous value, and the "haters" are just missing it out.

And just like I won't ever trust anyone claiming they dislike a language despite enormous fluency, I just can't see how anyone would know Lisp and yet just hate it. I stand by my words; the bias and hatred come from misunderstanding. I understand why programmers may dislike a specific PL - but Lisp is not a single programming language. It's an idea, the idea that influenced pretty much every single PL being used in the industry today. Like I dunno, how could anyone hate recursion, or closures, or pattern matching, or parametric polymorphism - these are just ideas, specific tools to use in specific context and situation. The only reason I see someone may hate them is because they have not gained sufficient understanding for how they work.

> Compare it to natural languages.

Assuming any such comparison is valid is purely speculative. There are significant differences.

> anyone who reaches fluency in a foreign language just "magically" stops hating it.

Not true (plenty of people learn Mandarin and regret doing so), and even if it were true it could just be survivorship bias - of course people who hate a language are less likely to become fluent in it.

> Turns out they don't really hate the language, do they? They don't hate phonology, morphology, syntax - they "hate" the culture, the idioms, the orthogonal stuff, right?

No, sometimes people really do hate the language.

> nobody in the right mind would ever join a discussion only to say "I hate Spanish, it's weird and hard to read".

That might not be a productive thing to say in a discussion, but that doesn't mean it can't be true.

> Like I dunno, how could anyone hate recursion, or closures, or pattern matching, or parametric polymorphism - these are just ideas, specific tools to use in specific context and situation.

Plenty of people hate any or all of those things. I'd say it's reasonable to hate a tool that tends to have bad consequences - e.g. a language feature that makes code superficially easier to write but hard to refactor or debug.

> Plenty of people hate any or all of those things.

Oh come on. You're flummoxed about things that are not controversial. You don't have to listen to some rando HN commenter like me - there isn't a line-up of renowned CS figures or prominent programmers who ever harshly criticized Lisp to absolute rejection, even Dijkstra. People expect him to have bashed Lisp, but he actually praised it (and not once): "Lisp has assisted a number of our most gifted fellow humans in thinking previously impossible thoughts." And there's a long line of well-known names from Alan Kay to Steele, Matz and Goetz, etc. who publicly said great things about the grand idea of Lisp. That is all well-documented and known. This isn't some "recorded history of the past", it's still going on - Clojure-like languages for different runtimes popping up every few months. Lisp isn't BASIC, Fortran or COBOL, yet some people waste so much energy to prove to themselves that it's somehow "wrong" or has "bad consequences", while Apple, Cisco, Netflix, Walmart, CircleCI, Nubank and many others have successfully built and maintained large projects. All the while so many "opposing" ideas quietly died over the years - Ada's intended universal dominance; anti-GC dogma; Algol 68 complexity-heavy direction (though Algol's good ideas lived on); rigid, ceremony-heavy, anti-interactive approaches consistently faded, while the dynamic/interactive/symbolic cluster that Lisp has pioneered keeps getting re-adopted.

What serious programmer ever ignores Lisp influence or importance? I suppose an ignorant one. I get it, plenty of serious programmers acknowledge the influence and still rationally choose not to use it, but outright rejecting the idea because it doesn't "visually appeal to them" - that is some naivete.

Whatever. You free to hold any beliefs - my actual, pragmatic, lived experience says otherwise.

> there's a long line of well-known names from Alan Kay to Steele, Matz and Goetz, etc. who publicly said great things about the grand idea of Lisp.

About the ideas, yes, helped by being such an early language that it can lay claim to being the originator of a great many things. About the syntax, rather fewer.

> Apple, Cisco, Netflix, Walmart, CircleCI, Nubank and many others have successfully built and maintained large projects

There are a great many success stories and just as many failure stories. 60+ years on, Lisp continues to exist but remains niche.

> rigid, ceremony-heavy, anti-interactive approaches consistently faded, while the dynamic/interactive/symbolic cluster that Lisp has pioneered keeps getting re-adopted.

Yes and no; the pendulum swings but the oscillations get smaller. At this point the programming world has pretty much converged on present-but-lightweight typing with inference and optional annotations, for example; there are no new serious pure dynamic languages being made, and all major dynamic languages are putting huge effort into retrofitting typing. Long edit-deploy-test cycles aren't coming back but nor is live-editing your production system.

> What serious programmer ever ignores Lisp influence or importance?

That's quite a different thing from saying that it's pleasant or even good. Every serious critic acknowledges that e.g. David Foster Wallace was influential and important, but many openly hate actually reading his work.

> actual, pragmatic, lived experience

Hardly. You've built this a whole edifice of beliefs that wouldn't withstand 5 minutes outside the Lisp bubble.

I love Lisps, ML-family languages, etc. Languages like Java or Go are just painful for me to program in, and I know I’m probably in the minority there.

But honestly, I think a lot of it comes down to the fact that syntax carries semantic expectations. Certain syntax makes you expect a certain model of programming: mutability, imperative control flow, objects everywhere, etc.

Gleam is a good counterexample. It has an ALGOL-ish syntax, but semantically it’s a functional language, and it’s wonderful to read/write.

Same with Ruby: the parts of Ruby that still make me smile are mostly the parts that feel Lisp-adjacent.

It’s kind of wild that we live in a world where, for most programmers, syntax seems to matter more than semantics.

> syntax carries semantic expectations

True! Syntax is a signaling system. Braces and semicolons signal the C-family, so you prepare for statements, mutation, sequential side effects, and objects. Parentheses-first signals Lisp, so you expect recursion and macros. Significant whitespace signals Python. Before you have read a single semantic line, the notation has already established a prior expectation. That is real, and most language discourse ignores it.

But syntax carries more than semantic expectations. It signals era, tribe, tooling, and aesthetics too. The paren signal says Clojure, CL, Emacs, REPL, niche, old-and-proud as loudly as it says functional. Some of the aversion to parentheses originates from sociological resistance to these signals rather than from semantic concerns. Yet honestly, grokking Lisp can make a true polyglot out of a coder. It did it for me. "A Lisper" is not always someone who writes and reads Lisp full-time. Fully fluent Lisper can rationally and successfully use any other PL syntax, because they understand the semantics, even though they'd actively try optimizing the connotation and ergonomics layer, a genuine separate axis.

I think if you believe that the aids types give for refactoring are equivalent to structural editing, then you are the one who might not get the value of typing information (I say this as a Python person, and am totally willing to accept lack of typing info in plenty of situations)

REPLs are nice and good, but when you're working on large enough systems it's nice to have some static foundations for your facts.

I don't "believe" things, I pragmatically choose the tools that work, the ideas that have merits. I did not say "refactoring is equivalent to structural editing", and I specifically talked about comparing Python REPL to Lisp's.

I don't lack experience working with type systems, I have used over a dozen different PLs, some of them were weirdly unusual - I once even had to program in a language with all operators in Russian.

> when you're working on large enough system

I have built and supported sufficiently large systems in various languages, and have seen firsthand the trade-offs Lisp systems can bring. The holistic experience of using Clojure often can beat systems with advanced static types, but you probably won't ever notice it, because you'd first demand something to "believe" in.

You guys (replying to the comment) seem to be convinced of my one-sided bias for defending s-expression syntax and dying for it. I'm defending it only because it gets bad rap from people unfamiliar with the merits. REPL-driven workflow, live image, structural editing, homoiconicity, code-as-data - none of these require the surface syntax to be parens and Rhombus is the living proof. Structural editing operates on any AST. The actual jewel is homoiconicity, and sadly it gets largely ignored by the majority of programmers today. S-expressions probably are the simplest form of syntax to operate homoiconic entities - the simplest notation that is at once a fully explicit tree and directly the language's own data structure. "I love homoiconicity" does not uniquely entail "I love parentheses", alas, programmers off the bat hate parentheses, often without even attempting to understand their significance - they think it's "aesthetic choice". They don't even for a second look around and get curious for why people keep making new Lisp dialects, 70 years on.

It's not unreasonable to dislike coding in s-expression syntax. It is not very readable.

There's a reason the vast majority of programming languages (especially weighted by popularity) use more traditional syntax.

> It is not very readable.

That holds true only for two cases:

- For a programmer who never learned Lisp as their first language. I have met people who learned Clojure as their very first PL and they said it was fun. Later there were utterly confused about Java, Python and Javascript. Going the opposite may feel confusing and identity-breaking.

- Reading static code. In a sense, it can be a bit harder to read a wall of Lisp, say printed on paper. Lispers typically don't inspect "dead code" like that; they'd connect to the live REPL and eval expressions on the go, programming it from "inside out". With experience, it becomes easier to scan the code and mentally parse it. Lisp at that point actually gets far more readable than any other PL. For instance, Lisp code is better suited for smaller screens of smartphones - the code wraps around yet retains its readability. Try that trick with literally any other language, I can 100% guarantee - most of them would look like a huge pile of indecipherable mess.

> For a programmer who never learned Lisp as their first language

Maybe. But I have never heard anyone say that Python is hard to read, and it's one of the most common complaints against Lisps. Just looking at them both it's hard to imagine how one could seriously believe that s-expressions are more readable. `(== a b)` is clearly worse than `a == b`. Even JavaScript programmers know that.

> they'd connect to the live REPL

Yeah I dunno this is the same cop-out Ruby programmers use to justify its lack of static typing. It's fundamentally better if you can understand code without having to run it.

> `(== a b)` is clearly worse than `a == b`

It's clearly worse just because it moved from infix to prefix and is wrapped by parens? Is `(* (+ a b) (+ c d))` clearly worse than `(a + b) * (c + d);`? Both have a bunch of parens, and one even has a semi colon.

This works both ways. `(list 1 2 3)` is clearly better than:

        var l = new List();
        l.add(1);
        l.add(2);
        l.add(3);

It's also better than `var l = [1, 2, 3];`

How often are you trying to make sense of a bunch of infix arithmetic operations when you're programming? Separately, how often are you creating data structures, navigating data structures, handling data in the form of JSON or XML, parsing that data into your language's native data structures, etc.?

Reading arithmetic in prefix instead of infix is easy, even if it is counter to how you were taught in elementary school. Working with s-expressions for code and data is clearly better than whatever syntax your language uses for code and either directly instantiating data or reaching for JSON or XML.

> justify its lack of static typing

Racket has both Typed/Racket as well as contracts.

> Is `(* (+ a b) (+ c d))` clearly worse than `(a + b) * (c + d);`?

Yes.

> `(list 1 2 3)` is clearly better than ...

It's not better than `[1, 2, 3]` is it?

> How often are you trying to make sense of a bunch of infix arithmetic operations when you're programming?

Very often??

Anyway it isn't just the lack of infix that makes it difficult to read - there's also the crazy bracket matching, and the lack of syntax in general. Yes that is a strength when writing parsers, macros and so on, but it also definitely hurts readability.

> It's not better than `[1, 2, 3]` is it?

If you want to change your vector to a linked list, in Lisp, you can change from `(vector 1 2 3)` to `(list 1 2 3)`. If you have some array `[1, 2, 3]` and you want to change to a linked list for whatever performance concern, you'd have to replace `[1, 2, 3]` with..

    var list = new List();
    l.insert(1);
    l.insert(2);
    l.insert(3);

Maybe this example is contrived, but I feel like it is much more of a realistic example to want to change from an unsorted map to a sorted map. You can't just simply switch from `{k1: v1, k2: v2}` to `sorted{k1: v1, k2: v2}` as you could do in Lisp from `(unsorted-map k1 v1 k2 v2)` to `(sorted-map k1 v1 k2 v2)`. You'd need to write out all of your operations as with the list example. And, all of a sudden you are stuck with using the unsorted data structure for your JSON serialization rather than having the ability to reach for a sorted data structure.

`(date 2026 6 1)` is better than "2026-06-01" because the latter isn't a date, it's a date string. `(date 2026 6 1)` is better than `new Date(2026, 6, 1);` because the former is how it is serialized and can be deserialized.

> there's also the crazy bracket matching

At least with reading code, there is almost no reason to try to match brackets at all. It's like complaining about having to read semi-colons in languages that use them to signify the end of a statement. When writing code, Lisp is just another language like all the rest that benefit from an IDE that is syntax-aware. Having highlights for the starting paren and ending paren for an expression and being able to just select a particular expression make bracket matching fairly effortless.

> never heard anyone say that Python is hard to read

I already pre-empted that: readability tracks what you learned first and how much you've practiced, and you trying to restate the familiarity effect as if it refutes it. You're measuring familiarity, not intrinsic readability. If you ask people about less popular language, say Haskell, yeah, they'd complain about its "readability" too.

> most common complaints against Lisps

Well, they are wrong on the other side of the fence. There are thousands of Lispers who'd say exactly the opposite, that: "Lisp is by far more readable than anything else"

You're cherry picking some fictive example about syntax, well, it's not a convincing one, comparing more than just a and b, blows up quickly, innit? `a === b && b === c && c === d`, while in Lisp it remains uniform `(= a b c d)`.

Lisp just uses one rule everywhere. "One uniform rule" vs "prefix for functions, infix for some operators, with a precedence table". You ever thought about that? You think you're getting an aesthetic point for binary operator example, while disregarding a bunch of layers that scream "simplicity".

> is the same cop-out Ruby programmers use

It's not the same, you clearly speaking as someone without honest, heartfelt attempt to use any modern Lisp dialects, like Clojure, Fennel or Jank. Honestly, try using Clojure, (re)write some personal shell scripts in babashka. It's truly great, and I'm saying that as someone who has used different languages, varied in paradigms. Interactive eval is not a substitute for static checking and I never offered such stance. Not to mention the enormous amount of research and experimentation on type systems that's been done by Lisp communities.

you could also compare

if (a === b && b === c && c === d && d == e)

To scheme's

(= a b c d e)

JavaScript clearly has the upper hand.

For you, perhaps. I've never been able to get into lisp style sexpr syntax languages :'(

)

There matched your paren for you.

Don’t you know that :’( is actually a trigraph for meta-quote-expression·opening ? Such a a reckless move as a lone mere literal closing bracket could destabilize the cosmic equilibrium entirely!

Being in the Lisp family, an often heard criticism is its use of parenthesis (disclaimer: I understand the difference between syntax & semantics. But syntax does matter).

Is this an issue in Rhombus? Or Racket?

Racket is s-expression based, so it has a lot of parentheses. Racket can claim to have slightly fewer parentheses than most other Lisps because it uses brackets in some places rather than parentheses.[1]

Rhombus is a novel notation (that is implemented as a Racket macro) which eliminates the need for almost all parentheses. They have a handful of code snippets on their homepage.

[1] Racket doesn't distinguish between parentheses and brackets, so programs could be paren-free. In practice, brackets are only used in a few key places: https://docs.racket-lang.org/reference/if.html#%28form._%28%...

I agree 100%. Racket is Awesome.

The Rhombus implementation is about 70% Racket!

Adding significant whitespace to a new language feels like a bad choice. It's not terrible but I do think it was a bad call for Python in hindsight.

why do you think it was a bad choice?

It‘s a source of problems with mismatched tabs/spaces being used for indentation between team members for fairly little upside. Imo it also makes moving blocks of code more cumbersome.

Shrubbery, Rhombus's first-pass indentation-sensitive syntax, has a syntax form to facilitate copy-paste.

With guillemets, « and », you can make a section of Shrubbery code indentation-insensitive. The idea for copy-paste it to "armor" the section you want to copy with guillemets in the right places, and unarmoring it after posting.

This needs editor support to do fluidly, but imo it's much better than trying to copy-paste the indentation-sensitive syntax.

The Guillemets syntax is described here: <https://docs.racket-lang.org/shrubbery/group-and-block.html#...>

I can't tell from my 5 minutes of poking DrRacket whether it supports this "armoring", I've been writing Shrubbery in nvim, which, unsurprisingly, does not support it.

That's horrifying.

At least it shows that the authors are aware of this issue and planned for it.

In DrRacket mark the section (with shift+arrows) then use tab or shift+tab.

Any language with significant indentation ends up specifying "Indent with spaces, not tab characters" for just that reason. As I recall, Python had that as a recommendation while F# ended up with it as a requirement, but it's been a while since I looked at that so I could be wrong. But in my experience, the category "people who complain about significant whitespace" is nearly a subset of the category "people who prefer tabs over spaces for indentation".

(Moving blocks of code around is not a real problem if your editor is capable of easily highlighting the thing that was just pasted. Because then you just hit that key binding, then press `>` or `<` — or Tab/Shift+Tab if you are using an inferior editor ;-) — until the indentation is where you need it. I haven't found it to be a big problem in practice when writing Python, though mileage will likely vary).

For me, the alternative solution makes much more sense for a language with significant indentation, i.e. to use only tabs for indentation and to completely prohibit spaces before the first printable character of a line.

I do not know why I have never seen this solution in practice.

It depends on the language's indentation requirements. That can work in Python, where you never need to line things up with characters above that aren't a multiple of an indent level. But in F#, at least a few years ago when I tried it, there are times when you would need (or strongly want) to line things up with other characters. For example, this example from https://learn.microsoft.com/en-us/dotnet/fsharp/style-guide/...:

    functionName
        arg1
        arg2
        arg3
        (function
         | Choice1of2 x -> 1
         | Choice2of2 y -> 2)

Note how the | needs one extra space in order to line up with the word "function", due to the open parenthesis. If you're using tabs for indentation, that means you need a series of tabs plus one trailing space after the tabs, in order to line up the | correctly.

Any situation where you must have a mixture of tabs and spaces for code to work right leads to a nightmare. Because it makes you have to turn on visible whitespace in your editor and peer closely at the lines. I have a simple rule: "Do NOT make me care whether there are tabs or spaces in this file!" If it's significant whether a line is indented with a tab or space, then that rule is broken, and you're probably in for a bad time. (Case in point: Makefile syntax).

I did not take this in consideration, because for such code, with brackets and separators, I prefer to align the separators with the opening and closing brackets, like this:

  ( ...
  | ...
  | ...
  | ...
  )

  { ...
  ; ...
  ; ...
  ; ...
  }

I just checked, and lining up the | with the open parentheses does work in modern F#. I believe they revamped the indentation rules a few years back, because I definitely remember things like that not working back when. So perhaps now your idea would be feasible. However, there was definitely a time in the past when F#'s indentation rules would have been problematic for tabs, and that fact is why the F# compiler still forbids tab characters outside of string literals or comments. (And there are still indentation styles recommended, though not required, by the official F# style guidelines that would require the use of spaces. Which is another reason to avoid tabs in F# code, because they're less flexible than spaces. Usually the reason to prefer tabs is because they're more flexible, but the slightly-peculiar nature of F#'s indentation rules means tabs are less flexible in F# code.)

>Because then you just hit that key binding, then press `>` or `<` — or Tab/Shift+Tab if you are using an inferior editor ;-) — until the indentation is where you need it.

But that's cumbersome compared to moving the block of code and hitting Tab to have your superior editor immediately indent the block at the right level.

That's why you use an autoformatter.

IMO the biggest downside is that it gets awkward to do closures and inline expressions and things like that. For example Python's `lambda` and if-else expression which are super weird and special snowflakey compared to the equivalents in e.g. Rust or OCaml or even Tcl.

Maybe there's a way to do it nicely; I haven't thought about it too much.

You can't autoformat broken indentation with significant whitespace since it would make the program not parse (or parse incorrectly)

I was responding to

> mismatched tabs/spaces being used for indentation between team members

Well yes. Say you check out a project that's all tabs but your editor is using spaces for indentation. You change a line and now the program is broken. Calling the auto-formatter won't help you.

This is literally not a problem. All Python projects use 4-space indentation. You would not have your editor configured for tabs when editing a Python program.

It's really not an issue at all in practice. The issue of making moving code more awkward is true but really barely an inconvenience. It's not difficult to select it and press tab a couple of times.

As I said the biggest issue is with closures and expressions that you might want on one line.

>This is literally not a problem. All Python projects use 4-space indentation.

Tell that to the one team at my old workplace that used spaces for all their scripts.

Like I said it’s a stupid source of errors that can be mitigated through style guides and tooling but it’s still a source of errors.

Massive fail. I dread having to move code around my F# codebase.

At least here they provide an alternative syntax that does not need significant indentation, so a program structure may be written on a single line.

"Modern programming languages reflect a consensus on the the most important programming concepts, including lexically scoped variables, closures, objects, pattern matching, and type parametricity. Why, then, yet another programming language?"

I don't want to be too nitpicky but ... the sentence has two "the", aka "the the most important". It is a really irrelevant error, but on the other hand, has nobody ever read the documentation through slowly, before publishing? Because then this means lack of care and interest. Again, people make typos, that's ok, but if you try to promote a new language, you should at the least have read your own (!!!) writing once. And I am quite certain that the author has not bothered to check his own primary writing here, not even once. So why would he then expect others to want to use a new programming language? Sure, that typo means nothing at all about the programming language itself, but as I got older I also realised that many great language designers are horrible at writing documentation. I'd much rather use languages that are very well documented. Naturally this is a tiny issue here, but if you don't even care about typos in the primary introduction, it makes one wonder about the long term focus of the language as such.

Extremely poor reasoning to assume that an author, upon reading his own primary writing once, is guaranteed to catch a typo of this nature.

Thanks for the report. I just made a PR to fix it.

I was not involved in writing this, but in my experience it's better to edit the text in Google Docs or something similar that catches all these easy typos. But it's harder to collaborate and make it git friendly, so I guess they just used a standard editor that has less support for this kind of errors.

Haven't tried it, but isn't collaborative editing what the zec.dev people are working on?

https://rhombus-lang.org/performance.html

Thanks to Chez Scheme I guess...

Yes, Chez Scheme is fast but it took a lot of time (a few years!) to make the compiler translate Rhombus/Racket code to fast Chez Scheme code. And there are still a few rough corners to fix...

Also, Matthew implemented flonum unboxing to make code that uses a lot of floating points like x10 faster. I added type recovery, that gives a 10% boost in many cases. And I'm probably missing a few similar features.

In most cases the Chez Scheme team also was involved. Those changes were upstreamed, so you can enjoy them in Rhombus, Racket and Chez Scheme.

    fun repeat(str :: String, n :: Nat) :: List:
        [body]

I may be over-sensitive to looks but... god why ?

    fun repeat(str: String, n: Nat): List =

would be prettier. (I guess authors had to compromise in affecting symbols)

No instances of blazingly detected in the paragraph "is it fast ? ", I guess the answer is not very

Like 3-5 times slower than C or Java. This is similar to my rule of thumb for Racket. More details and benchmarks in https://rhombus-lang.org/performance.html

I wonder how much utility of such special-purpose languages will keep getting diminished as AI coding becomes a staple in programming and software engineering.

With current LLM I am not sure. Using macro, you can often spare a lot of explicit code boilerplate. So token efficiency. On the other hand, will LLM shine in such a paradigme, where picking the right abstraction is more useful than generating large amount of lines?

Maybe it's a lake of training set, but just roaming the fine article, it already mention a LLM generated project which is more looking like Java idiomatic rather than something authors would consider elegant Rhombus code.

Woo!

Indentation scope? Pass.

Reply on news.ycombinator.com