
Love Letter to Clojure - gigasquid
https://itrevolution.com/love-letter-to-clojure-part-1/
======
juliangamble
> I will discuss the following:

> * What the Second Ideal of Focus, Flow and Joy Means to Me Relearning
> Coding: How Coding Mostly Left My Daily Life in 2008, But Came Back in 2016
> (or If I Can Learn Clojure, Anyone Can)

> * Why I Love LISPs Now

> * Functional Programming and Immutability (and John Carmack)

> * A Mistake I’ve Been Making Since Grad School, and How I Fixed It:
> Composability

> * The Epiphany I Had Reading “An Introduction to React in 2019 (For People
> Who Know Just Enough jQuery To Get By)”

> * What Rich Hickey Says About Simplicity: Where The First Ideal Of Locality
> and Simplicity Comes From

> * Solving Business Problems, Not Solving Puzzles—Why I Detest Doing
> Infrastructure Work These Days

> * Lastly, the REPL…the Ultimate in Fast and Fun Feedback Loops!

> * The Amazing Clojure Community, Parting Thoughts, and What I’d Like To
> Write About in the Future

------
dzpower
I feel similarly to Gene Kim about Racket. Here's a comparison ...

Gene Kim's Clojure example:

    
    
      ; input is JSON string: "{foo: 2}"
    
      (defn xform [s]
        (-> (js/JSON.parse s)
            js->clj
            (update "foo" + 2)
            clj->js
            js/JSON.stringify))
    
    

Racket equivalent:

    
    
      #lang racket
    
      (require threading json)
    
      ; input is (xform "{\"foo\" : 2 }")
    
      (define (xform s)
        (~> s
            string->jsexpr
            (hash-update 'foo (λ (x) (+ 2 x)))
            jsexpr->string))

~~~
reitzensteinm
This is a strange comparison. ClojureScript looks bad here because it's using
the native platform interop rather than a wrapped library, but the ability to
easily drop down and interact with the host is one of the best parts of
Clojure.

~~~
another-one-off
What looks bad about the ClojureScript example? I'm obviously a bit slow, but
I can't see any practical difference between the two.

I do prefer the ClojureScript because I don't know how to type "λ" and that
seems like a usability handicap. Minor complaint I know.

~~~
dzpower
The ClojureScript example is great.

Clojure and by extension ClojureScript has a lot of tasteful and pragmatic
design decisions, e.g. the use of the threading form and implicit lambda
illustrated with the "\+ 2").

By contrast Racket has been extended to include a Clojure-inspired threading
as a library, showing off just a little of its awesome linguistic
extensibility, leading in this case to ergonomically similar code.

Clojure/Script is a wonderful opinionated modern Lisp; Racket is a more
linguistically extensible modern Lisp. There's considerable cross-
fertilisation going on.

If you love Clojure, it's worth keeping an eye on Racket.

* * *

You can spell λ out as lambda in Racket (and Scheme).

------
obfk
As someone fairly new to Clojure I agree entirely. There's a freshness about
the language that has brought a new sense of joy and curiosity back into the
programming world. The language forces you to rethink, relearn, and reevaluate
the way you fundamentally understand programming. I think for the better.

------
seisvelas
I use Racket to create programming languages, however I am considering getting
into Clojure for web development. Racket's web development ecosystem is
actually pretty great, I'm just curious about Clojure's.

Might someone who's played with both give me some pro's and con's of Racket vs
Clojure?

~~~
loosetypes
I’ve heard this a few times - that racket (or any lisp, closure(script) aside)
plays well with the web - but have never seen much to back it up.

Could you point me in the direction of any good resources, libraries, or
communities to dig in further?

~~~
hellofunk
Server side web development is probably the area where Clojure is used most,
perhaps in combination with clojurescript on the front end.

A small google will take you to plenty of resources and libraries.

------
zvrba
> Contrast LISP to the complicated order of precedence operations you find in
> almost every other programming language, as well as their huge grammars and
> syntax. That takes a lot of brain space.

I disagree. I rarely find myself slowed down by the grammar or operator
precedence in Java and C#. In C++, only when I have to do something rather
esoteric (pointer-to-member, member function template specializations, etc.).

On the other hand, I critically rely on types. The IDE is able to narrow down
suggestions about applicable methods to a handful. But since `js->clj` is a
function `string -> map` (a very generic signature), there must be hundreds of
them with the same signature. Context-sensitive discoverability with the help
of IDE becomes nearly useless.

Yes, that's how I learn APIs these days. Types, intellisense + reading the
documentation to learn about possible edge cases. I cannot imagine being
productive in something like Clojure.

I also find Java 11 + VAVR rather pleasant to work with.

~~~
iLemming
> I cannot imagine being productive in something like Clojure.

Of many languages I used (dynamically and statically typed) Clojure turned out
to be the most productive one for me personally.

Nowadays if I have a problem to solve and not allowed to use Clojure, I would
still first prototype it in Clojure and then rewrite it in whatever language.
I am still faster that way.

Some people would argue that Lisps are optimized for writing, but are
difficult to read and maintain. Although I've experienced that to certain
degree with other Lisps, somehow I don't feel that is the case with Clojure.

