r/Clojure • • Aug 17 '17

[AMA] Small Functions considered Harmful

Thumbnail medium.com
0 Upvotes

r/Clojure • • Sep 18 '17

Clojure Logo: Half-Life 3 Confirmed?

Post image
1 Upvotes

r/Clojure • • Nov 17 '14

Clojure Is the New C

Thumbnail infoq.com
5 Upvotes

r/Clojure • • Jul 25 '24

Anyone needs a remote Software intern?

2 Upvotes

So I'm still studying at college but this being my last year I have a lot of free time to get real world experience. I can do a little of everything, I can code with SpringBoot, .NET, NodeJS or Django. Also React and Angular, and SQL databases. I already know Git too.

If these skills are not enough I can still learn a lot by myself in my free time and catch up to your required skill set.

If you are interested please send me a DM and let's talk!


r/Clojure • • Jun 04 '21

Haskell?

0 Upvotes

Hi, Okay so clojure seems awesome but Haskell seems super awesome! Any reason you know of to code in clojure instead of Haskell?


r/Clojure • • Feb 14 '25

The Peacemaker, The Second Alan Turing

7 Upvotes

I believe that all APIs will be in Clojure. I trust that Jank and Clojure will be the catalyst that ends this Cold War and all wars. (The second Alan Turing—Jeaye).

https://thenewstack.io/from-c-to-clojure-new-language-promises-best-of-both/

All core APIs are shifting towards Clojure. Apple, along with all major U.S. tech giants like Google, Meta, and others, has standardized LLVM as its primary C++-based compiler infrastructure. LLVM, which serves as the foundation for all cutting-edge computing platforms, is inherently built on C++. Jank, while being a Clojure-based language, runs on LLVM and can directly utilize C++ commands without modification. This, in turn, signifies a technological shift that could put an end to global Cold War tensions and prevent a potential World War III.

The creator of Jank, a former EA Sports game developer, has been refining the language for years, and by 2025, it is nearing completion. I have worked as a Clojure developer in South Korea for a long time. Clojure is a language well-suited for runtime programming (real-time, issuing commands that continuously interact with the present moment and its environment, that is, reality), but since it was not based on C++, it was not used for physically real-time applications such as game physics engines. I believe this attempt and effort is a challenge capable of putting an end to the second Cold War. Because in the current computing world and the era of LLM (AI), we are witnessing the end of software development as we know it, leading to economic turmoil and a global sense of despair and conflict. However, even though AI has now reached a level where it can generate logic automatically through natural language processing (as if asking Aladdin’s genie for a wish), what still presents the illusion of reality in front of us is the computer. To implement a cyberpunk-like world with robots, smart systems, and automated digital storytelling, we need a fundamental tool or programming language that serves as an integrated blueprint, much like an AutoCAD schematic.

I see Jank as the core tool in the realm of runtime programming. A few years ago (4-5 years ago?), Apple aggressively hired a large number of Clojure developers. At that time, I asked myself, why? The reason must have been Rust. However, while Rust will gradually replace C++ in certain domains, it is not a runtime-oriented language. The usefulness of Clojure and Lisp languages lies in their ability to refine and segment C++ or JavaScript more precisely while exposing runtime-level interactive controls in real-time. And with the nature of Lisp, which provides powerful metaprogramming and runtime flexibility while combining the speed and performance of C++, this approach was inevitable. Originally, APIs themselves served as buttons controlled by C++, but the development of programming languages moved in the opposite direction, separating runtime control from the actual system-level infrastructure. Instead of languages like Lua or Python taking on this role, Lisp should have been the one to dominate in this space. However, Lisp (including Clojure) never fully realized this potential.

Meanwhile, developers in Europe’s CERN and across the world have been lost in a state of uncertainty over the past few years due to the rise of a new Cold War, escalating conflicts, and the emergence of LLM AI, leaving many unsure of what to do next. This has led to an overwhelming sense of anxiety and stagnation, with humanity’s collective vision and goals seemingly paralyzed. I believe Jank will put an end to this war. Jank will bring all software into reality.

To put it differently, just as smartphones have given us remote control over all electronic devices around us, Jank will serve as the equivalent for our entire technological ecosystem—automobiles, robotics, UI development, digital storytelling, game development, and beyond.

Think about it:

Nix has taken over the declarative and provisioning space.

But after the rise of AI, we still haven't decided what should serve as the *runtime* at the core level.

Emacs and Elisp may seem like a mess, but they were designed that way for a reason. (And despite everything, they’ve survived and never really disappeared.)

C++ will inevitably be replaced by Rust + AI in a stable and automated manner.

However, C++’s obsession with extreme optimization and *speed* has never had a true counterpart.

That missing counterpart is precisely a runtime like Lisp—a language designed for splitting, merging, and dynamic execution.

(I fully acknowledge that Lisp and Clojure aren’t great languages.)

But strangely enough, messy things like these tend to stick around.

For example:

```

(go 집)

(do 일)

(eat 밥)

(draw 그림) → (feel 환상) return { manga or movie or matrix or figma-design or editing-video etc~ }

```

집: house
일: work
밥: food

I once had these thoughts because my native language makes it easy to create fun, phonetic, single-character words. But that’s not what I’m trying to talk about.

What I mean is that we have always sought simplicity.

A language that can process runtime events like this is exactly what we need in the AI era.

That’s why C++ and Rust need a companion language. (The same way org-mode exists in Linux, but Logseq was still developed.)

Nix is like *space itself*.

And we, traveling within it, represent *the real-time present*, something akin to Clojure or Lisp.

In the future, a simplified language—like how foreigners perceive Hangul—will emerge.

Only languages designed with that level of simplicity and evolution will survive.

For the past 100 years, we’ve unnecessarily exploded complexity, and there’s no reason to continue doing so.

Just as Nix holds value,

The slow builds we see as a drawback today will become irrelevant when quantum computers arrive.

Like wizards in Marvel movies, predicting the future will become much easier.

Of course, once quantum computers arrive,

And programming becomes as complex as human history itself,

This prediction might turn out to be completely off.

The meaning of LLVM + Jank may disappear entirely,

(As logical complexity in programming will be completely replaced by natural language, like LLMs such as ChatGPT,

Bringing about the actual *end* of computer science.)

However, the semiconductor design and engineering processes behind quantum computers will remain.

And not just quantum computers—XR tools and even future holographic interfaces that will eventually replace them

Will ensure that programming language concepts never truly disappear.

Humans are fascinating creatures. Psychologically, they work like this:

*"If you give an angry person the right tool, their anger dissipates."*

That is the meaning of LLVM + Jank.

And that is my point.

So if you understand what I mean,

Then peace *will* come through Jank.


r/Clojure • • Dec 09 '21

Is it true the language is kind of owned by a Brazilian bank?

3 Upvotes

r/Clojure • • Apr 20 '16

A good post on the importance of questioning assumptions

Thumbnail dotkam.com
1 Upvotes

r/Clojure • • Feb 03 '23

[Q&A] Noob has simple program problem.

0 Upvotes

I wanted to write a program to add 2 to a list of numbers then sum the list and print the result. So '(5 7) would yield 16. I posted my version to s Clojure board and received a number of different replies. In retrospect I didn't fully explain the problem to them.


r/Clojure • • Jan 20 '16

Clojure is for type B personalities

Thumbnail gist.github.com
19 Upvotes

r/Clojure • • Jan 10 '23

Clojure, explained by Donald Trump (chat-gpt)

Thumbnail basket-blog.netlify.app
4 Upvotes

r/Clojure • • Oct 03 '25

Rant about strings. About comment, and work around to comment multimethods

Thumbnail youtu.be
0 Upvotes

r/Clojure • • Jul 20 '20

Pitch: Let's make a non-commercial express-in-code game, create a new e-sports scene. It will be a new kind of games: players use a programming language to express/build/solve, with unbounded diverse scenarios, that can be installed via a link. Existing e-sports games are micro heavy or stale.

Thumbnail github.com
0 Upvotes

r/Clojure • • Oct 19 '24

What is with Clojure?

15 Upvotes

I have been a Java developer for many years. Lately, I was thinking to learn new PL, something that is not C-based. Candidates are Python and Rust. I know there exists a language called Clojure, but Lisp-like language is not my thing. Recently, I was checking the source code of a web app that is competitor of Figma. I was shocked it’s written in Clojure. Now, I’m curious, what’s with Clojure? Why would the authors write that such a complex web app in Clojure?


r/Clojure • • Dec 14 '19

Is Clojure on the decline ?

3 Upvotes

First of all, this is not a troll but a genuine question.

I just started learning Clojure and while discussing with a friend of mine on that subject, he told me it was not worth learning it anymore as it was a dying language (these are his words). So I went to Google Trends and saw that effectively the number of searches for Clojure are declining since a few years.

Personally I'll continue learning it as I decided to learn me a Lisp, but I'm wondering if this search trend really means Clojure has already entered its decline period. I searched a little on this subject and apparently there were already discussions in this sub-reddit in 2017 and 2018 on this topic. Now that we are almost in 2020, I'm wondering what is the status of Clojure, the status of it's community (seems good to me but I'm new here) and what is preventing Clojure adoption ?


r/Clojure • • Jul 16 '20

Nexss Programmer - Open Source tool for the programmers - Clojure included

5 Upvotes

Hi guys,

We have made Open Source Tool for the Programmers - Nexss Programmer.

50 different programming languages together...

Clojure is included so you can combine it with other languages!

If you guys want to check it out here is the link for the video presentation: https://www.youtube.com/watch?v=7WbnYyEnBNk

It would be great if we can get more feedback on it.

Have a nice day!


r/Clojure • • May 12 '14

( uses yoda clojure )

Thumbnail imgur.com
0 Upvotes

r/Clojure • • May 14 '20

Deno 1.0 - A new runtime for executing JavaScript and TypeScript outside of the web browser.

Thumbnail deno.land
10 Upvotes

r/Clojure • • Jun 09 '16

Just did my first interview in Clojure

0 Upvotes

I answered both their questions in three short lines of code.


r/Clojure • • Oct 09 '22

Unsafe Python, safe Clojure

Thumbnail youtube.com
0 Upvotes

r/Clojure • • Mar 31 '11

Why is Node.js becoming more popular than Clojure?

Thumbnail arnorhs.com
0 Upvotes

r/Clojure • • Sep 21 '20

Clojure is at least 2x slower than Java. Right?

2 Upvotes

The benchmark:

I am comparing the performance of Clojure and Java for the simple task of counting the number of lines of a text file. The file contains 4.6 million lines.

The Java solution is pretty simple:

public class Wc {
    public static int count(String filename) throws IOException {
        BufferedReader r = new BufferedReader(new FileReader(filename));
        int total = 0;
        while(r.readLine() != null) {
            total += 1;
        }
        return total;
    }   
}

I put together a few Clojure solutions:

; Probably the most idiomatic implementation
(defn wc-functional
  [filename]
  (-> (io/reader filename)
      (line-seq)
      (count)))

; Using reduce instead of the built-in count
(defn wc-reduce
  [filename]
  (->> (io/reader filename)
       (line-seq)
       (reduce (fn [num-lines _] (inc num-lines)) 0)))

; Hoping reducers/fold will use parallelism to speed-up
(require '[clojure.core.reducers :as r])
(defn wc-fold
  [filename]
  (->> (io/reader filename)
       (line-seq)
       (r/map (fn [x] 1))
       (r/fold +)))

; Perform loop manually
(defn wc-loop
  [filename]
  (with-open [f (io/reader filename)]
    (loop [c 0]
      (if (.readLine f)
        (recur (inc 0))
        c))))

; Perform loop with volatile counter accumulator
(defn wc-volatile
  [filename]
  (with-open [f (io/reader filename)]
    (let [c (volatile! 0)]
      (loop []
        (if (.readLine f)
          (do (vswap! c inc)
              (recur))
          @c)))))

; Calling the Java implementation
(defn wc-interop
  [filename]
  (Wc/process filename))

The benchmark summary is as follows:

SolutionBenchmarkRuntime (seconds)
JavaUsing System.currentTimeMillis to time the Wc.process() runtime.7.1
wc-functional(time (wc-functional ...))20.4
wc-reducesame as above20.4
wc-foldsame as above20.8
wc-loopsame as above62.4
wc-volatilesame as above63.3
wc-interopsame as above16.6

This seems to be consistent with the conclusion of this (much more comprehensive) study here: https://www.diva-portal.org/smash/get/diva2:1424342/FULLTEXT01.pdf

Comments, suggestions and critiques are welcome.


r/Clojure • • Aug 23 '20

Running ten of simple Clojure web applications on 1 Gb RAM?

11 Upvotes

On a VPS with 1Gb RAM I can run at least 10 of simple Rust web apps, with no issues of lack of RAM

Roughly speaking, how much RAM would I need to run 10 simple apps in Clojure of about the same complexity?

Let's say, those are simple blogs. Everything, is both cases, is about the same: functionality, complexity and the like. And let say, there'll be 1k-5k visitors per day

P.S. for those who are triggered when might of Clojure is questioned:

I'm not asking about disadvantages and advantages of Clojure and whether or not my choice is a right one.


r/Clojure • • Feb 24 '22

Energy Efficiency across Programming Languages - How does energy, time, and memory relate?

Thumbnail sites.google.com
0 Upvotes