
Predictably Fast Clojure (2014) [video] - tosh
https://www.youtube.com/watch?v=iQwQXVM6oiY
======
prospero
No idea why this is here, but I'm the speaker and happy to answer any
questions.

~~~
christophilus
Ha. I was wondering the same thing. I have a somewhat unrelated question for
you, though.

You've been using Clojure for a while. Do you still like it? If you were to
start your current project(s) over today, would you still use Clojure?

Clojure is on a list of technologies my team is considering using instead of
Ruby/Rails. Our goal is to move to a stack that discourages complecting,
encourages what we consider to be good practice (immutability, function
composition, explicit dependencies, etc), and which has reasonably good
performance characteristics. Clojure seems to fit the bill, and has the added
benefit of syntactic simplicity which I really like.

Lack of static typing is probably the biggest downside vs some of the other
languages we are weighing.

~~~
prospero
Clojure is the language I'm most productive in. At the beginning of the year I
quit my job to write a book about Clojure [1], do some consulting, and build a
developer tool I've been talking about for a few years.

For the tool, I'm using a client/server model, and on the client side latency
is a huge concern, so I'm using Java. Java is basically assembler for the JVM,
and has extremely predictable performance characteristics. Where performance
is a non-issue, or I only care about throughput, I'm using Clojure, because
it's much more expressive. I think the tradeoffs of the two languages are very
complementary, but also much less extreme than, say, Ruby and C.

I find the inertia of the core implementation of the language annoying, even
if it's not a huge problem for most applications. Clojure's immutable data
structures were world-class when the language was first released ten years
ago, but there have been a number of papers which detail improved approaches
since then. I've implemented most or all of them [2], but the chance of
getting these back into Clojure is effectively nil. That doesn't affect me (I
can just use my own data structures), but it does give me some concern as to
where the language will be after another ten years.

[1] [http://elementsofclojure.com/](http://elementsofclojure.com/)

[2] [https://github.com/lacuna/bifurcan](https://github.com/lacuna/bifurcan)

~~~
christophilus
A. Thanks for the response.

B. Interesting. I saw a recent article on high-performance immutable data-
structures[1], and wondered what the odds of Clojure implementing them might
be. Sounds like you think the odds are minuscule.

C. I've heard great things about your book, and it is on my reading list!
Thanks for writing it.

D. Given your hesitancy about the future of Clojure, what is your opinion of a
more future-proof stack that has similar properties to Clojure (functional,
simple, data-oriented, etc)? I can't think of many. ReasonML is interesting,
but immature and definitely more complex than Clojure. Elixir seems to be
promising, but I don't like the language, and I don't like being constrained
to doing everything the BEAM way-- JVM is nice for high-perf computing when
needed... Anyway, I'd appreciate your thoughts!

[1]
[https://news.ycombinator.com/item?id=15005569](https://news.ycombinator.com/item?id=15005569)

~~~
prospero
The chance of my implementation being folded into Clojure, as opposed to
whatever Rich writes himself, is definitely tiny. But there's no telling when
he might get around to it, so the best way to stay sane is to assume it will
never happen.

Clojure occupies a really nice local maximum, and I don't think any other
language is trying to compete for that niche. Since Clojure is just a Java
library, it's relatively easy for you to extend or replace any part of it, so
I don't think the future is a concern for anyone who enjoys the language and
is motivated to use it.

Rather, I worry about the growth of the community, since that's largely
predicated on the out-of-the-box experience. As an author and consultant who
is focused on Clojure, that affects me far more than a company which builds
its product using Clojure (assuming you're willing to hire people with an
interest in FP and teach them the rest in their first month). I don't claim
expertise in how to grow a community around a language, but it seems to be at
best a part-time job for the people at Cognitect, which is not ideal.

~~~
reilly3000
I am seeing pretty healthy CLJS adoption, especially as NPM access becomes
easier and easier. The things that are happening on the client side seem to be
out front of the rest of the industry fairly consistently over the past few
years. I think that bodes really well for the Clojure community overall.

