Clojure on Heroku

http://blog.heroku.com/archives/2011/7/5/clojure_on_heroku/

Clojure gains more and more support each day. Are you ready to abandon your obsolete Common Lisips and Schemes in favor of a more modern, agile solution?

Clojure is broken, so no.

>>2
Define broken.

>>3

0]=> clj
Clojure 1.2.1
user=> (remove even? [2 3 4 5])
(3 5)
user=> (binding [filter (fn [& _] "this kind of broken")] (remove even? [2 3 4 5]))
"this kind of broken"
user=>

>>4

;; Referential transparency is what makes functional code ``functional''.
user=> (defn f [x] (first '(1 2 3 4))) ;; this function is referentially transparent, it will discard its argument and return 1.
#'user/f
user=> (f 3)
1
;; I lied, it's not referentially transparent, Clojure, a functional programming language, cannot have referentially transparent functions!
user=> (binding [first rest] (f 3))
(2 3 4)
;; And we also know how well dynamic scope goes with concurrency. A functional programming language with strong support of concurrency indeed!

>>4-5
I don't get it. What I see is optional dynamic scope facilities, Scheme has it too with parameterize, though it's not as transparent because you need to create parameters explicitly with make-parameter.

>>6
The difference is, defn functions are always dynamically scoped, it's not optional, because it expands to def+fn. It would've been ok if it were optional. It would be ok if it worked just inside the current namespace, but it even breaks namespaces boundaries. I haven't tried, but I'm sure it may even break the namespace's encapsulation by leaking private bindings.
And procedures, again, can't be referentially transparent.
You also miss many optimizations: since you can't assume that a function will always have the same value, you can't inline them, you can't inline references to them, you can't do constant folding for user-defined procedures.
This is also bad because Clojure's lexical variables have the nice property of being immutable, which would enable by default most of those optimizations when Scheme compilers must check for any `set!' on that variable instead, but cannot be done because of the dynamically scoped functions.

Clojure cannot into continuations.

>>8
Not even proper tail calls.

Why would I do that when they already offer me everything that I need?

You can't do this in any other lisp: http://thecomputersarewinning.com/post/clojure-heroku-noir-mongo

>>11
Being hipster shit?

>>12
Lol, having a rich useful infrastructure is hipsterish? Using a language with no infrastructure only because it's ``cool" and obscure IS hipsterish.

You are hipster shit.

>>13
You probably didn't look at what the reasonably large amount of libraries and frameworks available for CL and some Schems.

get the fuck out hipster

>>14
The thing is Heroku is not a library, it's a platform that allows to deploy web applications painlessly with only "git commit". Infrastructure is more than just libraries, and that's where other Lisps lack severely.

Common Lisp, for example, has only recently got a centralized library repository with dependency management (Quicklisp) but it's still in beta and not as robust as it can be (a library needs to be added manually by the Quicklisp maintainer to get into the repository). There is nothing like that for Scheme that works across all implementations, only a bunch of incompatible NIH solutions with only Chicken Eggs having a solid amount of frequently updated libraries (PLT Planet, the next biggest repository, is really poor in comparison). And that's only the very basic things, but because they are in a such rough state there's no way to have something more advanced like Heroku. You can't move forward when a solid ground is absent.

And you you won't move with this attitude of calling everything practical ``hipster shit". This attitude is the key, it's not even about a size of community, because Haskell devs managed to create a decent and steadily growing Hackage, regularly release Haskell platforms, etc. There is a bitter irony that Lispers here just love to call Haskell a dead dog.

>>16
The ⁶⁶dead dog⁹⁹ meme is actually an in-joke about an actual dog named Haskell who was introduced to /hipster/ supposedly died. It's the stupidest fucking thing and I'm glad that no one posts that shit anymore.

Anyhow, it's ``ironic'' in the most cliche way how our fellow posters deride anything as hipster-like given that this is the most hipster programming board that I have found, where programming languages are routinely lambasted for being ENTERPRISE (i.e. inelegant and lacking genuineness), where we worship the ``classics'', made with pure ideals (SICP, Scheme, C and maybe Common Lisp), and are generally a bunch of elitist little faggots who obsess over aesthetics and independence, and that is wonderful. Else we'd have Stack Overflow with 4chan memes (also known as /r/programming).

>>17
lolol is ur dof ded

U MENA LISP AND HASKELL

>>17 Your observation rings true.