
Is Clojure dying, and what has Ruby got to do with it? - tosh
https://lambdaisland.com/blog/25-05-2017-simple-and-happy-is-clojure-dying-and-what-has-ruby-got-to-do-with-it
======
reality_czech
It is now official. Netcraft has confirmed: Clojure is dying.

One more crippling bombshell hit the already beleaguered Clojure community
when Lambda Island confirmed that Clojure market share has dropped yet again,
now down to less than a fraction of 1 percent of all new code. Coming on the
heels of a recent Netcraft survey which plainly states that Clojure has lost
more market share, this news serves to reinforce what we've known all along.
Clojure is collapsing in complete disarray, as fittingly exemplified by
failing dead last in the recent comprehensive programming languages survey.

You don't need to be the Amazing Kreskin to predict Clojure's future. The hand
writing is on the wall: Clojure faces a bleak future. In fact there won't be
any future at all for Clojure because Clojure is dying. Things are looking
very bad for Clojure As many of us are already aware, Clojure continues to
lose market share. Red ink flows like a river of blood.

Due to the troubles of Lisp, abysmal sales and so on, Lisp Machines went out
of business and was taken over by GigaMos Systems, who sold another troubled
Lisp. Now GigaMos is also dead, its corpse turned over to yet another charnel
house.

All major surveys show that Clojure has steadily declined in market share.
Clojure is very sick and its long term survival prospects are very dim. If
Clojure is to survive at all it will be among programming language dilettante
dabblers. Clojure continues to decay. Nothing short of a miracle could save it
at this point in time. For all practical purposes, Clojure is dead.

~~~
sanderjd
Is this an ironic homage to some piece of alarmist writing about something
else? If not, it seems way over the top. It was pretty fun to read though.

~~~
voltagex_
I feel old now:
[https://everything2.com/title/BSD+is+dying](https://everything2.com/title/BSD+is+dying)

~~~
dasil003
Nice E2 reference. Hard to believe now, but back in the day there was serious
debate about whether it should compete with the upstart Wikipedia. Glad they
went the creative writing direction instead, there's some great stuff in
there.

------
virtualwhys
Clojure's not dying, but it's also not thriving[1].

I think it will continue on as a solid niche language for the foreseeable
future, but it's highly unlikely that the language will grow by leaps and
bounds barring some must-have innovation in the Clojure language and/or
ecosystem that gets the tech world to take it more seriously.

There are so many options these days that it's tough to stand out from the
crowd. Clojurescript, while interesting, is a dime-a-dozen with Elm,
Purescript, Scala.js, Typescript, etc. all on offer, and with static types to
boot. Also, Lisp itself is a tough sell, mainstream adoption isn't in the
cards without a major paradigm shift.

[1]
[https://trends.google.com/trends/explore?q=%2Fm%2F0_lcrx4,%2...](https://trends.google.com/trends/explore?q=%2Fm%2F0_lcrx4,%2Fm%2F091hdj,%2Fm%2F03yb8hb)

~~~
seanmcdirmid
Lisp used to be the language for AI, could Clojure possibly steal the machine
learning niche back from Python?

~~~
dragonwriter
> Lisp used to be the language for AI

IIRC, when Lisp was a leading language for "AI", it was specifically a leading
language for _expert systems_ , not ML. Even to the extent that was due to
language features being well-suited to the domain, there's still no real
reason to expect that suitability to translate to the radically different
approaches to AI today.

~~~
TeMPOraL
> _Even to the extent that was due to language features being well-suited to
> the domain, there 's still no real reason to expect that suitability to
> translate to the radically different approaches to AI today._

People these days use Python for ML, which is even less suited for the domain
(and lacks the ability to re-suite itself), not to mention being significantly
less performant than popular Common Lisp implementation.

Our industry is strange :).

~~~
mamon
Python is well suited for ML, just not in technical sense:

it is a very simple language that's easy to use by people who have a strong
academic background, but not much of programming experience (AKA: Data
Scientists). Also it has a lot of numerical libraries (numpy, pandas)

~~~
singingfish
ML problems are those where people benefit from the assistance of thinking
more like the computer does. Python helps people think more like the computer.
(corrolary: although a very similar language, Perl helps the computer think
more like you do).

------
phs2501
Oddly, as someone who was reasonably into Common Lisp, what really viscerally
turned me off to Clojure was the use of square brackets.

This sounds petty but I actually have some rationalization for it. Once you
learn to read Lisp (mostly looking at the indentation and ignoring the parens)
it's really nice that there's only one kind of delimiter in the language. It
allows a lot of easy structure editing with a decent editor. I had emacs set
up to use the unshifted square bracket keys to create and exit balanced
parenthesis pairs. Once you got used to this, this was really pleasant to
write and mutate code.

As soon as I saw Clojure, I knew that my setup would unavoidably get twice as
complicated because they added another delimiter that's used in random places
in the code. (Why are function arguments a vector instead of a list? Just
because the designer thinks it looks better? Why are let bindings a vector?
Why are ordinary function calls and function bodies a list? It just feels
arbitrary.) That in and of itself really turned me off. (The fact that it's
the JVM really didn't help either, but that was actually secondary to the
above.)

Other issues for me were the lack of two layers in the LET statement (i.e.
it's (let [a 1 b 2] ...) rather than (let ((a 1) (b 2)) ...). To some that
probably "looks better" but it kills the ability to use emacs's transpose-
sexps to swap the order of your let bindings around.

All in all the syntax just didn't seem well thought out to me. OTOH to non-
lispers it probably looked better, so maybe that was the goal.

~~~
_halgari
What's interesting is that for me Clojure was my first lisp. One of the main
reasons I never learned lisp before Clojure was all the parens that made the
language impossible to read. Clojure cleans up the "normal" lisp syntax quite
a bit, and that made it a lot more palatable.

Beauty is in the eye, and all that, but CL code still makes me want to claw my
eyes out.

~~~
agentgt
People complain about the parens in Lisp but what kills me about Lisp in
general is not the parens but the fact your brains has to read the code from
bottom to top and/or right to left. This is because of prefix notation.

And while I do not like object oriented languages its far more natural to
English readers such as myself to write and read things from top to bottom and
left to write.

Now of course some FP languages have operators to (Haskell, F#) to allow left
to right function application and you could of course make macros in Lisp in
whole it doesn't really fix the problem entirely.

You can also of course mitigate the above with judicious use of let
expressions but more often than not people inline anyway.

------
modularfurnitur
I think Clojurescript might be the thing. With advances in the Google Closure
compiler, it's getting better and better. And the front end developer tools
and libraries in Clojurescript are _the best_ out there. The holy grail for
javascript exists in Clojurescript. Until then I'll keep making my Javascript
env look like Clojurescript. With janky react devcards, Immutable.js, and
react-redux.

~~~
shadowmint
I hear this a lot from the clojure community... but I think it's a missed
attempt to pivot off the JVM and have clojure be useful for more people on a
more popular platform.

Missed?

Yes.

Pick a thing.

Be excellent at it.

What is clojurescript excellent at?

Its a nice language, with not very nice tooling, that is hard to maintain and
significantly different from the existing javascript code base you already
have, with poor interop to the existing js ecosystem (it is poor, compared to
some other compile to js languages).

On the JVM, java sucks, but your choices are limited; what, maybe groovy,
kotlin, scale, clojure?

Clojure has pride of place as the best dynamic language in that space.

For javascript, that crowd of alternatives is _so much larger_ , clojurescript
needs to _actually be good_ to stand out amongst all the others.

...and I don't think it really does.

The people who use it seem to just like it as a language; and I get that,
that's a thing.

...but aesthetics are personal preference and its difficult to ague they make
a compelling use case.

~~~
lsdafjklsd
> with not very nice tooling

The tooling is the best. Figwheel is hot reload that never goes down, devcards
is revolutionary, and a browser repl for live in editor evaluation...

> significantly different from the existing javascript code base you already
> have

It actually isn't. Clojurescript is basically javascript that's immutable
first, has underscore in it's core library, and then a bunch of other awesome
language constructs. The libraries use the same patterns, re-frame is a nicer,
more succinct abstraction over react-redux.

> poor interop to the existing js ecosystem

The interop might be the best out there. Seriously you can write javascript in
clojurescript. you can straight up import es6 jsx javascript into your
clojurescript code. (thanks Google Closure)

> For javascript, that crowd of alternatives is so much larger

I mean, what are the options? Clojurescript's benefits are so much more than
the language. The real pluses for clojurescript are the Google Closure
compiler, hot reload, browser repl, devcards, front end libraries. The
language is the cherry on top. There are no alternatives that have a
comparable platform not completely alien to JS developers.

~~~
shadowmint
> The tooling is the best.

No, it's really not.

Have you tried other ecosystems? You should. If clojure is the best tooling
you've ever used, look around, there's a wide world out there.

Heck, even the article _linked above_ from lambdaisland lists tooling as one
of the issues clojure suffers with.

> I mean, what are the options?

Haxe. Dart. Typescript. Elm. Scala. LivesSript. ES6. CoffeeScript. Flow.
PureScript. ...

There must be what, 50 odd listed on
[https://github.com/jashkenas/coffeescript/wiki/List-of-
langu...](https://github.com/jashkenas/coffeescript/wiki/List-of-languages-
that-compile-to-JS)

...but I mean, even if we accept that the things you say about clojurescript
are true (and I don't agree that they are, but _even if_ I did), the point I'm
making is that it _doesnt stand out from the crowd_ in terms of features.

Nothing you've described is something that would be missed particularly using
say, typescript, webpack and npm.

------
rdtsc
> Elm, Elixir, JavaScript, seem to be better at prioritizing the humanistic
> aspect. Both in the affordances of the software (Elm’s famous error
> messages), and in person-to-person interactions.

Can't stress that enough. I have observed Elixir community and I have to say
Jose and others did an excellent job fostering a healthy, friendly and warm
community. That is such an essential component. That combined with standing on
a solid, reliable, battle proven platform (Erlang's BEAM VM) makes for a
powerful combination. You see them interact and learn, and ask for help and
you think as a new comer "Right on, I want to hang out with these people".
Then you run some benchmarks, check out some docs, tutorial and think "Yeah I
made the right choice".

So my recommendation if you want to build programming language community -
copy what Elixir did and it will be a good start. That means both community,
outreach, documentation as well a technical foundation.

~~~
pmarreck
I tried Clojure and literally within the first hour got a super ugly Java
stack trace from trying to add two numbers, and that was after already being a
bit miffed by JVM startup time (i'm very big on instant unit test feedback).
Meh.

~~~
ledgerdev
If you attempt to use edit/compile/restart method of development that most
languages use, in the words of south park, "You're gonna have a bad time".

Clojure doesn't make it nearly clear enough that development needs to be
performed interactively against a running instance of your application, with a
REPL integrated into your editor. And yes tests run instantly when doing this.

Anything else is pure pain.

------
systems
clojure's killer app, datomic, is closed source

in my opinion, this is a key reason, why clojure is not thriving

i can't think of any (problem) domain, where clojure have a framework or
library, than is significantly better than most other frameworks or libraries

if you are not number 1 at anything, it is hard to thrive

~~~
swannodette
I use Datomic everyday. While it's certainly a stunning piece of technology
and you could pry it from my cold dead hands, I don't think it has _that_ much
bearing on the growth of the Clojure community.

~~~
derefr
Sure, but that's the point: _if_ Datomic is "the best thing Clojure's got" as
far as killer-apps go—and it's not really that important to the community—then
Clojure doesn't really have a killer app.

A killer app is something that looks like Rails does in Ruby, or Phoenix does
in Elixir: a thing where 50%-or-more of the people learning the language are
only learning it in the context of using that one framework, and so often get
confused as to what's a feature of the language vs. a feature of the
framework.

Which is, y'know, an awful annoyance for the people who use the language for
other things—but boy does it pull people in.

~~~
t3soro
Clojure, and lisp in general, tends to avoid the "framework" way of thinking
prevalent among object-oriented languages. It's therefore no surprise that
something like Rails hasn't taken off.

There are, however, libraries and patterns which are very common, ring for
example.

~~~
derefr
I'm not sure that Clojure avoids it, per se; a framework isn't something you
set out to build by saying "this shall be a framework." A framework is just a
library, exposed directly as functions and data in a given runtime, that has
enough internal structural complexity and "active" logic that the framework
offers high-level abstractions that pre-compose its components into functional
arrangements, rather than expecting you to DSL-glue them together yourself.

Consider: OpenGL/DirectX are essentially "frameworks." They rely on you to
specify the high-level (scenes) by calling the library APIs; the library does
the medium-scale logic of managing the GPU; and then the library calls back to
your code (shaders) to get the low-level details of textures and vertices
specified to it. That's a framework! And there's really no way that it could
be anything _other_ than a framework.

If Clojure doesn't have any "frameworks", that's not because Clojure does
something to avoid making libraries into frameworks; it's more because nobody
has built a library that inherently _is_ a framework, specifically for
Clojure.

------
retrogradeorbit
“What is right is not always popular and what is popular is not always right.”
-- Albert Einstein

I love Clojure, am more productive in it than any other language (and I've
done a lot in my time, including the other FP languages mentioned in this
thread) but I have to concede that most people will just not like it or get
it. And that's fine by me.

I also like alternative music. Most people will never like it. Most people
like mainstream pop. This is also fine by me.

Oh and I certainly would never go back to a mutable-by-default language like
Ruby. I mean if it works for you, do it. But I think you are crazy.

~~~
emperorcezar
I heard somewhere that over half of developers are new to the field.

What disheartens me is that the majority of developers care very little about
programming. They care about things going out the door fast, quality be
damned!

I never thought of Clojure as a language that would catch on to the 90% of
shops out there. That's what ruby and python are for (and of course Java, but
that's for historical marketing reasons.)

What I have thought the niche of Clojure and other languages like it are
larger scale projects and established places that care about robustness and
correctness. Where the wishy washy ways of the pythons and rubies of the world
can can a real issue when not done correctly.

------
jakebasile
I really hope it isn't dying since it's by far the most pleasant language I've
ever worked in. Now that I've spent enough time on it I'd very much like to
use it for the rest of my career. I suppose if it does die out there are other
Lisps available despite the claim that Lisp is dead.

------
lngnmn
Why would you expected a dialect of Lisp to become popular in the Packer's and
Pointy Haired Bosses Paradise (a ready-made ecosystem for sweatshops and
coding factories of easily replaceable coding drones)?

A bit more seriously (which does not mean than anything in the previous
paragraph is less true) the Java ecosystem has been grossly oversold from the
very beginning, and even Rich himself has been converted (I still remember how
I spat when I listened to his praise for Java as the best target platform in
his very first marketing videos).

Clojure has been very well positioned and cleverly promoted (basically
bringing decades of research by very bright people culminating in the Common
Lisp to the Java Land of packers) but there was (and is) no demand for it and
very few of those who could understand and appreciate the principles and ideas
on which it has been founded.

It is dying for the very same reasons that the Common Lisp is still dying -
The Worse Is Better or _Idiots, Idiots Everywhere_.

No one really needs a perfection (approaching perfection) of the great
languages. The popular crap to get shit done for a paycheck (Java, Javascript,
Ruby you name it) is what is in demand.

But this is rather a common pattern. This is exactly how the Upanishadic
philosophy has been degraded into cryptic meaningless tantras, how Buddhism
has been transformed into debased Lamaism, how western philosophy ended up
with Hegelian nonsense and Marxism or what a sophisticated noise we have
instead of Bach. The very same pattern. The world is dominated by idiots and
will always be.

~~~
eggsyntax
"even Rich himself has been converted"

I'd love to know where you learned this, or why you believe this. I'd be very
interested to hear what he had to say about the change of heart.

------
daxfohl
Going further, it seems like the whole category of alternative languages hit a
peak about three years ago, and interest has been dwindling since. It's like
coders got their fix of "new ways of thinking about code", and now have gone
back to whatever they feel most productive in.

Moreover, the buzziest alt languages now (Elixir, Go, Kotlin) seem to be much
closer to existing mainstream languages than the buzzy ones of a couple years
ago.

~~~
tanilama
Ultimately, the value of a piece of code is decided by the functionality it
offers, rather than what language it is written. Thus, project with 'I made X
using Y' formula, while it might be a cool personal achievement, doesn't make
it go beyond the confinement of its intrinsic functionality. A web server
written in clojure, doesn't make it a space rocket, and certainly not making
you a rocket scientist.

~~~
cutler
Alternatively a programming language shapes your way of thinking about a
problem which can in turn affect the quality of the end product. If immutable
data structures and a functional approach produce easier to test, less buggy
code it can be argued those language features contribute to making the world a
safer place.

------
dizzystar
>> Someone asked if their were any Clojure failure stories.

Yes, unfortunately there are a few that I'm aware of. I don't want to go into
detail, but I've definitely gotten more SOS calls than I care to count. I'm
okay cleaning up messes, but Clojure allows developers to really hang
themselves in ways that they can't in other languages simply because you _can
't_ do those things in other languages.

Clojure isn't an easy language to get, or rather, it is easy to reach for very
complex, totally passing up the very simple tools the language gives you. The
language is very simple, and I think that throws a lot of people, especially
if they come from languages with more boilerplate baked in.

Personally, I love Clojure, but I never considered it practical for any team
that is larger than a handful of developers, and it is certainly not safe for
every developer to use. I'm using it on my current project because I'm working
alone, and in keeping it small and focused, I have no plan to change that.

Is Clojure dying? I don't really know. I've never met enough Clojure
developers that stuck with it long enough to move the meter to "massive
uptick," so there isn't much of a down-slope relative to "alive." I've always
seen it as a niche language with a wonderful community. I sometimes joke that
I know all 50 people in the US who actually know how to use the language.

------
j_m_b
I really hope this isn't true, Clojure is my favorite programming language. I
feel that it spoiled me. Builds are easy, code is elegant and easy to parse,
functional programming combined with immutable data structures is beautiful.
It also is great for "full-stack" devs in that there is little context
switching between server and client.

I think the "killer app" that Clojure needs is that it should be compilable
into C/C++ with the same great interop it has with Java. It would be amazing
to be able to utilize all those libraries, all those frameworks, all that
code... in a Clojure REPL!

~~~
j_m_b
Yes, I know there is Chicken Scheme and Guile. I prefer Clojure over them
though.

~~~
cutler
For the niche that Python enjoys (data science, devops, machine learning)
there's also Hy (hylang.org) which has more or less the same syntax as
Clojure. With Clojurescript, Hy and Clojure you can use Clojure syntax in all
3 major layers: front-end, scripting and compiled/back-end.

~~~
j_m_b
Haven't seen Hy yet, thanks for pointing it out! I have been getting back into
machine learning recently and Python dominates. Great to see a Python lisp!

------
ubercow
Clojure's "killer feature" for me is the by-default persistent data
structures.

Are there any other functional languages out there with similar features? Lisp
or otherwise.

~~~
lilactown
Erlang/Elixir also is immutable & persistent by default.

~~~
retrogradeorbit
It is immutable and persistent, but not with the same performance
characteristics. It lacks Bagwell's data structures that allow structural
sharing. Take a 10 million item list in elixir and 'change' (return a new) the
5 millionth element. Time how long it takes. Do the same with clojure.
Compare.

~~~
ramchip
That was true a few years ago, but not anymore:
[https://medium.com/@jlouis666/breaking-erlang-
maps-1-31952b8...](https://medium.com/@jlouis666/breaking-erlang-
maps-1-31952b8729e6)

(You would have to use a map though, the native lists are still plain old
lists)

------
j_m_b
One of the best things about ClojureScript is the build process using lein.
I've had a very stable build for years now, whereas JS has had grunt, growl,
webpack, etc.

~~~
lsdafjklsd
Yup, front end development is light years ahead of JS. sad

~~~
cutler
Exactly. Wave goodbye to Webpack, Babel, Redux, Gulp, Grunt, Browserify,
Brunch, Yeoman and the rest of the usual suspects. I'm baffled as to why
Clojurescript + Leiningen isn't the preferred way. Javascript Stockholm
syndrome perhaps?

~~~
retrogradeorbit
It's true of everything in life. The best is never the most popular. The most
popular is often, frankly, crap. Why would programming be any different?

------
protomyth
I do wonder how much the purchase of Sun (Java) by Oracle and/or the slow down
in Java advancement has affected those languages that a primarily hosted on
the JVM.

~~~
frou_dh
I always thought the Java tie-in was a double-edged sword. For some potential
Clojure users, in addition to learning the language they were interested in,
they'd also have to half-learn a language (and its tooling) that they probably
weren't interested in.

I guess in the US there is/was an assumption that everyone coming out of the
computing education system is already experienced with Java.

~~~
rjeli
I can't find the quote for the of me, but it was from Rich Hickey and went
something like: "First, you use Clojure to escape Java. Then, you use Clojure
to write better Java."

I definitely found it to be true. Clojure takes the good parts of Java's OO
system.

~~~
cutler
Doesn't make any sense as Rich makes a big point of having wasted years
writing large applications in Java and C++ before discovering Lisp and FP. If
anything Clojure is the ultimate anti-OOP which, I think, partly explains its
lack of adoption sitting, as it does, on top of a mass of libraries designed
with OOP.

~~~
rjeli
ok, found it: [https://stuartsierra.com/2008/08/08/clojure-for-the-
semantic...](https://stuartsierra.com/2008/08/08/clojure-for-the-semantic-web)

I think it was in reference to the java ecosystem, more than "a better way to
write java," although I still see it that way.

~~~
cutler
How can Clojure be reduced to "a better way to write Java" when you can live
quite happily in Clojureland without writing a line of Java or importing a
Java library?

------
jasonkostempski
I had never touched Clojure until a few weeks ago. I started learning it
because Spec got me really excited and I want it or something a lot like it
right now.

------
outworlder
So, a keynote on conference about a dying language has mentioned that another,
unrelated language is dying. And people are taking notice.

It does not make sense.

------
mountaineer
Within the monthly HN "who is hiring" posts, Clojure and Ruby appear mostly
flat[1], albeit with Ruby at a much higher level.

[1] [http://www.ryan-williams.net/hacker-news-hiring-
trends/2017/...](http://www.ryan-williams.net/hacker-news-hiring-
trends/2017/may.html?compare1=Clojure&compare2=ruby)

------
iammiles
I spent the better part of 2013 - 2015 learning and working with Clojure. I
love the language and the feeling I got solving little problems like Project
Euler or 4clojure. However, I could never quite transition to feeling
productive making larger projects and found myself using reverting to Scala or
JS instead.

------
agentgt
I'm try to understand how Ruby has any relation to Clojure's purported dying
other than I guess a few critical things were said at a Ruby conference.

What is becoming less popular is dynamically typed languages or perhaps more
correct to say languages who's types are not statically analyzed at compile
time.

So if there is anything hurting Clojure I believe it is the increased uptake
of languages with much better type systems than in the past (Scala, Swift,
Rust, and even Go).

Particularly Go as clearly it is eating a lot of the jaded JVM crowd (that
.NET core should be taking up but for various reasons have not).

Hell even Python is moving towards being more type oriented or at least having
support for optional typing.

That being said I think out of all the dynamic languages Lisp, and thus
Clojure are the best. I even like Elisp. Its the only time I do like a dynamic
language (other than quick shell like scripts) and that is because the runtime
is integrated so heavily with the development that essentially you are getting
your types constantly checked (as well as auto completion and code lookup).

------
dmichulke
Front page rank #22 (after 18hs) with 208 points and 192 comments on HN on a
dying language.

Shouldn't _< put dying thing here>_ be met with a lack of interest?

~~~
rimliu
Some funerals are attended by a large number of people.

~~~
dmichulke
Haha, so people are here to say goodbye to clojure? :)

I think that only works for concrete things, so in OO that would read: objects
can die, classes can't.

------
throwaway7645
This was a really well written article. Nice to see the nod to Larry Wall's
excellent talk on postmodern languages.

~~~
cutler
A lot of people who have never used the language sneer at Perl but I worked
with it almost exclusively for the first 10 years of my programming career and
still have a deep appreciation for the elegance of its design and the great
mind that gave birth to it. Perl is the original linguist's programming
language, superseded by Ruby, some would argue, which in turn was superseded
by Perl6 with its built-in grammars.

~~~
throwaway7645
Yea...really wish Perl6 was more polished now.

------
coliveira
I think Clojure's mistake is to sell itself as a JVM language. Sure, there are
lots of people who love or need to use the JVM, but for everyone else it is a
downside. There is already one language that is the queen of JVM, Java. Every
other language is faded to become a second class citizen.

------
xiaq
There is something missing in the "simple vs. easy" argument. You need to put
things in the perspective of evolution.

Designing an "easy" language is easy because you can usually resort to human
intuitions, yours or somebody's else. Everyone can tell your language is easy
or not; although there is no single criteria of what is easy, it's still
possible to come up with something that many people agree are easy.

Evolving easy languages is also not hard. Just follow the trend and keep
making it easy to do whatever just became popular. Statistics, backend
development, machine learning, whatever. If some early design choice turns out
to be a bad move, just provide alternatives. People don't have very high
expectations about the internal coherency of your langauge, so you have much
freedom in evolving your language.

Designing a "simple" language is much harder because it requires a very deep
understanding of the underlying structure of your runtime environment, the
kinds of systems you want to build with the language, and the structure of
computer programs in general. Appreciating easiness requires experience and
insights, and simple things can appear complex when looking from a different
perspective.

Even if you are super smart and came up with a amazingly simple language,
that's only the beginning. Sooner or later, whether it's new area of
programming or a design mistake surfacing, you need to evolve your language.
And that is hard, because blindly adding features will destroy the simpleness
and your language degenerates into an "easy" one. Instead, you need to
carefully think about the natures of the new requirements, challenge the
assumptions underneath the original design, and restructure your design. This
process is often slow and can be more challenging than the original design
process.

Of course as the article says, "simple" and "easy" is hardly a dichotomy; what
I described are extreme cases, and most if not all languages fall somewhere in
between and exhibit properties from both sides. But I think it's helpful to
think the two dimensions in this way.

------
agumonkey
I have to say, it's been long since I searched for Hickey or clojure conf
talks. Maybe that's just me and there are lots of new valuable stuff, but in a
way it's hard to top cljs, core.logic, datalog in terms of brain wow.

------
georgewsinger
I quit using clojure because (i) no C/C++ FFI, (ii) lack of strong type
system, and (iii) horrific startup times (although clojure itself is fast, its
startup time is not fast).

------
AKifer
Once modern languages like Crystal, Elixir and probably all the rest begin to
allow AST manipulation, the appeal from Lisp dialects diminishes even further
as like when mainstream languages began to ship with a garbage collector.
Clojure like all Lisp is not dead or dying, it's not just for everyone, and
that's fine.

------
BWStearns
I wonder if a microservice library or framework could become the killer
feature to break clojure out of its niche. It could still be used by other jvm
languages, possibly js languages, and wouldn't require betting the farm on it
to try it out.

------
raspasov
Clojure is a tool for people who know their doing by people who know their
doing.

Just like a fine Stradivarius violin. For me the violin would be
indistinguishable from an entry level violin but for the master it's a very
powerful tool.

~~~
discreteevent
That analogy can be used both ways!

"I'm an artist, and if you give me a tuba, I'll bring you something out of it”
- John Lennon.

------
programminggeek
This is odd. I find myself moving to Assembly nowadays.

~~~
wand3r
There will always be room in the market for trendy, abstracted languages like
Assembly that provide simple syntax and garbage collection to sort memory
management. Sometimes I think it's too user friendly though:

    
    
        assembly new project
    

When you scaffold an app like this in assembly you hardly know what it's doing
under the hood.

~~~
city41
I thought programminggeek was making a joke. There's a high level language
called Assembly? If so, it's 100% unsearchable. Or are you joking too? Got any
links?

~~~
wand3r
I think they were serious. I was certainly joking.

------
Pica_soO
These decline and declare articles are programmers equivalent of alien-
abduction tales in dive bars. I was - sniff- abducted by a foreign framework -
sniff- they made me do this - sniff- they made me learn - sniff - put there
knowledge everywhere in my brain. It was horrible. \- sob -

It sounds horrific but you are not bound by oath and vow to the framework you
love. You must not jump ship, you can ride two or three, depending on where
your money comes from.

------
draw_down
For me, there are a number of ideas in Clojure that I think are wonderful. I
just really hate reading and writing lisp code. I can't think of a syntax I
like less, unfortunately, even including junk like Visual Basic.

------
mshenfield
Ultimately a thoughtful read.

------
eth0up
Certainly not this, but it's a great tune anyway:
[https://www.youtube.com/watch?v=8PLE3IjTRb8](https://www.youtube.com/watch?v=8PLE3IjTRb8)
\- The Wurzels, Ruby

~~~
eth0up
^ <step here> ^

------
Grue3
Is Ruby supposed to be an example of "not dying" language? Because it has
certainly passed its glory days as well.

Also Common Lisp is better in every way ;) There's even a JVM implementation
(ABCL) for people who like that sort of stuff.

~~~
swannodette
I don't know but it seems to me Ruby is dying the same way anything else with
200,000+ questions on Stack Overflow is dying (i.e. it isn't).

~~~
dragandj
David, you have to put more bugs in ClojureScript - we need way more questions
on StackOverflow ASAP! :)

------
graphememes
I'm still left with the question of "why all the parenthesis?"

While it might sound silly and reductionist, it is ostensibly the single
hurdle I could never overcome when it came to lisp languages. The majority
resides with the fact that it could work without them, so I see it as an
ancient artifact.

~~~
bryanlarsen
There seems to be a very nice solution to the parenthesis problem:
[https://sourceforge.net/p/readable/wiki/Home/](https://sourceforge.net/p/readable/wiki/Home/)

I have no idea why it hasn't caught on. As far as I'm aware, there's no
Clojure implementation. Lispers like their parentheses.

~~~
flavio81
(we) lispers LOVE our parentheses.

"Elegant weapons... for a more civilized age."

Ref: [https://xkcd.com/297/](https://xkcd.com/297/)

~~~
bbcbasic
I love that particular xkcd

I'm not even a lisper.

