Rich Hickey† is a disgusting turd. His very existence is an insult to the legacy of Lisp, the genius of McCarthy, and all the hard work that Lispers have put in over the years. The fact that Clojure runs on the JVM¥ is trivial compared to its other mortal sins, which are so numerous (and make me so angry) that I can't even describe half of them.
Shall I start with the munging-together of value and function names? In a proper Lisp you can instantly recognize head forms by the fact that they're at the head of the list. It was bad enough when Scheme made this ignorant mistake, and worse when Paul "Look at me, I don't even know what interactive development is" Graham copied it. Can't anyone learn from their errors? Oh, and by the way, Scheme tried to remedy this by having "hygienic" macros, which are also completely retarded but at least manage to make it usable. Clojure doesn't even have that. It's completely laughable.
It's not even as if that's the worst part. Not that I need to say it: There's too much syntax! I think Haskell must be Hickey's role model here, since I've never seen another language with as much syntax as Haskell ever in my life. And in Clojure, we get what is easily the most syntax-heavy Lisp-like (it's certainly nothing like Lisp except in the most superficial respects) that has ever been seen. All manner of things that could very easily be done in an ordinary head form style instead wind up littering brackets and delimiters all over the place, even in the simplest of functions. [foo] instead of (list foo), {:foo bar} instead of (dict :foo bar)...
Lambda. It's spelled "lambda," not "fn." Is that too much typing for you, Mr. Hickey? Is it? Did you sprain your wrists masturbating to your unwarranted self-importance? I hope they break off, Mr. Hickey, I hope they break off and you die. Because you've ruined Lisp for a lot of people. You can't even type "lambda?" Seriously? I'm not impressed.
I'm going to have some tea now. I'll be back. Later.
†What the fuck kind of a name is that, anyway?
¥ABCL runs fine on the JVM, I hear. There's no point in making another dialect for that.
Name:
Anonymous2012-09-03 3:21
>>1
OP, you seem knowledgable. I'm curious on your thoughts on newLISP. Is it any good? return false unless user == OP
Name:
Anonymous2012-09-03 4:32
The sooner we get rid of cons the better. The blessing of the cons cell as the ultimate primitive datatype was a fundamentally wrong mistake. What we really need as primitive datatypes are:
— Dynamically-typed cells capable of holding no value (e.g. NIL) or any other value.
— Fixed-precision numbers.
— Statically-typed statically-sized vectors.
— Statically-typed dynamically-sized vectors.
With those, lists, hash tables, a full numerical tower and symbols are trivial to implement with the same efficiency as if they were primitives.
Name:
Anonymous2012-09-03 4:41
>>82 — Statically-typed statically- and dynamically-sized vectors.
These are available in every Lisp out there.
The blessing of the cons cell as the ultimate primitive datatype was a fundamentally wrong mistake.
What is the type of `(my fucking ,(list 1 'x))
>>86
But in >>82 you said you wanted to get rid of cons cells. Suppose that you do -- then what would be the type of the expression in >>83?
Name:
Anonymous2012-09-03 5:52
>>87
It is a vector containing three dynamically-typed cells, the first one holding MY, the second one holding FUCKING, the third one holding (1 X).
Representing lists this way has a lot of advantages:
— The notion of proper and improper lists disappears.
— You can introduce generic EQUAL and COPY functions which would work equally well on arrays, lists, trees, alists.
I want to point out that with a sufficiently-smart implementation concatenation performance wouldn't even suffer since huge dynamically-sized vectors could be implemented as unrolled linked lists.
Name:
Anonymous2012-09-03 6:12
>>88
Now, wouldn't a smart enough interpreter use unrolled linked lists to represent cons lists anyway?
Name:
Anonymous2012-09-03 6:15
>>89
Yes, but the distinction between improper and proper lists introduces a lot of complexity and overhead. And most importantly, it prevents using the same functions on arrays, lists, trees, alists. In my model, list is simply a usage hint for arrays.
Name:
Anonymous2012-09-03 6:46
>>90
I think you got it all wrong. Array is simply a usage hint for lists.
Name:
Anonymous2012-09-03 6:56
>>91
You can think of it that way too. The point remains: there are no cons cells.
>>1
Yes so much syntax... # @ ' ` , list set setf setq
λ. It's spelled "λ". Is that too much typing for you, Mr. Hickey?
I suppose you prefer var x = function () {};... LOL.
Btw, I am λ, haven't you got it?
Name:
Anonymous2012-09-04 16:30
Check em 100 her dubs
Name:
Anonymous2012-09-04 17:22
>>1
The problem with Rich Hickey is that he is Jewish. So he had no insight and great original ideas - he just copied Common Lisp to Java, with a few minor gimmicks, like missing tail-call-optimization and exception-stack-overflow.
Name:
Anonymous2012-09-04 17:48
>>99
You don't understand the difference between functions, macros, and syntax
Name:
Anonymous2012-10-22 9:37
I seriously hate hygienic macros. Really, gensym too hard for ya?
>>104
Symta has more syntax that GHC Haskell with all extensions
Name:
Anonymous2012-10-22 16:32
guy steele, the guy who wrote the common lisp spec and book endorsed clojure. so did dan weinreb, cofounder of symbolics lisp machines. so did gerry sussman
Name:
Anonymous2012-10-22 16:35
old people dont have much intelligence left. even geniuses turn stupid when they grow old. we shouldnt trust the judgment of old people at all.
Name:
Anonymous2012-10-22 23:57
ima haskell
Name:
Anonymous2012-10-23 0:00
im glad there's someone else who sees the err of of clojure's ways
Name:
Anonymous2012-10-23 0:07
>>105
Nope. It's parser is as simple as:
(defun /term ()
(/skip-ws)
(let ((x (/top-char)))
(if (/sym-head? x)
(let ((m (/take-prefix #'/sym-body?)))
(new-sym (/location m) m))
(try n (/num) (/delim)
(when (/sym-head? (/top-char))
(setf n (st (* $n $(/dot)))))
n))))
(defmacro /lop (name down &rest ops) ; left-biased op
`(defun ,name ()
(try a (,down) :fail
(rec r ((e a))
(try o (/op ,@ops) e
(try b (,down) (/error "`~a`: missing right operand" o)
(r (if (and (string= o ".") (integerp e) (integerp b))
(read-from-string (format nil "~a.~a" e b))
(vector o e b)))))))))
(defmacro /rop (name down &rest ops) ; right-biased op
`(defun ,name ()
(try a (,down) :fail
(try o (/op ,@ops) a
(try b (,name) (/error "`~a`: missing right operand" o)
(vector o a b))))))
(defmacro /prop (name down &rest ops) ; prefix op
`(defun ,name ()
(try o (/op ,@ops) (,down)
(try a (,name) (/error "`~a`: missing operand" o)
(if (and (numberp a) (equal o "~")) ;dangerous hack
(- a)
(vector o a))))))
>>1
OP is an idiot..."boo hoo, clojure is different than CL
In a proper Lisp you can instantly recognize head forms by the fact that they're at the head of the list.
the reason clojure is better than CL is that it is not built on cons cells dumbass
There's too much syntax!
no, there is less syntax, clojure is a barebones Lisp, the syntax differences are mainly there to get rid of the over abundance of parens
Lambda. It's spelled "lambda," not "fn."
lambda is not necessary syntax, you can get rid of it all together with quote