Remix.run Logo
▲ Clojure will affect the way you think about programming (2017)(eli.thegreenplace.net)
91 points by sammatilda 7 hours ago | 30 comments
▲tikotus 15 minutes ago | parent | next [-]

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?

▲TN1ck 5 hours ago | parent | prev | next [-]

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 an hour ago | parent [-]

> 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.

▲ajasmin 3 hours ago | parent | prev | next [-]

I love the thoughtful approach to programming that Clojure exemplify.

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

▲darksaints 6 hours ago | parent | prev | next [-]

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.

▲kmac_ an hour ago | parent | next [-]

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.

▲chii 2 hours ago | parent | prev | next [-]

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

▲quixoticelixer- 6 hours ago | parent | prev [-]

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 3 hours ago | parent | next [-]

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 2 hours ago | parent | prev [-]

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 2 hours ago | parent [-]

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.

▲sourdecor an hour ago | parent | prev | next [-]

I recently found out you can use Malli type providers[0] with Typed Clojure[1] to get instant feedback when developing!

So you can do this when programming:

  (m/=> foo [:=> [:cat :int] :int])
  (defn foo [t] (inc t))
  (foo 1)
[0]: https://github.com/typedclojure/typedclojure/tree/main/examp...

[1]: https://github.com/typedclojure/typedclojure

▲Jtsummers 5 hours ago | parent | prev | next [-]

https://news.ycombinator.com/item?id=14928429 - One discussion from back then, 216 comments

▲opiniateddev 5 hours ago | parent | prev | next [-]

fun fact: Conductor OSS has support for clojure

https://github.com/conductor-oss/clojure-sdk

▲theanonymousone 2 hours ago | parent | prev | next [-]

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?

▲deterministic 3 hours ago | parent | prev | next [-]

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

▲zergrush 4 hours ago | parent | prev | next [-]

Outdated article post-LLMs, if you are still taking to heart what this article says you are working against the trend.

You don't need any inner working of clojure or any lower language for that matter. It's all available within your reach. Don't let the people who have built an identity over the tools that they have chosen, they can't give you any meaningful advice anymore with what we have as tools.

I'm saying this as someone who has worked with clojure for over a decade. There is no point in gate keeping things anymore. It also means that the point of clojure which is supposed to have a lot of DX built into it , is gone with LLMs.

Software is largely solved now and the only thing that matters now is distribution so start thinking about your product and how to market it.

▲j12a 3 hours ago | parent | next [-]

There was a good Conj 2026 talk on points that can make Clojure a great fit for LLM-driven development, same which make it convenient for humans also.

What tipped the scales for Clojure - Brendan Foote (Clojure/Conj 2026)

https://youtube.com/watch?v=tzzg8CVkl2A

▲bigstrat2003 3 hours ago | parent | prev | next [-]

> Outdated article post-LLMs

Outdated take post-slopocalypse. You still very much need to know how to program and will often get better results writing code yourself, as we have seen from the outages caused by people vibe coding shit.

> if you are still taking to heart what this article says you are working against the trend.

Being trendy is not synonymous with being correct. In this case the trend is stupid and making the profession worse, so one would be well advised to work against it.

> Software is largely solved now

If that were true, we would be getting a deluge of high quality software. Instead we are getting a deluge of crap. Software is by no means solved.

▲Joel_Mckay 3 hours ago | parent | prev | next [-]

While I agree "LLM" have lowered the barrier to access languages, it is fundamentally just isomorphic plagiarism of around $9Tn worth of FOSS projects.

Much like how GPU were bodged onto the monolithic von Neumann CPU architectures, we may safely assume most "LLM" will be superseded by neuromorphic computing technology sooner of later. =3

▲zergrush 3 hours ago | parent | next [-]

Viewing LLMS as compression is flawed because it shouldn't be possible to solve new novel problems. Zipping every single file in existence and then asking Winzip to produce a novel working zip file clearly doesn't work. Clearly LLMs are learning from data it is fed and a lot of what we do before LLMs also involved "plagirism". Even the greatest writers and artists would copy each other to master their styles and extract the dimensions. I think framing LLMs as compression is not only silly it demonstrates a poor understanding of the inner workings of LLMs

▲Joel_Mckay 3 hours ago | parent [-]

Except a statistically salient search context is in proximity to something similar, and manual content curators drop their thumb on the scales weights to boost desirable outcomes in the quantized model.

https://www.youtube.com/watch?v=LPZh9BOjkQs&list=PLZHQObOWTQ...

The encoding of the LLM is almost always lossy compression, but we agree it is not real intelligence.

As a sentient turnip, I likely wouldn't understand such things, but do recognize copyright bleed-through when it includes known obscure works. =3

https://en.wikipedia.org/wiki/Mechanical_Turk

▲pitchlatte 2 hours ago | parent | prev [-]

> Much like how GPU were bodged onto the monolithic von Neumann CPU architectures, we may safely assume most "LLM" will be superseded by neuromorphic computing technology sooner of later. =3

perhaps this is the optimism i need today.

▲Ampersander 2 hours ago | parent | prev | next [-]

You're absolutely right! It's all in the title really, Clojure can't affect how we think about programming anymore, because we stopped both thinking and programming.

▲globular-toast 2 hours ago | parent | prev [-]

Even if what you say is true, I prefer to own my intelligence rather than rent it. Whatever makes you happy, though.

▲stephbook 4 hours ago | parent | prev [-]

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.

▲vemv 2 hours ago | parent | next [-]

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.

▲froh 3 hours ago | parent | prev | next [-]

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.

▲quixoticelixer- 2 hours ago | parent | prev | next [-]

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

▲bcrosby95 an hour ago | parent | prev [-]

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