TN1ck 1 day ago

There was a time in university where I started my days with doing some 4clojure puzzles. I became so obsessed, I managed to solve almost all of them. It's wild what an impact these few weeks had on my programming abilities. It's a beautifully designed language that makes you think in data structures and their transformations.

As a side note: I code Clojure in Lightroom. It was so cool to see your code instantly evaluate and trace through your functions.

  • xinuc 1 day ago

    > As a side note: I code Clojure in Lightroom. It was so cool to see your code instantly evaluate and trace through your functions.

    do you mean lighttable? or you really code in adobe's photo editor.

    • TN1ck 23 hours ago

      Sorry, meant Light Table, also meant past tense. It was cool back then.

  • sdeframond 1 day ago

    Is lighttable still alive?

    • TN1ck 23 hours ago

      Sorry, typos all around, I meant that I coded (past tense) using Light table (not Lightroom :D).

  • xhevahir 22 hours ago

    This got me wondering if something like Light Table's instarepl would be feasible in DrRacket. I don't know how its GUI works but Gemini thought it would be amenable to vibecoding some of the features.

tikotus 1 day ago

In the era of LLMs, I often stop to think of Clojure. I believe it had a significant role in popularizing the concept of immutable data structures. Immutability simplifies the required context for understanding and solving problems. This benefits both humans and LLMs.

Would an LLM, or a person solely coding using them, have had the insight to work out that immutability is the way to go, and we should revolutionize software develoment? If LLMs had happened 15 years ago, would all code still be "place oriented programming", with higher token counts and less reliability than we have today thanks to better practices we've learned in the recent past?

If so, what are we missing out on in the future, now that stopping and thinking about code is frowned upon?

  • stingraycharles 1 day ago

    Aren’t these abstractions mostly meant to make reasoning about code easier for humans, and wouldn’t LLMs optimize for easy reasoning for LLMs?

    Phrased differently: what would a language look like that’s optimized for LLMs?

    • tikotus 1 day ago

      That's a good question. I do think that for example immutability is easier for LLMs as well, since it reduces the required amount of context for any give part of the software. But there might be even bigger wins out there for LLMs.

      Is anyone out there trying to find these wins?

      • stingraycharles 1 day ago

        Well answering my own question, but I think a strong type system with clear error messages is extremely useful for an LLM.

        Just look at how a system like LEAN allows LLMs to incrementally solve a problem. It absolutely wouldn’t get that far if it couldn’t rely on some type of compiler to verify things.

        So yeah, a strong type system that allows lots of constraints to be expressed easily.

        I think Haskell and Rust are much more “LLM-compatible” than Clojure.

        And I say this as someone who has written Clojure full time for over half a decade.

        • tikotus 1 day ago

          Oh, absolutely. LLMs thrive with problems that are easy to verify. They don't always get it right, but the number of attempts they can do in a short time more than covers for it if verification is fast. Type systems are great for this.

    • layer8 1 day ago

      This comes down to the question of how much LLM reasoning differs from human reasoning qualitatively. Maybe for the most part reasoning is just reasoning, so most things that help for human reasoning also help for LLM reasoning, and vice versa.

  • brlewis 1 day ago

    >If so, what are we missing out on in the future, now that stopping and thinking about code is frowned upon?

    You're probably asking this rhetorically, but if you were seriously asking, this would be one of those riddle sentences like "This sentence is a lie." If somebody had an idea that they could articulate in natural language on this forum, the natural language would be something an LLM could process and turn into better code. Any true answer could make itself false.

    What we'd miss out on if stopping and thinking about code was no longer a thing, would be ideas that stem from direct human experience. Language models relate words to words. There's a lot of power in that, way more than one would think, but they don't relate words to direct experience, except as described in other words. Innovation comes when humans express their direct experience in new natural language, that other humans can benefit from, and eventually language models benefit from.

  • 8by3 1 day ago

    Clojure and Elixir both do really well in the LLM age. Functional programming in general, but those two in particular as they have a runtime/shell that agents can interop with directly to view/modify the code as it runs.

    I actually just wrote about doing more clojure a few days ago

    https://tuhat.net/@sbr/p/beam-to-jvm

  • phplovesong 1 day ago

    We had immutable data LONG before clojure was a thing. Immutability is good, but nothing new, ir nothing that should be forced.

    • tikotus 1 day ago

      You're right, but I wouldn't nullify Rich Hickey's hard work just because he didn't invent persistent data structures. He's done much more to the industry than just created a language. My question is, will we have more people like him in a world where people no longer spend hammock time thinking about code?

  • wavemode 1 day ago

    > If LLMs had happened 15 years ago

    Functional programming and immutable data structures are much older than Clojure

    > If so, what are we missing out on in the future, now that stopping and thinking about code is frowned upon?

    "We" here is vague. In truth, the vast majority of programmers just use whatever is most convenient at their place of work and do not participate in, nor care about, the advancement of the craft. That has always been true.

    I imagine that, as we enter an age where many programmers don't even read code anymore, those people will largely stop caring about programming languages and paradigms entirely. But, a few will still have to. Similar to how most programmers nowadays don't think about allocation and memory management, but a few still have to.

    • tikotus 1 day ago

      You're right that Rich Hickey didn't invent functional programming or persistent data structures. But he did a lot to advance the industry. I'm not saying it's solely thanks to him, but immutability is now the default in many places, which definitely wasn't the case 15 years ago.

      And Rich didn't do what he did because he had to do it. He risked his own savings to go on this crusade, to make software development a happier place.

      Who will take a risk like that in a world where no one writes code?

      • wavemode 1 day ago

        there will always be people who write code. just like there will always be expensive handmade goods, even though most goods are mass-produced in factories nowadays.

  • keybored 22 hours ago

    At this point I often just pop into real tech threads (using tech with your own hands) to see how many But Now In The LLM Era top-level comments there are. And whether they follow the template of “now that there is <outcome I have asserted>, what philosophical ramifications does that have?” (For who? The humans that are not there?)

    There’s where my reading habits are right now. I guess well played?

ertucetin 1 day ago

Lisp is something people just can't seem to kill. It refuses to die. I know it's a niche language, and it will probably stay that way. But if you look closely, Lisp posts frequently make it to the front page, especially Clojure posts. They're always popping up now and then, attracting lots of comments, just like this thread.

I've been a Clojure developer for over 10 years now, and this still surprises and thrills me.

mlmonkey 1 day ago

Each of these 4 families of languages: Prolog, Lisp, ML, C/C++ will affect how you think about programming, each in their own different way. Most of us do imperative programming (C/C++) and are content with that; but if you really want to expand your thinking, try languages like Prolog and Lisp.

mdnahas 1 day ago

I’ve used Clojure a bit. Really liked it.

If you want to dive into Lisp, read Paul Graham’s book “ANSI Common Lisp”. It will show you the “why” and the concepts. Then learn Clojure for the syntax.

Even if you can never see yourself programming with Lots of Silly Parentheses (LiSP), the book is worth reading for the concepts. (And to imitate his writing style.)

  • ndr 1 day ago

    For the outsiders the meme is that it's full of parens.

    For the insider the meme is that it's the same parens: instead of `function(a, b)` you move the open paren to the beginning: `(function a b)`.

    Immutability is a much bigger hurdle for most newcomers.

    Anyway I recommend trying out Clojure and enjoy.

  • embedding-shape 23 hours ago

    > If you want to dive into Lisp, read Paul Graham’s book “ANSI Common Lisp”. It will show you the “why” and the concepts. Then learn Clojure for the syntax.

    Kind of feels like if someone never been exposed to Lisp before, not sure if they'd like it or not, "Hackers and Painters" (by the same author) is a better (non-technical) introduction to the "why's" of lisps. Less of a manual and more "high-level" about creative work in general.

nlitened 1 day ago

The more I work with Clojure, the more I am amazed how well thought-out, practical, and forward-looking it is, how well all its parts play well together.

And now, when I write all the code with agents, Clojure helps immensely with aligning agents’ code with what I want, with making sure I fully remain in control of all important behaviors of my code, with testing the agent-generated code, with troubleshooting running systems. Which probably means that Clojure is focused on delivering flexible complex production systems in general, not just human programmers’ ergonomics.

I try to use Rust whenever I can for small projects, but if I expect the system to be complex, I just have write it in Clojure, otherwise it would quickly get out of my control, and lose in performance and simplicity.

ajasmin 1 day ago

I love the thoughtful approach to programming that Clojure exemplify.

MVP churn and AI fatigue is getting to me. Need some good Hammock Time!

meken 1 day ago

This year has been fun for learning programming languages that change the way I think. The highlights have been:

- Clojure for functional programming (you mean you can update a bitmap in a purely functional way??)

- Array langauges (APL, BQN, J) for avoiding loops with matrix operations

- Prolog for avoiding loops with backtracking

darksaints 1 day ago

By a weird stroke of luck, clojure was one of the first languages I learned. And yeah, I guess it left a lasting impact on me in the form of an appreciation for immutability and dataflow programming.

Unfortunately it also left me with an extremely deep distaste for dynamic types, and in particular, the blind usage of lists and maps for everything. The ML family of languages finally gave me a paradigm worth keeping around.

  • quixoticelixer- 1 day ago

    I started learning Clojure when I was 17, but then later moved away from programming. It's done the opposite with me, I struggle to really get the benefit of static types and I still think of everything as maps and functions.

    • Xirdus 1 day ago

      The biggest benefit of static typing is that you automatically know every single operation you can perform on every single result of every single function ever made.

    • Tcepsa 1 day ago

      Haha same! All you need are primitives and maps and lists and first class functions! (Though good decomposition syntax is up there as well; it can be really helpful for telling what a given thing needs the map to include!)

      • oblio 1 day ago

        Awesome, how do you ensure clients of your code always do the correct operations on your data?

        With static types it's obvious and you generally have to work hard (and in non intuitive ways) to mess up.

        This becomes more important as team sizes grow.

        • skydhash 1 day ago

          > Awesome, how do you ensure clients of your code always do the correct operations on your data?

          Either the data type is opaque (as in you shouldn’t mess with it and you should use the provided api) or it’s just normal primitives and thus no restrictions.

          You don’t usually reach into data structures to modify their properties, especially if it’s for foreign modules.

    • Kyo91 1 day ago

      I think an appreciation for static typing comes once you have to start working with code others wrote. I used to write a lot of clojure in my free time, but I think I liked it more because I was the only developer on those projects.

      Working professionally in dynamic languages, especially those that use maps in place of objects/records, I would spend a lot of time trying to figure out which keys were present in various input maps. Were they always available or only sometimes? I could either add verify checks at function callsites or trace the map all the way through my code and hope it didn't originate from an undocumented API response.

      A few years ago, we started migrating our code from Elixir to Scala. That involved a lot of work creating case class "schemas" for many records that used to be represented by maps. But now it's clear at dev time what data each function receives as input. What fields are required and which are optional. I can write a quick bugfix in a large module that someone else wrote without spending a full day tracing data paths and looking at runtime traces.

      • BeFlatXIII 15 hours ago

        > I think an appreciation for static typing comes once you have to start working with code others wrote.

        …or working with yourself after several years of putting that project to the side. I've found some GNARLY type signatures in my Python that made sense at the time in 2018. No such luck in 2026.

        > I used to write a lot of clojure in my free time, but I think I liked it more because I was the only developer on those projects.

        Makes sense that a Lisp-like language has the curse of Lisp.

  • chii 1 day ago

    > the blind usage of lists and maps for everything

    it's not blind, tho it could seem that way, and if someone hadn't thought deeply abut how they should use lists and maps, then it could be described as being blindly using them.

    But this style is also what makes clojure dynamic, and flexible. Updates don't have to be rigid, and keeping backwards compatibility is a lot easier than a lot of statically typed languages.

    That's not to say you can't have some rigidity where it's needed (specs for example, can be sprinkled in where you need/want it).

  • kmac_ 1 day ago

    I always thought that a good craftsman knows many tools and techniques, so I learned and practiced everything. My goal was not to leave blank spots on my technology and language map. I learned FP, OOP, and various architectures like DDD, and I did not dismiss any language or major framework. "Every tool has its own place and is useful". Then, after years, I was employed by a company that used Ruby as their main language. "Such beautiful, simple code," I thought. It was a real culture shock for me. Strings and maps everywhere. No types. Monkey patching. No structure. I was really disappointed, but other words come to mind. I quit. So yeah. Once you go to some regions, there is no way back. I wonder how people who started with, for example, Haskell, and were shaped in a correct way, function when they touch other paradigms.

slifin 21 hours ago

Rich Hickey's talk from this year:

https://youtu.be/P5eO7BNyJao?si=45zxrLUsY9AMUg6B

I feel like there was not enough fuss about what he showed off this year considering how many programmers (historically myself included) cared about checking/enforcing structure on a potentially nested thing, spec in usage has proved to be good for external boundaries but not great for internals

I remember we used to code something like:

class User { name age username password }

etc all the time but would end up having to make everything optional so that we could use the type hint against the age method and the auth method when we had partial information for the object

Obviously not an optimal design and can be broken down into yet more types and then composed together but I'm not a huge fan of object of object of object type situations — anyway my point is that Rich showed that we can just do the checks in context using deconstructing and in a reusable way rather than trying to declare a type once centrally and then cram that into everything else

I haven't explained it very well — I wanted to do a blog on it but just watch the video its one of the few things I got excited about even though I don't really code directly any more - the sad thing is current LLMs won't even use the technique because its not in their training sets and that still matters I've noticed for what they do

  • cypherpunk666 18 hours ago

    I like Clojure & Rich. And “it depends” and “everything is a trade-off” are true. But! The DB-25 vs. DB-9 example is bad, when he says adding a pin for each new feature is the metaphor, and it shows how static typing is bad. Remember that those connectors also require protocols to match across them. The do not in face restrict what the protocol is. DB-9 has been used for god knows how many different purposes, some utterly physically inconpatible. The only point is that he misses the fact that if you remove complexity (eg static typing) from one place to make it easier, it will just show up elsewhere (bugs, or more testing). There actually is a lot of essential complexity that cannot be magically dismissed. And to say coding for space proves static typing is bad (I am hyperbolizing his poibt prrhsps) is dumb given Arianne V88, sheesh. And you can bend a system to do unanticipated things without them breaking? Yeah, until the time you do that AND IT BREAKS. It is also kind of very wrong that static types help with getting an algorithm (eg hash table) right, whereas they are very useful for getting the shapes of information programming data right. Look at why people got sick of json-with-no-schema.

avmich 19 hours ago

I am confused about Clojure having full Lisp macros. Paul Graham described another kind of macros in Lisp, which when I checked wasn't available in Clojure.

  • dapperdrake 15 hours ago

    It’s called hygienic macros. Has to do with details around symbol capture. Idea originated in scheme, IIRC.

    All those approaches are "full" lisp macros. You have all of lisp or clojure or scheme available at macroexpansion time.

    • avmich 12 hours ago

      I think they are called read macros or something like that.

podgorniy 1 day ago

The interesting thing about Clojure, for me, is that for all its beauty and power, it’s so simple that there isn’t much variety in the articles you can write or the “gotchas” you can cover for a wide audience. Niche stuff that assumes you already know Clojure doesn’t catch on with a wider audience. Its strong points—“everything is data,” “REPL development,” “immutability and strong primitives,” and “paradigm shift”—get repeated so often that they become noise people just filter out.

There isn’t much room for yet another framework or another way to work with data (I’m looking at you, Node.js), so there isn’t much to talk about or write articles about.

In other words, the efficiency and simplicity of the language act as a barrier to its spread in a world where only repeated mentions get through. IDK, maybe this is for the better after all.

  • jcul 1 day ago

    It's an interesting question, even outside programming.

    Before people might ask questions and discuss things on obscure forums or subreddits. Now that LLMs are trained on all this data people no longer need to do that.

    You just ask and LLM and get a throwaway answer that people generally trust as the best option.

    Where do the new insights and opinion come from? Especially when LLMs start getting trained to recommend certain products.

netbioserror 1 day ago

And it did. Clojure and Rich Hickey helped me understand that the most basic units of computation, data and functions, really are the simplest and most general-purpose tools for thinking about and modeling problems.

The programming books from my youth and my classes in college were so completely invested in Java and OO (from page 1) that it's only with hindsight that I can recognize: They never EVER gave a motive for why solutions need to be modeled that way. It might've been something like "We don't have enough memory or CPU throughput these days to be constantly copying data and performing collections", but even that is just an argument for procedural programming.

deterministic 1 day ago

If you enjoy your brain exploding then I also highly recommend learning LEAN and how to prove software correct.

shevy-java 1 day ago

So, people say this about programming languages all the time.

My problem is:

a) this assumes that people can not have ideas without a programming languages. That's obviously incorrect. I can have ideas without knowing a programming language.

b) languages also constrain the thinking. For instance, in ruby you have a class and a module, as distinction. Is that a useful distinction? I think it is overlapping, with modules giving more flexibility. In practice, this distinction does not lead to many problems, but if you have: class Foo; module Bar; end; end and then you were to write "class Foo::Bar" in another file because you want to modify the code quickly, then ruby says you'd have to use "module Foo::Bar" instead, because the ruby parser already knew that this is a module, not a class. It is not a big problem, but whenever I run into this issue, I wonder why I need to care whether it is a class, or a module. Because, when I do so, such as adding a new method to that, perhaps from another namespace/project, then I wonder why ruby does not prioritize me wanting to change the code, but instead complains about that it is a module or a class. (I understand the ruby parser has to work that way, in order to differentiate between errors made or mixing up code, but my point of contention here is the "class versus module" distinction. The above is one example of many more that can be found in programming languages.

Of course you can reason that better programming languages typically lead to better implementations too. I'd reason in favour of such a statement. I don't really see the point of learning a language that is inferior to languages I already know, when I know I am not going to use that language. The "learn a new language every year" is not a bad idea, but why would I want to learn languages that are bad? That makes no sense. There is competition between languages, as well as against time.

  • cryptopian 1 day ago

    > languages also constrain the thinking

    Which is precisely why trying out languages built on different paradigms is a good way to widen the way you think about programming.

    • lioeters 1 day ago

      This is equally true of human language as well. Learning a new language expands the mind and often allows you to think new thoughts that weren't possible or intuitive in other languages.

theanonymousone 1 day ago

To me, Clojure was "Lisp for JVM". Is that an incorrect picture?

I mean, recently I saw Clojure for . Net and Clojure without JVM (forgot the name). If you don't need/want JVM, then why would you use Clojure over e.g. Common Lisp?

  • quixoticelixer- 1 day ago

    It used to be tied heavily to Java and then JavaScript but it's on quite a few platforms now. But clojures big thing is dynamic functional programming, passing immutable maps to functions.

  • podgorniy 1 day ago

    Common Lisp was designed to unify several Lisp dialects. Its standard reflects historical compromises, but it also deliberately supports several programming styles.

    Clojure makes stronger choices about the default style: immutable data, transformations over collections, and explicit tools for managing changing state.

    Zooming out you're right: it's lisp and jvm is a difference. Zooming in and there are different ergonomics and incentives on how to structure the program.

  • dapperdrake 1 day ago

    A little bit.

    Clojure is a lisp-1 which, surprisingly, feels better to use than a lisp-2. Much more intuitive. (You can kind of also have a function call returning a function in the first position of a list and it just works. Common Lisp doesn’t like that at all and you need funcall or apply.)

    The immutable data structures and better array and hashmap syntax and ergonomic hashmap argument destructuring remove a lot of mental overhead. Kind of like Python or JSON-in-Javascript.

    Having slight syntax variation like square brackets for let bindings and one less level of nesting in let bindings makes it easier to read. Still homoiconic, though. So you get the best of both worlds.

    The hygenic macros helped me design better anaphoric macros.

    EDIT: typo

    • dapperdrake 1 day ago

      Clojure and hylang (python) help with understanding threading macros (-> …), so basically more readable shell pipelines.

      Hylang also had a good take on anaphoric macros in relation to threading macros. Clojure makes it more obvious that explicitly passing in the anaphoric symbol at the call-site is better for maintainability. This offers threading with arbitrary argument positions instead of forcing first or last position.

      Clojure transducers finally broke the ice on common lisp series. The CL side of this is horrifying. SBCL seems to have dropped its sb-series contrib module. But it moved us far enough along that we now have parenscript-series. So upside all around.

      Don’t know enough Fennel (Lua) or Elixir (Erlang) yet, to have any useful comments there.

  • rjsw 22 hours ago

    There are other Lisps for JVM such as ABCL and Kawa.

mdevere 1 day ago

This Or Jai! If you can get access.

eddiewithzato 1 day ago

We don't do that anymore. I mean FP is just natural language now, can't wait for LLM optimized languages. I don't read the rust/ts code produced by claude anymore, so why bother using said language.

stephbook 1 day ago

I think clojurists overestimate how advanced their language is. Or maybe it's just my outsider's perspective? Famously, Clojurists/Lispers think that theirs is the most advanced language and everyone who fails to see that just doesn't understand expressive power.

In any case: Typescript has dynamic types and static types, it has true union types, it has hot reload (what you might call REPL), it has the widest package ecosystem and so much more. It works out of the box with the most popular IDE and you don't need to learn emacs.

I rarely hit the power ceiling of Typescript, so I never put in the work to learn Clojure.

  • froh 1 day ago

    confluent persistence, on data. which changes how you think about concurrency.

    it allows you to "branch, work on a worktree, and merge" but unlike git worktrees you don't need to copy a complete clone of the data, you instead, like in the git object store, share most of it and only need memory for what you touch in your branch.

    and your data only changes when _you_ decide to rebase, and merging partial work results is a _deliberate_ step, not something happening under your feet.

    • layer8 1 day ago

      How are merge conflicts handled in Clojure, in that picture?

      • acobster 1 day ago

        Latest one wins. But you can keep a reference to the old, unchanged structure around, too. This is why immutability is important.

        ``` (let [a {:greeting "hello" :name "world"} b (merge a {:greeting "hi"})] [(:greeting a) (:greeting b)]) ; => ["hello" "hi"] ```

  • quixoticelixer- 1 day ago

    I don't think I've really seen the argument that clojure is "advanced" much at all.

  • vemv 1 day ago

    Typescript doesn't have a real repl. You cannot redefine just one variable in a running program and have the rest of the compilation untouched, yet aware of the redefinition.

    I get that "hot reload" can feel similar, but it's not the same and is more limited for debugging, experimentation, extremely fast (sub-ms) iteration loops, etc.

    Another thing you can't do is running/debugging tests without triggering more compilation. In a real repl language you drive things in-process, not from the outside with compilers and test runners.

    Typescript is lovely btw, just have a go at other paradigms if you feel like it.

  • bcrosby95 1 day ago

    Fuck being advanced, I love how stupid simple it is.

  • dyzone 1 day ago

    Javascript is the peak of programming language design, unironically.

  • tosh 9 hours ago

    Clojure is more about simple than about being 'advanced'