From: Javier
Subject: Have you already switched to Clojure?
Date: 
Message-ID: <gov33u$74h$1@aioe.org>
Have you already switched from CL or Scheme to Clojure?


If you did, why?


If not, why not?

From: Marco Antoniotti
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <4c404520-4123-4018-9278-94c845678341@d19g2000yqb.googlegroups.com>
On Mar 8, 1:24 am, Javier <·······@gmail.com> wrote:
> Have you already switched from CL or Scheme to Clojure?

No

>
> If you did, why?
>
> If not, why not?

Too many things lacking at the language level and no significant
advantages library wise.  The JVM and threading niceties are not a
concern for me right now and I think this is the only relative
competitive advantage.

Cheers
--
Marco
From: Vagif Verdi
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <7228f635-d80f-48c1-9613-3d9ecb95040d@l16g2000yqo.googlegroups.com>
On Mar 8, 1:10 am, Marco Antoniotti <·······@gmail.com> wrote:
> Too many things lacking at the language level

Care to elaborate ?
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp12aq$7ma$1@news.motzarella.org>
Vagif Verdi schrieb:
> On Mar 8, 1:10 am, Marco Antoniotti <·······@gmail.com> wrote:
>> Too many things lacking at the language level
> 
> Care to elaborate ?

I suppose he means something like defstruct and defclass, plus the
metaobject protocol. So, built in mechanisms for oop.
Also he may mean: lack of reader macros and some few macro special ops,
such as symbol-macrolet.
I personally see it as a strong advantage of not having built-in support
for OOP. I like that Clojure concentrates more on functional programming.
OOP had enough years, now functional programming has its turn.
Concentrating on a main paradigm can produce more compatible code, and
will make it easier for teams to work together.

Not having (user definable) reader macros.. well, I would like to have
them, but can understand that they may do more harm than good.


Andr�
-- 
Lisp is not dead. It�s just the URL that has changed:
http://clojure.org/
From: neptundancer
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <f12a0126-49ee-4520-ab65-9707416c48f0@j8g2000yql.googlegroups.com>
On Mar 8, 7:21 pm, André Thieme <address.good.until.
···········@justmail.de> wrote:
> Vagif Verdi schrieb:
>
> > On Mar 8, 1:10 am, Marco Antoniotti <·······@gmail.com> wrote:
> >> Too many things lacking at the language level
>
> > Care to elaborate ?
>
> I suppose he means something like defstruct and defclass, plus the
> metaobject protocol. So, built in mechanisms for oop.
> Also he may mean: lack of reader macros and some few macro special ops,
> such as symbol-macrolet.
> I personally see it as a strong advantage of not having built-in support
> for OOP. I like that Clojure concentrates more on functional programming.
> OOP had enough years, now functional programming has its turn.
> Concentrating on a main paradigm can produce more compatible code, and
> will make it easier for teams to work together.
>
> Not having (user definable) reader macros.. well, I would like to have
> them, but can understand that they may do more harm than good.
>
> André
> --
> Lisp is not dead. It’s just the URL that has changed:http://clojure.org/

Funny, that you see absence of such a powerful think like CLOS an
advantage because it's "OOP" (albeit the best OO system used in
practice), and with the same breath you don't mind buying Java
libraries "advantage" and Java interop (main selling point of
Clojure), not bothering that it's built on the very most crippled
"object" system ever designed.
From: jimka
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <128672bb-8c48-4756-b210-e2eee3647767@j38g2000yqa.googlegroups.com>
A couple of things I'm wondering about clojure?

1. Is the fact that CLOS is missing intentional?  I.e., do you want to
prevent it being added? or is it more a matter of priority?   And does
the architecture of clojure prevent its being added later?

2. Clojure seems to be missing some powerful lambda list specification
facilities which other lisps have such as &key and &optional.  It
seems like users are responsible to boilerplate these capabilities out
of the existing & (basically an &rest).   How can I do the equivalent
of (apply fun 1 2 3 others) in clojure?

3. The recure construct seems interesting but quite incomplete.  Maybe
it is a limitation of java, but wouldn't tail call optimization
actually be much more useful that tail recursion?  Tail-recursion
would then simply be a special case.  Tail calls occur in every
function, but recursion in only a few.

4. I did not see anything about backquote, comma, and commat-at.
Macros would be possible but pretty difficult without them (maybe I
just overlooked them).  And doesn't having to deal with vectors and
lists make macros again more difficult.  In other lisps, the fact that
the lambda list and the local bindings inside the LET are represented
as lists, makes them it easy to manipulate in macros.   Do we loose
that simplicity with clojure?

5. Having a <small> language sounds like it has some nice advantages
but only if users can add libraries which look native.  Having macros
seems to enable this, but I wonder how possible it really is to extend
the language at the application level?  Maybe I'm wrong but the
feeling I get is that the language has been intentionally designed to
be restrictive rather than liberating in order to make it interface
well with Java.  If that is the case then there are indeed some
advantages, but it is sad at the same time. :-(  Maybe I'm wrong?  I
hope so.

-jim
From: carlitos
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <8fc2ee42-a1f4-4f51-ac46-7ae045a1c6e1@u1g2000vbb.googlegroups.com>
On Mar 9, 12:03 am, jimka <·····@rdrop.com> wrote:
> A couple of things I'm wondering about clojure?

I'm not an expert (not even a convert... yet), but I can offer a
couple of answers.

> 1. Is the fact that CLOS is missing intentional?  I.e., do you want to
> prevent it being added? or is it more a matter of priority?   And does
> the architecture of clojure prevent its being added later?

This might have been left out of the system intentionally ("Object
Orientation is overrated"), but there are people working on object
systems: http://groups.google.com/group/clojure/browse_thread/thread/ea26e69150fbb15a

> 2. Clojure seems to be missing some powerful lambda list specification
> facilities which other lisps have such as &key and &optional.  It
> seems like users are responsible to boilerplate these capabilities out
> of the existing & (basically an &rest).   How can I do the equivalent
> of (apply fun 1 2 3 others) in clojure?

I'm not sure I understood the last question, (apply fun 1 2 3 others)
is perfectly valid in clojure (assuming "others" is a list or vector
of numbers).

> 4. I did not see anything about backquote, comma, and commat-at.
> Macros would be possible but pretty difficult without them (maybe I
> just overlooked them).  

Backquote (called syntax-quote), tilde (unquote) and tilde-at (unquote-
splicing) are the equivalents in clojure.
For example (from http://clojure.org/reader):
user=> (def x 5)
user=> (def lst '(a b c))
user=> `(fred x ~x lst ·@lst 7 8 :nine)
(user/fred user/x 5 user/lst a b c 7 8 :nine)

Cheers,

Carlos
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp1lob$pi8$1@news.motzarella.org>
jimka schrieb:
> A couple of things I'm wondering about clojure?
> 
> 1. Is the fact that CLOS is missing intentional?  I.e., do you want to
> prevent it being added? or is it more a matter of priority?   And does
> the architecture of clojure prevent its being added later?

It is easy to implement oop in Clojure. That is because you have all
building blocks ready as your tools, that is: functional programming and
macros. Paul Graham btw says that FP and Macros are more powerful than
oop.
You can sit down and build a clone of what is CLOS, and make it even
more powerful, for example by adding aspect oriented programming to it.
Or having the ability to add a full stack of before/after methods, and
have full control over the order in which they run, and be able to
change that during runtime, etc.

In Clojure one typical solution is, that instead of
(defclass bank-account ()
   (customer-name balance))
you would have:
(defstruct bank-account :customer-name :balance)
A struct is Clojure is a factory for maps.
So, the bank-account thing is something like a hash-table.


> 2. Clojure seems to be missing some powerful lambda list specification
> facilities which other lisps have such as &key and &optional.  It
> seems like users are responsible to boilerplate these capabilities out
> of the existing & (basically an &rest).   How can I do the equivalent
> of (apply fun 1 2 3 others) in clojure?

Yes, it may seem this way at a first glance.
In Clojure you don�t give optional arguments. But instead you can have
a function being overloaded by the number of parameters.
Usually you say:
(defn foo [a b c] ...) where ... is the body. But you can also put lists
into the position of the parameter vector:
(defn sum
   ([] 0)
   ([a] a)
   ([a b] (+ a b)))

Here we gave three lists, each containing a parameter vector and a body.
So, if we want to have a function foo taking a number and optionally a
second one, and just returning the number or, when called with a second
argument, returning their sum, we could say:
(defn foo
   ([a] (foo a 0))
   ([a b] (+ a b))

This function just illustrates how you can handle optional arguments.
Instead of keyword arguments you have your function accept a hashmap.
This is very comfortable in Clojure, as it comes with this handy reader
macro {} for that case.

(some-function {:name "Peter" :age 4})

&rest arguments are handled by &.
(defn sum [& numbers]
   (apply + numbers))

One thing that I never want to miss again is the built-in automatic
destructuring.
(defn foo [[a b & r] n]
   (println a b)
   (+ (count r) n))

(foo (range 10 20) 1000) ==> will print 10 11  and return 1008
(range 10 20) ==> (10 11 12 13 14 15 16 17 18 19)
The 10 is bound to the a, the 11 to the b and the rest to r.


> 3. The recure construct seems interesting but quite incomplete.  Maybe
> it is a limitation of java, but wouldn't tail call optimization
> actually be much more useful that tail recursion?  Tail-recursion
> would then simply be a special case.  Tail calls occur in every
> function, but recursion in only a few.

The recur is actually a nice thing to have in Clojure.
It allows anonymous functions to recursively call themselves and it also
makes sure that the call really takes place in the tail position. Only
in that the compiler will compile the code.
People are currently working on TCO for the Open-JDK it seems. But even
when the JVM can do it, Clojure will keep recur, and it is idiomatic to
use that.


> 4. I did not see anything about backquote, comma, and commat-at.
> Macros would be possible but pretty difficult without them (maybe I
> just overlooked them).  And doesn't having to deal with vectors and
> lists make macros again more difficult.  In other lisps, the fact that
> the lambda list and the local bindings inside the LET are represented
> as lists, makes them it easy to manipulate in macros.   Do we loose
> that simplicity with clojure?

No, we don�t lose it, and it even gets better.
It is true that there is no comma and comma-at. But instead there is
tilde and tilde-at.
(defmacro my-when [test & body]
   `(if ~test (do @~body)))

The nice thing here is that Clojures backquote expands symbols fully,
including their namespace. So when I (macroexpand-1 (my-when ..)) it
then will not expand into an (if ..) but instead into
(clojure.core/if ...)
As the compiler forbids to bind things to these fully qualified names
it protects you to some extent from erros in your macro code.
Also it is so much nicer to use gensyms in Clojure than it is in CL,
in my opinion.
You need gensym much less often. Just append a # to the end of the var
which you wish to be a gensym. For example, look at the macro for and:
(defmacro and
   "Evaluates exprs one at a time, from left to right. If a form
   returns logical false (nil or false), and returns that value and
   doesn't evaluate any of the other expressions, otherwise it returns
   the value of the last expr. (and) returns true."
   ([] true)
   ([x] x)
   ([x & next]
    `(let [and# ~x]
       (if and# (and ·@next) and#))))

Here we bind ~x to and#.
In the expansion the and# will be replaced by something like
and__3226__auto__
Beautiful.

Yes, it is just a small thing, but those add up in Clojure.
We humans are mildly happy if something makes our life easier.
But we react much more harsh if even small things get lost.
So, when you come to Clojure you will maybe not be overwhelmed by how
cool it is. However, after some time you will see that it is difficult
to go back to CL. It lacks too many things.


> 5. Having a <small> language sounds like it has some nice advantages
> but only if users can add libraries which look native.  Having macros
> seems to enable this, but I wonder how possible it really is to extend
> the language at the application level?  Maybe I'm wrong but the
> feeling I get is that the language has been intentionally designed to
> be restrictive rather than liberating in order to make it interface
> well with Java.  If that is the case then there are indeed some
> advantages, but it is sad at the same time. :-(  Maybe I'm wrong?  I
> hope so.

Jim, what I liked about your posting was that you asked questions.
You presented your first impression and put everything politely into
questions/assumptions. That is much nicer than what several other people
here in c.l.l., who just explain what is wrong in Clojure, without ever
haven written a single line of code in it.
Your ideas about Clojure are still vague, and you can definitly optimize
your knowledge in that area. I invite you to have a closer look, and be
prepared for enjoying it :)
You will like what you see.


Andr�
-- 
Lisp is not dead. It�s just the URL that has changed:
http://clojure.org/
From: Javier
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp224j$h3c$1@aioe.org>
Andr� Thieme wrote:

[...]

This is pretty impressive....

I have the impression that CLOS is the only thing that Clojure doesn't
have, but that is because Clojure is meant to be (almost) purely
functional. For everything else, Clojure seems to be pretty modern and
convenient.

I have a question... what about performance? Can it be compared with,
for example, SBCL?
From: William James
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp2bnp02v3t@enews2.newsguy.com>
Javier wrote:

> I have a question... what about performance? Can it be compared with,
> for example, SBCL?

I don't know, but for floating-point calculations, it can be faster
than compiled OCaml:

http://groups.google.com/group/comp.lang.functional/browse_thread/thread/99b8230c078d9b44#
 

However, it seems a lot slower than OCaml where only integers are
involved.
From: Pillsy
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <64462ddd-f834-4614-a113-d610674ac51f@s19g2000vbp.googlegroups.com>
On Mar 8, 11:25 pm, Javier <·······@gmail.com> wrote:
[...]
> I have the impression that CLOS is the only thing that Clojure doesn't
> have, but that is because Clojure is meant to be (almost) purely
> functional.

AIUI, Clojure also lacks the CL condition system, which is easy to
overlook, but is nonetheless an extremely nice thing to have, and one
that I find myself missing more and more when I'm not programming in
CL (which is most of the time these days).

Cheers,
Pillsy
From: J Kenneth King
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <87ab7uso90.fsf@agentultra.com>
Pillsy <·········@gmail.com> writes:

> On Mar 8, 11:25 pm, Javier <·······@gmail.com> wrote:
> [...]
>> I have the impression that CLOS is the only thing that Clojure doesn't
>> have, but that is because Clojure is meant to be (almost) purely
>> functional.
>
> AIUI, Clojure also lacks the CL condition system, which is easy to
> overlook, but is nonetheless an extremely nice thing to have, and one
> that I find myself missing more and more when I'm not programming in
> CL (which is most of the time these days).
>
> Cheers,
> Pillsy

That's one of the first things I noticed.

I also noticed that it compiles to JVM code but doesn't dump or load
images.

The way it does function parameters is kind of awkward too.

However, after a presentation on Clojure by the local lisp group I only
managed to get the impression that it was a lispy-java.

Unless you need to produce software to run on the JVM (and you hate
programming in Java) there's no real reason to give up CL AFAIK. Clojure
doesn't replace anything in CL with something better. It's just a niche
tool IMO, not a full replacement.
From: Pascal J. Bourguignon
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <7c7i2yg0l5.fsf@pbourguignon.anevia.com>
J Kenneth King <·····@agentultra.com> writes:

> Unless you need to produce software to run on the JVM (and you hate
> programming in Java) there's no real reason to give up CL AFAIK. Clojure
> doesn't replace anything in CL with something better. It's just a niche
> tool IMO, not a full replacement.

For this use case, there's already ABCL and CLforJava.

-- 
__Pascal Bourguignon__
From: J Kenneth King
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <8763iisgrx.fsf@agentultra.com>
···@informatimago.com (Pascal J. Bourguignon) writes:

> J Kenneth King <·····@agentultra.com> writes:
>
>> Unless you need to produce software to run on the JVM (and you hate
>> programming in Java) there's no real reason to give up CL AFAIK. Clojure
>> doesn't replace anything in CL with something better. It's just a niche
>> tool IMO, not a full replacement.
>
> For this use case, there's already ABCL and CLforJava.

Then you really can have your cake and eat it too.

<3 CL.
From: Pillsy
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <7ae80de5-c9ca-4498-80f2-769db5eb2613@r34g2000vbp.googlegroups.com>
On Mar 8, 7:52 pm, André Thieme <address.good.until.
···········@justmail.de> wrote:
[...]
> Paul Graham btw says that FP and Macros are more powerful than oop.

I might agree in the sense that if you said, "OK, Pillsy. Macros, FP
or an object system: pick two," I'd pick macros and FP, but that
doesn't mean I wouldn't rather have all three. Just because you can
roll your own object system out of macros and closures doesn't mean
that it's easy to get right, or particularly enjoyable.

IME, CLOS works very well alongside HOFs and macros. It's not like you
have to stop using functional programming or syntactic abstractions
one you have a DEFCLASS or two.
[...]
> The nice thing here is that Clojures backquote expands symbols fully,
> including their namespace.

What in the world makes you think that the Common Lisp backquote
doesn't keep track of symbols' packages?

> So when I (macroexpand-1 (my-when ..)) it
> then will not expand into an (if ..) but instead into
> (clojure.core/if ...)

Er, so what? That's just a feature of how the printer works, and if
you want to emulate that behavior in CL, it's quite doable.

* (let ((*package* (find-package :keyword)))
    (format t "~S" (macroexpand-1 `(or ,'x y z))))
(COMMON-LISP:COND (COMMON-LISP-USER::X) (COMMON-LISP-USER::Y)
 (COMMON-LISP:T COMMON-LISP-USER::Z))
NIL
[...]

Cheers,
Pillsy
From: ·······@gmail.com
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <e14cfc41-f3a3-454f-ace5-161aacbf1f9f@s28g2000vbp.googlegroups.com>
On Mar 9, 7:36 am, Pillsy <·········@gmail.com> wrote:
> On Mar 8, 7:52 pm, André Thieme <······························@justmail.de> wrote:
> > So when I (macroexpand-1 (my-when ..)) it
> > then will not expand into an (if ..) but instead into
> > (clojure.core/if ...)
>
> Er, so what? That's just a feature of how the printer works

From CL's perspective this is a "so what"; from Scheme's perspective
it
is a "d'oh upside the head".  The hack of having ` intern symbols into
namespaces, of having this normally not happen, permits Clojure to
have
a DEFMACRO with its lisp-1 instead of Scheme's assortment of inferior
systems.

(ns a)
(defmacro aif [test then else]
  `(let [val# ~test]
     (if val#
       (let [~'it val#] ~then)
       ~else)))
(ns b)
(refer 'a :only '[aif])
(aif 1 it 2) => 1
(macroexpand '(aif 1 it 2))
=>
(let* [val__7__auto__ 1] (clojure.core/if val__7__auto__ (clojure.core/
let [it __val__7_auto__] it) 2))
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp3t6d$84t$1@news.motzarella.org>
Pillsy schrieb:
> On Mar 8, 7:52 pm, Andr� Thieme <address.good.until.
> ···········@justmail.de> wrote:
> [...]
>> Paul Graham btw says that FP and Macros are more powerful than oop.
> 
> I might agree in the sense that if you said, "OK, Pillsy. Macros, FP
> or an object system: pick two," I'd pick macros and FP, but that
> doesn't mean I wouldn't rather have all three. Just because you can
> roll your own object system out of macros and closures doesn't mean
> that it's easy to get right, or particularly enjoyable.
> 
> IME, CLOS works very well alongside HOFs and macros. It's not like you
> have to stop using functional programming or syntactic abstractions
> one you have a DEFCLASS or two.

It does not mix too well. You will have to decide if you want to produce
clos objects or lightweight closure objects.
Will Paul Grahams accumulator be a class? Just for illustrative purposes
I will give this example:

(defun make-accumulator (n)
   (lambda (i) (incf n i)))

It's short readable code, fast, lightweight.
Now later you decide you wish to reset the accumulator object.
How easy is it to do it via CLOS mechanisms?
You could change the definition of that function and return a
list of functions. But then you have to change already written code.

In teams/companies it means that more meetings are needed, more
code management, etc.
If your company decides to use CLOS/FP for everything then the
course is much more clear. Code of workmates is more likely to be
compatible, or can be made more easily compatible.

> Er, so what? That's just a feature of how the printer works, and if
> you want to emulate that behavior in CL, it's quite doable.
> 
> * (let ((*package* (find-package :keyword)))
>     (format t "~S" (macroexpand-1 `(or ,'x y z))))
> (COMMON-LISP:COND (COMMON-LISP-USER::X) (COMMON-LISP-USER::Y)
>  (COMMON-LISP:T COMMON-LISP-USER::Z))

CL:
CL-USER> (defparameter x 100)
CL-USER> (defmacro foo (x &rest body)
            `(let ((x 10))
               (progn (print x)
                      ,@body)))
CL-USER> (foo 8 (+ x 5))

10
15


CLJ:
(def x 100)
user> (defmacro foo [x & body]
         `(let [x 10]
            (do (println x)
                ·@body)))
user> (foo 8 (+ x 5))
==> java.lang.Exception: Can't let qualified name: user/x

But
user> (defmacro foo [x & body]
         `(let [x# 10]
            (do (println x#)
                ·@body)))
user> (foo 8 (+ x 5))
10
105


Andr�
-- 
Lisp is not dead. It�s just the URL that has changed:
http://clojure.org/
From: Pillsy
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <4a516cc0-2bed-456a-a5a0-23c28c4eb4f2@41g2000yqf.googlegroups.com>
On Mar 9, 4:11 pm, André Thieme <address.good.until.
···········@justmail.de> wrote:
> Pillsy schrieb:
>
> > On Mar 8, 7:52 pm, André Thieme <address.good.until.
> > ···········@justmail.de> wrote:
[...]
> > IME, CLOS works very well alongside HOFs and macros. It's not like you
> > have to stop using functional programming or syntactic abstractions
> > one you have a DEFCLASS or two.

> It does not mix too well. You will have to decide if you want to produce
> clos objects or lightweight closure objects.

Yes. On the other hand, I actually get to make that decision, which is
nice.

> Will Paul Grahams accumulator be a class? Just for illustrative purposes
> I will give this example:

> (defun make-accumulator (n)
>    (lambda (i) (incf n i)))

> It's short readable code, fast, lightweight.

It's also not, well, functional, what with that INCF in there.

> Now later you decide you wish to reset the accumulator object.
> How easy is it to do it via CLOS mechanisms?

Very easy. I just change

(defun bump (accumulator &optional (delta 1))
  (funcall accumulator delta))

to

(defgeneric bump (accumulator &optional delta)
  (:method ((accumulator counter) &optional (delta 1))
    (incf (slot-value 'count counter) delta))
  (:method ((accumulator function) &optional (delta 1))
    (funcall counter delta)))

Then I change make-accumulator so it uses MAKE-INSTANCE, write my
generic function for reset, and I'm all done. What would I have done
if I didn't have CLOS? I'd either have to do something where I return
multiple closures, either in a list or using values, or I'd write the
sort of thing you see in some Scheme books and the like, where I'd
have to have make-counter become something like this:

(defun make-counter (counter)
  (let (n 0)
    (lambda (msg &rest args)
      (ecase msg
        ((:bump)  (incf n (if args (car args) 1))
        ((:reset) (setf n 0)))))

and then change bump:

(defun bump (counter &optional (delta 1))
  (funcall counter :bump delta))

It sure isn't any less work, and I've had to spend some time
Greenspunning my own not-terribly-useful object system.

> You could change the definition of that function and return a
> list of functions. But then you have to change already written code.

I'd have to change already written code either way, now, wouldn't I?
But this way, I'd have to change a whole lot less.
[...]
> > Er, so what? That's just a feature of how the printer works, and if
> > you want to emulate that behavior in CL, it's quite doable.

> > * (let ((*package* (find-package :keyword)))
> >     (format t "~S" (macroexpand-1 `(or ,'x y z))))
> > (COMMON-LISP:COND (COMMON-LISP-USER::X) (COMMON-LISP-USER::Y)
> >  (COMMON-LISP:T COMMON-LISP-USER::Z))

> CL:
> CL-USER> (defparameter x 100)
> CL-USER> (defmacro foo (x &rest body)
>             `(let ((x 10))
>                (progn (print x)
>                       ,@body)))
> CL-USER> (foo 8 (+ x 5))

> 10
> 15

> CLJ:
> (def x 100)
> user> (defmacro foo [x & body]
>          `(let [x 10]
>             (do (println x)
>                 ·@body)))
> user> (foo 8 (+ x 5))
> ==> java.lang.Exception: Can't let qualified name: user/x

What the gibbering green hell is the point of *that*!?

Cheers,
Pillsy
From: Pascal J. Bourguignon
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <87prgqwefp.fsf@galatea.local>
Andr� Thieme <······························@justmail.de> writes:

> Pillsy schrieb:
>> On Mar 8, 7:52 pm, Andr� Thieme <address.good.until.
>> ···········@justmail.de> wrote:
>> [...]
>>> Paul Graham btw says that FP and Macros are more powerful than oop.
>> I might agree in the sense that if you said, "OK, Pillsy. Macros, FP
>> or an object system: pick two," I'd pick macros and FP, but that
>> doesn't mean I wouldn't rather have all three. Just because you can
>> roll your own object system out of macros and closures doesn't mean
>> that it's easy to get right, or particularly enjoyable.
>> IME, CLOS works very well alongside HOFs and macros. It's not like
>> you
>> have to stop using functional programming or syntactic abstractions
>> one you have a DEFCLASS or two.
>
> It does not mix too well. You will have to decide if you want to produce
> clos objects or lightweight closure objects.
> Will Paul Grahams accumulator be a class? Just for illustrative purposes
> I will give this example:
>
> (defun make-accumulator (n)
>   (lambda (i) (incf n i)))
>
> It's short readable code, fast, lightweight.
> Now later you decide you wish to reset the accumulator object.
> How easy is it to do it via CLOS mechanisms?
> You could change the definition of that function and return a
> list of functions. But then you have to change already written code.

That's funny.  The above is purely functional.  That is in the style
promoted by Clojure.  What happen in Clojure when you need to add
features, such as resetting accumulators?  You have to change
definition of functions, return lists of functions, change already
written code!

Here is how easy it is to do via CLOS.   Remember that closure <=>
object.  But there's an expressive power difference: objects are
cracked open, you may have access directly to the bindings or to the
functions of the objects. 

(defclass accumulator ()
  ((n :initarg :n)))

(defmethod inc ((self accumulator) i)
   (incf (slot-value self 'n) i))


So now you want to be able to reset the accumulator?

(defmethod reset ((self accumulator) n)
   (setf (slot-value self 'n) n))

Nothing to change in existing code.

Try to do that in Clojure!


> In teams/companies it means that more meetings are needed, more
> code management, etc.
> If your company decides to use CLOS/FP for everything then the
> course is much more clear. Code of workmates is more likely to be
> compatible, or can be made more easily compatible.

It seems to me that a company will choose to use CLOS sooner than
Clojure...

-- 
__Pascal Bourguignon__
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp45l6$vfa$1@news.motzarella.org>
Pascal J. Bourguignon schrieb:
> Andr� Thieme <······························@justmail.de> writes:

>> Will Paul Grahams accumulator be a class? Just for illustrative purposes
>> I will give this example:
>>
>> (defun make-accumulator (n)
>>   (lambda (i) (incf n i)))
>>
>> It's short readable code, fast, lightweight.
>> Now later you decide you wish to reset the accumulator object.
>> How easy is it to do it via CLOS mechanisms?
>> You could change the definition of that function and return a
>> list of functions. But then you have to change already written code.
> 
> That's funny.  The above is purely functional.  That is in the style
> promoted by Clojure.  What happen in Clojure when you need to add
> features, such as resetting accumulators?  You have to change
> definition of functions, return lists of functions, change already
> written code!

First of all, the above is not purely functional. Take a look again.
There is a state change.
And I had exactly in mind what you said when I wrote this.
This example was given, as I wrote, for illustrative purposes only.
Neither in Clojure nor in CL would one write such a factory, if it were
not for a very specific case.
What I wrote was for giving the idea of how closures can interact with
CLOS, and without some pre-planning it can not always be done so easily.


> Here is how easy it is to do via CLOS.   Remember that closure <=>
> object.  But there's an expressive power difference: objects are
> cracked open, you may have access directly to the bindings or to the
> functions of the objects. 
> 
> (defclass accumulator ()
>   ((n :initarg :n)))
> 
> (defmethod inc ((self accumulator) i)
>    (incf (slot-value self 'n) i))
> 
> 
> So now you want to be able to reset the accumulator?
> 
> (defmethod reset ((self accumulator) n)
>    (setf (slot-value self 'n) n))
> 
> Nothing to change in existing code.
> 
> Try to do that in Clojure!

Yes, the CLOS solution is extensible this way.
In Clojure I would need to have a mutable object. An atom could
be the right thing:

(defn make-accumulator [n] (atom n))
(defn inc-accu [accu i] (swap! accu + i))
(defn reset-accu [accu i] (reset! accu i))

user> (def x (make-accumulator 15))
#'user/x
user> (inc-accu x 4)
19
user> (inc-accu x 2)
21
user> @x
21

Now this Clojure code is concurrency ready. You can read the
value of any accu at any time without locks. And you can also
inc/reset it any time without locks, from any number of threads
your system supports, and you will not run into corrupt data.
But okay, I did not ask for concurrency ready code.
Your solution is fine and extensible. One can add methods and
does not need to change existing code.
However, I was not keen to see the CL solution, as I had more
than a vague idea of how it could look like. My whole point was
to mention that functional programming does not automatically
mixes well with CLOS.


Andr�
-- 
Lisp is not dead. It�s just the URL that has changed:
http://clojure.org/
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp46rj$bjd$1@news.motzarella.org>
Andr� Thieme schrieb:
> (defn make-accumulator [n] (atom n))
> (defn inc-accu [accu i] (swap! accu + i))
> (defn reset-accu [accu i] (reset! accu i))
> 
> user> (def x (make-accumulator 15))
> #'user/x
> user> (inc-accu x 4)
> 19
> user> (inc-accu x 2)
> 21
> user> @x
> 21
> 
> Now this Clojure code is concurrency ready.

Just an example to test it:
user> (def x (make-accumulator 0))
user> (dotimes [i 10] (future (inc-a-lot x 1000000)))

We will always end up with (= @x 10000000) ==> true

Btw, for readers of c.l.l new to concurrent programming may want to have
a look at this video:
http://rubyconf2008.confreaks.com/what-all-rubyist-should-know-about-threads.html

It was recorded during a Ruby conference, but what Jim explains there
can be of interest for many.


Andr�
-- 
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp4933$31m$1@news.motzarella.org>
Andr� Thieme schrieb:
> Just an example to test it:

Forgot
(defn inc-a-lot [accu n] (dotimes [i n] (inc-accu accu 1)))
From: Pascal Costanza
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71mq7eFlocr2U2@mid.individual.net>
Andr� Thieme wrote:
> Pascal J. Bourguignon schrieb:
>> Andr� Thieme <······························@justmail.de> writes:
> 
>>> Will Paul Grahams accumulator be a class? Just for illustrative purposes
>>> I will give this example:
>>>
>>> (defun make-accumulator (n)
>>>   (lambda (i) (incf n i)))
>>>
>>> It's short readable code, fast, lightweight.
>>> Now later you decide you wish to reset the accumulator object.
>>> How easy is it to do it via CLOS mechanisms?
>>> You could change the definition of that function and return a
>>> list of functions. But then you have to change already written code.
>>
>> That's funny.  The above is purely functional.  That is in the style
>> promoted by Clojure.  What happen in Clojure when you need to add
>> features, such as resetting accumulators?  You have to change
>> definition of functions, return lists of functions, change already
>> written code!
> 
> First of all, the above is not purely functional. Take a look again.
> There is a state change.
> And I had exactly in mind what you said when I wrote this.
> This example was given, as I wrote, for illustrative purposes only.
> Neither in Clojure nor in CL would one write such a factory, if it were
> not for a very specific case.
> What I wrote was for giving the idea of how closures can interact with
> CLOS, and without some pre-planning it can not always be done so easily.

Which is wrong, see my other post.

>> Here is how easy it is to do via CLOS.   Remember that closure <=>
>> object.  But there's an expressive power difference: objects are
>> cracked open, you may have access directly to the bindings or to the
>> functions of the objects.
>> (defclass accumulator ()
>>   ((n :initarg :n)))
>>
>> (defmethod inc ((self accumulator) i)
>>    (incf (slot-value self 'n) i))
>>
>>
>> So now you want to be able to reset the accumulator?
>>
>> (defmethod reset ((self accumulator) n)
>>    (setf (slot-value self 'n) n))
>>
>> Nothing to change in existing code.
>>
>> Try to do that in Clojure!
> 
> Yes, the CLOS solution is extensible this way.
> In Clojure I would need to have a mutable object. An atom could
> be the right thing:
> 
> (defn make-accumulator [n] (atom n))
> (defn inc-accu [accu i] (swap! accu + i))
> (defn reset-accu [accu i] (reset! accu i))
> 
> user> (def x (make-accumulator 15))
> #'user/x
> user> (inc-accu x 4)
> 19
> user> (inc-accu x 2)
> 21
> user> @x
> 21
> 
> Now this Clojure code is concurrency ready. 

...but too inefficient in case you know that it will be used in a single 
thread only.


Pascal

-- 
ELS'09: http://www.european-lisp-symposium.org/
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp99gl$ref$1@news.motzarella.org>
Pascal Costanza schrieb:
> Andr� Thieme wrote:

>> (defn make-accumulator [n] (atom n))
>> (defn inc-accu [accu i] (swap! accu + i))
>> (defn reset-accu [accu i] (reset! accu i))
>>
>> user> (def x (make-accumulator 15))
>> #'user/x
>> user> (inc-accu x 4)
>> 19
>> user> (inc-accu x 2)
>> 21
>> user> @x
>> 21
>>
>> Now this Clojure code is concurrency ready. 
> 
> ...but too inefficient in case you know that it will be used in a single 
> thread only.

I can agree on this code being less efficient in a single threaded
program. I just want to go so far to say it would be too inefficient.
This depends on the problem domain. Although, if efficiency was in play,
then I suggest to run the code on todays hardware, that is, quadcore boxes.


Andr�
-- 
Lisp is not dead. It�s just the URL that has changed:
http://clojure.org/
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp9mp5$qgu$1@news.motzarella.org>
Andr� Thieme schrieb:
> I just want to go so far to say it would be too inefficient.
         ^
       don't


Andr�
-- 
From: Pascal Costanza
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71mq40Flocr2U1@mid.individual.net>
Andr� Thieme wrote:
> Pillsy schrieb:
>> On Mar 8, 7:52 pm, Andr� Thieme <address.good.until.
>> ···········@justmail.de> wrote:
>> [...]
>>> Paul Graham btw says that FP and Macros are more powerful than oop.
>>
>> I might agree in the sense that if you said, "OK, Pillsy. Macros, FP
>> or an object system: pick two," I'd pick macros and FP, but that
>> doesn't mean I wouldn't rather have all three. Just because you can
>> roll your own object system out of macros and closures doesn't mean
>> that it's easy to get right, or particularly enjoyable.
>>
>> IME, CLOS works very well alongside HOFs and macros. It's not like you
>> have to stop using functional programming or syntactic abstractions
>> one you have a DEFCLASS or two.
> 
> It does not mix too well. You will have to decide if you want to produce
> clos objects or lightweight closure objects.
> Will Paul Grahams accumulator be a class? Just for illustrative purposes
> I will give this example:
> 
> (defun make-accumulator (n)
>   (lambda (i) (incf n i)))
> 
> It's short readable code, fast, lightweight.
> Now later you decide you wish to reset the accumulator object.
> How easy is it to do it via CLOS mechanisms?

(defclass accumulator ()
   ((counter :initarg :counter :accessor counter))
   (:metaclass funcallable-standard-class))

(defun make-accumulator (n)
   (let ((object (make-instance 'accumulator :counter n)))
     (set-funcallable-instance-function object
      (with-slots ((n counter)) object
        (lambda (i) (incf n i))))
     object))

 > (defvar x (make-accumulator 2))
X

 > (funcall x 3)
5

 > (funcall x 4)
9

 > (setf (counter x) 0)
0

 > (funcall x 5)
5

 > (funcall x 6)
11


What was your problem again?


Pascal

-- 
ELS'09: http://www.european-lisp-symposium.org/
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
From: Pascal Costanza
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71k3thFlbdkhU1@mid.individual.net>
Andr� Thieme wrote:
> jimka schrieb:
>> A couple of things I'm wondering about clojure?
>>
>> 1. Is the fact that CLOS is missing intentional?  I.e., do you want to
>> prevent it being added? or is it more a matter of priority?   And does
>> the architecture of clojure prevent its being added later?
> 
> It is easy to implement oop in Clojure.

http://mumble.net/~jar/pubs/oopis.ps

> That is because you have all
> building blocks ready as your tools, that is: functional programming and
> macros.

It gets considerably harder if you want to make this efficient.

> Paul Graham btw says that FP and Macros are more powerful than oop.

Paul Graham says a lot.

> You can sit down and build a clone of what is CLOS, and make it even
> more powerful, for example by adding aspect oriented programming to it.

http://common-lisp.net/project/closer/aspectl.html

> Or having the ability to add a full stack of before/after methods, and
> have full control over the order in which they run, 

http://www.lispworks.com/documentation/HyperSpec/Body/m_defi_4.htm

> and be able to
> change that during runtime, etc.

http://common-lisp.net/project/closer/contextl.html

> In Clojure one typical solution is, that instead of
> (defclass bank-account ()
>   (customer-name balance))
> you would have:
> (defstruct bank-account :customer-name :balance)
> A struct is Clojure is a factory for maps.
> So, the bank-account thing is something like a hash-table.

http://infolab.stanford.edu/~paepcke/shared-documents/mopintro.ps



Pascal

-- 
ELS'09: http://www.european-lisp-symposium.org/
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
From: Javier
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp2n65$1ko$1@aioe.org>
Pascal Costanza escribi�:
> Andr� Thieme wrote:
>> jimka schrieb:
>>> A couple of things I'm wondering about clojure?
>>>
>>> 1. Is the fact that CLOS is missing intentional?  I.e., do you want to
>>> prevent it being added? or is it more a matter of priority?   And does
>>> the architecture of clojure prevent its being added later?
>>
>> It is easy to implement oop in Clojure.
> 
> http://mumble.net/~jar/pubs/oopis.ps
> 
>> That is because you have all
>> building blocks ready as your tools, that is: functional programming and
>> macros.
> 
> It gets considerably harder if you want to make this efficient.
> 
>> Paul Graham btw says that FP and Macros are more powerful than oop.
> 
> Paul Graham says a lot.
> 
>> You can sit down and build a clone of what is CLOS, and make it even
>> more powerful, for example by adding aspect oriented programming to it.
> 
> http://common-lisp.net/project/closer/aspectl.html
> 
>> Or having the ability to add a full stack of before/after methods, and
>> have full control over the order in which they run, 
> 
> http://www.lispworks.com/documentation/HyperSpec/Body/m_defi_4.htm
> 
>> and be able to
>> change that during runtime, etc.
> 
> http://common-lisp.net/project/closer/contextl.html
> 
>> In Clojure one typical solution is, that instead of
>> (defclass bank-account ()
>>   (customer-name balance))
>> you would have:
>> (defstruct bank-account :customer-name :balance)
>> A struct is Clojure is a factory for maps.
>> So, the bank-account thing is something like a hash-table.
> 
> http://infolab.stanford.edu/~paepcke/shared-documents/mopintro.ps




You broke my illusions....


do we need to stick with CL anyway?
From: Marco Antoniotti
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <b5900557-85c6-4947-ae2a-587267f03832@e15g2000vbe.googlegroups.com>
On Mar 9, 10:25 am, Javier <·······@gmail.com> wrote:
> Pascal Costanza escribió:
>
>
>
> > André Thieme wrote:
> >> jimka schrieb:
> >>> A couple of things I'm wondering about clojure?
>
> >>> 1. Is the fact that CLOS is missing intentional?  I.e., do you want to
> >>> prevent it being added? or is it more a matter of priority?   And does
> >>> the architecture of clojure prevent its being added later?
>
> >> It is easy to implement oop in Clojure.
>
> >http://mumble.net/~jar/pubs/oopis.ps
>
> >> That is because you have all
> >> building blocks ready as your tools, that is: functional programming and
> >> macros.
>
> > It gets considerably harder if you want to make this efficient.
>
> >> Paul Graham btw says that FP and Macros are more powerful than oop.
>
> > Paul Graham says a lot.
>
> >> You can sit down and build a clone of what is CLOS, and make it even
> >> more powerful, for example by adding aspect oriented programming to it.
>
> >http://common-lisp.net/project/closer/aspectl.html
>
> >> Or having the ability to add a full stack of before/after methods, and
> >> have full control over the order in which they run,
>
> >http://www.lispworks.com/documentation/HyperSpec/Body/m_defi_4.htm
>
> >> and be able to
> >> change that during runtime, etc.
>
> >http://common-lisp.net/project/closer/contextl.html
>
> >> In Clojure one typical solution is, that instead of
> >> (defclass bank-account ()
> >>   (customer-name balance))
> >> you would have:
> >> (defstruct bank-account :customer-name :balance)
> >> A struct is Clojure is a factory for maps.
> >> So, the bank-account thing is something like a hash-table.
>
> >http://infolab.stanford.edu/~paepcke/shared-documents/mopintro.ps
>
> You broke my illusions....
>
> do we need to stick with CL anyway?

Why not?  I am (almost) perfectly happy with it :)

Cheers
--
Marco
From: Pascal Costanza
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71kgnoFkn6vkU1@mid.individual.net>
Javier wrote:
> Pascal Costanza escribi�:
>> Andr� Thieme wrote:
>>> jimka schrieb:
>>>> A couple of things I'm wondering about clojure?
>>>>
>>>> 1. Is the fact that CLOS is missing intentional?  I.e., do you want to
>>>> prevent it being added? or is it more a matter of priority?   And does
>>>> the architecture of clojure prevent its being added later?
>>> It is easy to implement oop in Clojure.
>> http://mumble.net/~jar/pubs/oopis.ps
>>
>>> That is because you have all
>>> building blocks ready as your tools, that is: functional programming and
>>> macros.
>> It gets considerably harder if you want to make this efficient.
>>
>>> Paul Graham btw says that FP and Macros are more powerful than oop.
>> Paul Graham says a lot.
>>
>>> You can sit down and build a clone of what is CLOS, and make it even
>>> more powerful, for example by adding aspect oriented programming to it.
>> http://common-lisp.net/project/closer/aspectl.html
>>
>>> Or having the ability to add a full stack of before/after methods, and
>>> have full control over the order in which they run, 
>> http://www.lispworks.com/documentation/HyperSpec/Body/m_defi_4.htm
>>
>>> and be able to
>>> change that during runtime, etc.
>> http://common-lisp.net/project/closer/contextl.html
>>
>>> In Clojure one typical solution is, that instead of
>>> (defclass bank-account ()
>>>   (customer-name balance))
>>> you would have:
>>> (defstruct bank-account :customer-name :balance)
>>> A struct is Clojure is a factory for maps.
>>> So, the bank-account thing is something like a hash-table.
>> http://infolab.stanford.edu/~paepcke/shared-documents/mopintro.ps
> 
> You broke my illusions....
> 
> 
> do we need to stick with CL anyway?

The only thing we _need_ to do is form our own opinions.


Pascal

-- 
ELS'09: http://www.european-lisp-symposium.org/
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp3s2d$r7v$1@news.motzarella.org>
Pascal Costanza schrieb:
> Andr� Thieme wrote:
>> jimka schrieb:
>>> A couple of things I'm wondering about clojure?
>>>
>>> 1. Is the fact that CLOS is missing intentional?  I.e., do you want to
>>> prevent it being added? or is it more a matter of priority?   And does
>>> the architecture of clojure prevent its being added later?
>>
>> It is easy to implement oop in Clojure.
> 
> http://mumble.net/~jar/pubs/oopis.ps

Interesting to see how things were, 20 years ago.


>> That is because you have all
>> building blocks ready as your tools, that is: functional programming and
>> macros.
> 
> It gets considerably harder if you want to make this efficient.

Yes, as with most things.
If you want to have a different object system for CL or
Java, then you will also have difficulties to make it efficient.
But well, OOP was not what one hoped for in the 80ies.
Typically oop is done internally via side effects. It would be
possible to make an oop system creating always fresh objects,
but when you talk about efficiency... it will not be easier
that way.
With that old model of oop it is not as easy to write concurrent
applications as it is with a functional approach, mostly free
from side effects.

Anyway, Clojure offers something different than oop: a functional
programming approach. What many of us told to CL beginners was:
�Don't think in C, think in CL�.
We should apply this with respect to CL and CLJ.
You have hashmaps and generic multimethods that can dispatch
on anything you like, not just the type. This is a very flexible
and extensible model to write code in.



>> Paul Graham btw says that FP and Macros are more powerful than oop.
> 
> Paul Graham says a lot.

Yes, for example he tries to defend the position that Lisp is
somehow �more powerful� than other languages. Many believe it.
He tries to convince people that Lisp allows to build better
abstractions, and that it is easier in several aspects. And
that this mostly comes from its functional style + macros.
Seems like cherry picking to say that only the first parts are
true, but his explanation isn't.
(although I don't want to state that *you* say that Lisp is
anyhow more powerful/better than other languages, I just mean
that several CLers think so).


> http://common-lisp.net/project/closer/aspectl.html
> http://common-lisp.net/project/closer/contextl.html

The author is an expert for oop and aop. He spent a lot of his
time to investigate in oop systems, to deeply understand them.
It would be natural for him to be mostly interested in oop,
and maybe not so much in functional programming.
A guy like Paul Hudak however (one of the authors of Haskell)
would probably only smile mildly if someone proposed to use oop
for complex problems.


Andr�
-- 
Lisp is not dead. It�s just the URL that has changed:
http://clojure.org/
From: Pascal Costanza
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71mmi1Fles1nU1@mid.individual.net>
Andr� Thieme wrote:
> Pascal Costanza schrieb:
>> Andr� Thieme wrote:
>>> jimka schrieb:
>>>> A couple of things I'm wondering about clojure?
>>>>
>>>> 1. Is the fact that CLOS is missing intentional?  I.e., do you want to
>>>> prevent it being added? or is it more a matter of priority?   And does
>>>> the architecture of clojure prevent its being added later?
>>>
>>> It is easy to implement oop in Clojure.
>>
>> http://mumble.net/~jar/pubs/oopis.ps
> 
> Interesting to see how things were, 20 years ago.

It was actually already known 30 years ago how to integrate OOP into 
Lisp. You make the statement that it's easy to implement it in Clojure 
as if that were a new and groundbreaking insight.

The hard part is to make it efficient and convenient to use.

>>> That is because you have all
>>> building blocks ready as your tools, that is: functional programming and
>>> macros.
>>
>> It gets considerably harder if you want to make this efficient.
> 
> Yes, as with most things.
> If you want to have a different object system for CL or
> Java, then you will also have difficulties to make it efficient.

http://p-cos.net/documents/context-switch.pdf
http://p-cos.net/documents/context-meta.pdf
http://p-cos.net/documents/context-fd.pdf

> But well, OOP was not what one hoped for in the 80ies.

Message sending was not what one hoped for. Things are quite different 
for generic functions. Rich Hickey would agree, as far as I can tell 
from the Clojure specification.

> Typically oop is done internally via side effects. It would be
> possible to make an oop system creating always fresh objects,
> but when you talk about efficiency... it will not be easier
> that way.

You don't know a lot about modern garbage collectors, do you?

> With that old model of oop it is not as easy to write concurrent
> applications as it is with a functional approach, mostly free
> from side effects.

You haven't heard of actors yet, have you?

> Anyway, Clojure offers something different than oop: a functional
> programming approach. What many of us told to CL beginners was:
> �Don't think in C, think in CL�.
> We should apply this with respect to CL and CLJ.
> You have hashmaps and generic multimethods that can dispatch
> on anything you like, not just the type. This is a very flexible
> and extensible model to write code in.

...which will lead to problems in the long run because it doesn't take 
care of handling ambiguities in the dispatch correctly, which makes 
Clojures dispatch unpredictable.

>>> Paul Graham btw says that FP and Macros are more powerful than oop.
>>
>> Paul Graham says a lot.
> 
> Yes, for example he tries to defend the position that Lisp is
> somehow �more powerful� than other languages. Many believe it.
> He tries to convince people that Lisp allows to build better
> abstractions, and that it is easier in several aspects. And
> that this mostly comes from its functional style + macros.
> Seems like cherry picking to say that only the first parts are
> true, but his explanation isn't.
> (although I don't want to state that *you* say that Lisp is
> anyhow more powerful/better than other languages, I just mean
> that several CLers think so).
> 
> 
>> http://common-lisp.net/project/closer/aspectl.html
>> http://common-lisp.net/project/closer/contextl.html
> 
> The author is an expert for oop and aop. He spent a lot of his
> time to investigate in oop systems, to deeply understand them.
> It would be natural for him to be mostly interested in oop,
> and maybe not so much in functional programming.

This was a response to the following statement of yours:

> You can sit down and build a clone of what is CLOS, and make it even
> more powerful, for example by adding aspect oriented programming to it.

Again, you made it sound as if this was a unique feature of Clojure, 
while it is actually already known since the 60's how to add 
aspect-style features to Lisp.

See http://p-cos.blogspot.com/2007/12/origin-of-advice.html

> A guy like Paul Hudak however (one of the authors of Haskell)
> would probably only smile mildly if someone proposed to use oop
> for complex problems.

Paul Hudak says a lot.


Pascal

-- 
ELS'09: http://www.european-lisp-symposium.org/
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp8s8p$qg9$1@news.motzarella.org>
Pascal Costanza schrieb:
> Andr� Thieme wrote:

>> You can sit down and build a clone of what is CLOS, and make it even
>> more powerful, for example by adding aspect oriented programming to it.
> 
> Again, you made it sound as if this was a unique feature of Clojure, 
> while it is actually already known since the 60's how to add 
> aspect-style features to Lisp.

Oh oki, I don�t meant it to sound like that.
What I said is also true for other Lisps.


> Paul Hudak says a lot.

As you and I do too ;)


Andr�
-- 
Lisp is not dead. It�s just the URL that has changed:
http://clojure.org/
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp1ie1$eme$1@news.motzarella.org>
neptundancer schrieb:
> On Mar 8, 7:21 pm, Andr� Thieme <address.good.until.
> ···········@justmail.de> wrote:
>> Vagif Verdi schrieb:
>>
>>> On Mar 8, 1:10 am, Marco Antoniotti <·······@gmail.com> wrote:
>>>> Too many things lacking at the language level
>>> Care to elaborate ?
>> I suppose he means something like defstruct and defclass, plus the
>> metaobject protocol. So, built in mechanisms for oop.
>> Also he may mean: lack of reader macros and some few macro special ops,
>> such as symbol-macrolet.
>> I personally see it as a strong advantage of not having built-in support
>> for OOP. I like that Clojure concentrates more on functional programming.
>> OOP had enough years, now functional programming has its turn.
>> Concentrating on a main paradigm can produce more compatible code, and
>> will make it easier for teams to work together.
>>
>> Not having (user definable) reader macros.. well, I would like to have
>> them, but can understand that they may do more harm than good.
>>
>> Andr�
>> --
>> Lisp is not dead. It�s just the URL that has changed:http://clojure.org/
> 
> Funny, that you see absence of such a powerful think like CLOS an
> advantage because it's "OOP" (albeit the best OO system used in
> practice), and with the same breath you don't mind buying Java
> libraries "advantage" and Java interop (main selling point of
> Clojure), not bothering that it's built on the very most crippled
> "object" system ever designed.

Yes, again criticism of one of those experts who never even wrote
a single line of Clojure code, great.
I smell the turing argument here, which makes no sense.
You know that under the hood all is machine language, yes?
Zeros and Ones.
Many Java libs get more testing each year than all CL libs
together since they began to exist. I don�t care at all if those
people implemented it in Java, Delphi or Assembler.
Fact is, those libs are there. They are usable, mature and have
several orders of magnitude more testing than all of what CL
ever had.

The Java stuff is used in Clojure nearly exclusively to communicate
with the world. Reading/writing data from/to disk, network, DB, etc.
It�s not typical that you run into oop from the Java world when you
write Clojure programs. Of course, you can�t know this since you
don�t know much about Clojure. Just enough to feel the need to post
here.


If there were an oop mechanism built in into Clojure then some people
would give oop solutions while other would follow the route that makes
more sense, i.e. the functional route. That would lead to more
incompatibility. In CL you ask ten people to solve a problem and you�ll
get eleven solutions. All incompatible to each other. That just makes
not much sense.
CLOS just was not fit enough to become more popular. I don�t want to
talk about better/worse, as this is very subjective. But obviously it
was not fit, in an evolutionary way.
We CLers (many of us, yes, including me) tried for years to put lipstick
on the pig. We tried to rationalize every time when someone said:
�Hey, if CL is that good, why are not more people using it�.
It�s nearly 2010 and we should realize that it simply is not that good.

Try out Clojure. Work a few months with it, write a few hundred or
thousand LOC and report were/if you truly miss oop.


Andr�
-- 
Lisp is not dead. It�s just the URL that has changed:
http://clojure.org/
From: neptundancer
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <e81ca795-c928-4222-a0ef-ea58773b1e6f@17g2000vbf.googlegroups.com>
> > Funny, that you see absence of such a powerful think like CLOS an
> > advantage because it's "OOP" (albeit the best OO system used in
> > practice), and with the same breath you don't mind buying Java
> > libraries "advantage" and Java interop (main selling point of
> > Clojure), not bothering that it's built on the very most crippled
> > "object" system ever designed.
>
> Yes, again criticism of one of those experts who never even wrote
> a single line of Clojure code, great.
> I smell the turing argument here, which makes no sense.
> You know that under the hood all is machine language, yes?
> Zeros and Ones.
> Many Java libs get more testing each year than all CL libs
> together since they began to exist. I don’t care at all if those
> people implemented it in Java, Delphi or Assembler.
> Fact is, those libs are there. They are usable, mature and have
> several orders of magnitude more testing than all of what CL
> ever had.
>
I worked for Java shop. You wouldn't believe how many troubles and
surprises wait behind almost every corner when you want to do
something a bit different than written in manual. Never again.

> CLOS just was not fit enough to become more popular.
Great. Let's buy all Britney Spears now! A man is intelligent. A mass
of people is as much intelligent as the loudest of them. Popularity of
Java is mostly because of marketing targeted at management, not
because of quality.

> Try out Clojure. Work a few months with it, write a few hundred or
> thousand LOC and report were/if you truly miss oop.
>
I program daily in Erlang for years. I know a bit about functional
programming and also about concurrent programming. I don't think
Clojure has the right approach to concurrency.
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp1pe7$19g$1@news.motzarella.org>
neptundancer schrieb:
>>> Funny, that you see absence of such a powerful think like CLOS an
>>> advantage because it's "OOP" (albeit the best OO system used in
>>> practice), and with the same breath you don't mind buying Java
>>> libraries "advantage" and Java interop (main selling point of
>>> Clojure), not bothering that it's built on the very most crippled
>>> "object" system ever designed.
>> Yes, again criticism of one of those experts who never even wrote
>> a single line of Clojure code, great.
>> I smell the turing argument here, which makes no sense.
>> You know that under the hood all is machine language, yes?
>> Zeros and Ones.
>> Many Java libs get more testing each year than all CL libs
>> together since they began to exist. I don�t care at all if those
>> people implemented it in Java, Delphi or Assembler.
>> Fact is, those libs are there. They are usable, mature and have
>> several orders of magnitude more testing than all of what CL
>> ever had.
>>
> I worked for Java shop. You wouldn't believe how many troubles and
> surprises wait behind almost every corner when you want to do
> something a bit different than written in manual. Never again.

Do you have some examples? Maybe you can contrast how a lib in Java did
not let you do what you wanted, while the CL equivalent is more liberal
here.

And is that common in your opinion? If yes, could you give several
examples where CL libs let you do things different than the manual says
while at the same time the Java equivalent must stick closely to the
examples given in the docs/tutorials?


>> CLOS just was not fit enough to become more popular.
> Great. Let's buy all Britney Spears now! A man is intelligent. A mass
> of people is as much intelligent as the loudest of them.

It still is possible that the most intelligent man of all is doing Java.
Even if the average is not so intelligent.
Besides, I think it does not buy us anything by degrading users of
popular programming languages.

And see that I wrote about fitness in a given environment.
If we see the number of users of a language, the number of programs
written in it, the number of jobs for language users and the number of
books for a language as the basis for the fitness, then although CL can
be regarded as �better� in the opinion of a minority, it still is not
as fit as Java.


> Popularity of Java is mostly because of marketing targeted at management,
 > not because of quality.

I don�t believe that.
CL had waay more time to conquer the world. What were CLs competitors in
the 80ies? Fortran, C and Pascal. Oh, Basic.
CL is clearly much more powerful than these.
The myth about Suns amazing marketing will maybe never go away.
This is what I meant by putting lipstick on the pig. We try to invent
all kinds of rationalizations to defend CL and it�s status of being not
popular.
Maybe we should face the truth that other languages got better.
If those old promises of the 80ies, of 5x to 20x more productivity with
CL were really true, then nearly all would use it. CL programs would
constantly prove this productivity. It would enable you to do within
minutes what other people need a day for.


Andr�
-- 
Lisp is not dead. It�s just the URL that has changed:
http://clojure.org/
From: Tamas K Papp
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71jeqqFld29iU1@mid.individual.net>
On Mon, 09 Mar 2009 01:55:31 +0100, André Thieme wrote:

> neptundancer schrieb:
>
>> I worked for Java shop. You wouldn't believe how many troubles and
>> surprises wait behind almost every corner when you want to do something
>> a bit different than written in manual. Never again.
> 
> Do you have some examples? Maybe you can contrast how a lib in Java did
> not let you do what you wanted, while the CL equivalent is more liberal
> here.

Oh dear God, you this is the nth iteration of the following loop:

1. André pushes Clojure,
2. [... things happen ...]
3. André ends up defending Java.

Seriously, one could write a macro to capture this.

Please do realize that Clojure is a Lisp, and was created precisely
because Lisp is more powerful than Java.  Comparing to Java, the
differences between CL and Clojure are relatively minor, regardless of
the endless threads on c.l.l which are picking on the differences
between the two languages.

> And is that common in your opinion? If yes, could you give several
> examples where CL libs let you do things different than the manual says
> while at the same time the Java equivalent must stick closely to the
> examples given in the docs/tutorials?

Are you serious?  Just think stuff you did in Clojure which would be
difficult or cumbersome to do in Java.  I am absolutely sure there are
countless examples.  Then just imagine you did that in CL instead of
Clojure: yes, surely the code is going to be a bit different, but
pretty similar from the vantage point of Java.

> And see that I wrote about fitness in a given environment. If we see the
> number of users of a language, the number of programs written in it, the
> number of jobs for language users and the number of books for a language
> as the basis for the fitness, then although CL can be regarded as
> „better” in the opinion of a minority, it still is not as fit as Java.

Same applies to Clojure.  Again, serious and knowledgeable people
could have the preference ordering CL > Clojure >> Java, or
Clojure > CL >> Java.  Above, you seem to argue that Clojure > Java >
CL, but sorry, I am not buying that, given that CL and Clojure have a
lot in common.

Anyhow, I don't really want to enter this pointless thread, I just
want to point out three things to André:

1. You are pushing Clojure very aggressively.  Yes, I know the
feeling, you found this amazing new toy and want people to share your
joy.  That's fine, but sometime you enter Zealot Mode and border on
the ridiculous.

2. You don't have to argue that CL sucks in order to show that Clojure
is a nice language.

3. You don't have to defend Java in order to demonstrate that Clojure
is a nice language.  That makes your life a whole lot easier, as Java
is a reeking pile of dung.  But that's OK -- that why Clojure was
invented.

Peace,

Tamas
From: William James
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp26ge02r8q@enews2.newsguy.com>
Tamas K Papp wrote:

> 1. You are pushing Clojure very aggressively.  Yes, I know the
> feeling, you found this amazing new toy

"Toy" is a disparaging term.

>                                         and want people to share your
> joy.  That's fine, but sometime you enter Zealot Mode and border on
> the ridiculous.

Followers of CL are, as a rule, always in Zealot Mode, and they
don't merely border on the ridiculous: they live in it.

> 
> 2. You don't have to argue that CL sucks

Please, please don't argue that CL sucks; that would make us cry.

Paul Graham, May 2001:
A hacker's language is terse and hackable. Common Lisp is not.
The good news is, it's not Lisp that sucks, but Common Lisp.
From: Javier
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp233g$hro$1@aioe.org>
Tamas K Papp escribió:

> 1. You are pushing Clojure very aggressively.  Yes, I know the
> feeling, you found this amazing new toy and want people to share your
> joy.  That's fine, but sometime you enter Zealot Mode and border on
> the ridiculous.
> 
> 2. You don't have to argue that CL sucks in order to show that Clojure
> is a nice language.
> 
> 3. You don't have to defend Java in order to demonstrate that Clojure
> is a nice language.  That makes your life a whole lot easier, as Java
> is a reeking pile of dung.  But that's OK -- that why Clojure was
> invented.


What I don't like about you and people like you (almost everyone here)
is you intrinsic ability to constantly say that everything except CL sucks.
When somebody presents to you something good about X (for example, the
rich and good amount of libraries about Java) you simply return to the
level of "that sucks", and then start trolling in your own terrain.

You may think yourself who is really the ridiculous here.
From: Pillsy
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <09aea872-f622-42fd-9689-6162ce214758@q30g2000vbn.googlegroups.com>
On Mar 8, 11:42 pm, Javier <·······@gmail.com> wrote:
> Tamas K Papp escribió:
[...]
> > 3. You don't have to defend Java in order to demonstrate that Clojure
> > is a nice language.  That makes your life a whole lot easier, as Java
> > is a reeking pile of dung.  But that's OK -- that why Clojure was
> > invented.

> What I don't like about you and people like you (almost everyone here)
> is you intrinsic ability to constantly say that everything except CL sucks.

Er, one of the major points of Tamas' post was that Clojure *doesn't*
suck. Indeed, people who post here often have nice things to say about
languages other than CL. They rarely have anything nice to say about
*Java*, but it's not like that's a particularly unusual opinion, let
along one that's peculiar to posters on comp.lang.lisp.

Cheers,
Pillsy
From: Tamas K Papp
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71kj55Flia7sU1@mid.individual.net>
On Mon, 09 Mar 2009 06:01:00 -0700, Pillsy wrote:

> On Mar 8, 11:42 pm, Javier <·······@gmail.com> wrote:
>> Tamas K Papp escribió:
> [...]
>> > 3. You don't have to defend Java in order to demonstrate that Clojure
>> > is a nice language.  That makes your life a whole lot easier, as Java
>> > is a reeking pile of dung.  But that's OK -- that why Clojure was
>> > invented.
> 
>> What I don't like about you and people like you (almost everyone here)
>> is you intrinsic ability to constantly say that everything except CL
>> sucks.
> 
> Er, one of the major points of Tamas' post was that Clojure *doesn't*
> suck. Indeed, people who post here often have nice things to say about
> languages other than CL. They rarely have anything nice to say about
> *Java*, but it's not like that's a particularly unusual opinion, let
> along one that's peculiar to posters on comp.lang.lisp.

Javier is a well-known troll (most people killfiled him a long time
ago), this whole thread was pure flamebait.  If you observe him, you
will notice that he steps in with a non-sensical follow-up whenever
there is a chance that the discussion is getting rational.  I don't
know what kind of enjoyment he derives from this - he probably does
not have the skills to do anything more interesting with his time.

Tamas
From: Javier
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp36bh$f78$1@aioe.org>
Tamas K Papp escribió:
> On Mon, 09 Mar 2009 06:01:00 -0700, Pillsy wrote:
> 
>> On Mar 8, 11:42 pm, Javier <·······@gmail.com> wrote:
>>> Tamas K Papp escribió:
>> [...]
>>>> 3. You don't have to defend Java in order to demonstrate that Clojure
>>>> is a nice language.  That makes your life a whole lot easier, as Java
>>>> is a reeking pile of dung.  But that's OK -- that why Clojure was
>>>> invented.
>>> What I don't like about you and people like you (almost everyone here)
>>> is you intrinsic ability to constantly say that everything except CL
>>> sucks.
>> Er, one of the major points of Tamas' post was that Clojure *doesn't*
>> suck. Indeed, people who post here often have nice things to say about
>> languages other than CL. They rarely have anything nice to say about
>> *Java*, but it's not like that's a particularly unusual opinion, let
>> along one that's peculiar to posters on comp.lang.lisp.
> 
> Javier is a well-known troll (most people killfiled him a long time
> ago), this whole thread was pure flamebait.  If you observe him, you
> will notice that he steps in with a non-sensical follow-up whenever
> there is a chance that the discussion is getting rational.  I don't
> know what kind of enjoyment he derives from this - he probably does
> not have the skills to do anything more interesting with his time.

Tamas K Papp is a well-known hostile member of this forum, and attacked
me in the past. From that time, everytime that he detects a message from
me, he says I am a troll, and start insulting me.
I do not have the intentions he says, and what I'm doing with my life
and skills is something that is only of his business, but he insist in
trying to analyze me and putting me in evidence.
From: Javier
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp36h6$f78$2@aioe.org>
Pillsy escribi�:
> On Mar 8, 11:42 pm, Javier <·······@gmail.com> wrote:
>> Tamas K Papp escribi�:
> [...]
>>> 3. You don't have to defend Java in order to demonstrate that Clojure
>>> is a nice language.  That makes your life a whole lot easier, as Java
>>> is a reeking pile of dung.  But that's OK -- that why Clojure was
>>> invented.
> 
>> What I don't like about you and people like you (almost everyone here)
>> is you intrinsic ability to constantly say that everything except CL sucks.
> 
> Er, one of the major points of Tamas' post was that Clojure *doesn't*
> suck. Indeed, people who post here often have nice things to say about
> languages other than CL. They rarely have anything nice to say about
> *Java*, but it's not like that's a particularly unusual opinion, let
> along one that's peculiar to posters on comp.lang.lisp.

You cut my original message, that was:

"""
What I don't like about you and people like you (almost everyone here)
is you intrinsic ability to constantly say that everything except CL sucks.
When somebody presents to you something good about X (for example, the
rich and good amount of libraries about Java) you simply return to the
level of "that sucks", and then start trolling in your own terrain.
"""


Note that I was talking about Java libraries, not Clojure.
Anyway, my message is completely right. Look for Tamas messages
regarding other things apart from CL, and you'll discover his full
hostility, intolerance, and arrogance.
From: Pascal Costanza
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71kqadFllbf5U1@mid.individual.net>
Javier wrote:

> What I don't like about you and people like you (almost everyone here)
> is you intrinsic ability to constantly say that everything except CL sucks.

No Common Lisper I know says that Common Lisp is perfect in all 
respects. To the contrary, every Common Lisper I have talked to has 
something to criticize about it.

The same goes for Scheme.

The same even goes for Clojure, at least when you consider what Rich 
Hickey says himself about it. (For example, he admits that recur is a 
workaround, and not the best solution in his eyes.)

To generalize, every reasonable programmer should know something to 
criticitize about their preferred language.

> When somebody presents to you something good about X (for example, the
> rich and good amount of libraries about Java) you simply return to the
> level of "that sucks", and then start trolling in your own terrain.

You don't need a lot of libraries, you need good libraries. The amount 
of libraries and the amount of users of a particular language don't say 
anything about their quality, it just gives you the warm and fuzzy 
feeling that you make the same choice as a lot of other people.

Lispers are typically not interested in that warm and fuzzy feeling. 
They want more substantial arguments (and then they start to disagree, 
but at least on a more profound level ;).


Pascal

-- 
ELS'09: http://www.european-lisp-symposium.org/
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
From: =?UTF-8?B?QW5kcsOpIFRoaWVtZQ==?=
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp3our$mkp$1@news.motzarella.org>
Pascal Costanza schrieb:
> Javier wrote:
> 
>> What I don't like about you and people like you (almost everyone here)
>> is you intrinsic ability to constantly say that everything except CL 
>> sucks.
> 
> No Common Lisper I know says that Common Lisp is perfect in all 
> respects. To the contrary, every Common Lisper I have talked to has 
> something to criticize about it.

True.
And yes, true for any language.
As soon you decide for one, you buy its load of advantages and dis-
advantages. The one best programming language still needs to be
invented.



> The same even goes for Clojure, at least when you consider what Rich 
> Hickey says himself about it. (For example, he admits that recur is a 
> workaround, and not the best solution in his eyes.)

And he also said that recur will stay in the language, even when TCO
appears.
It is true that it is a workaround, because without it we could
potentially run into stack overflows.
It has advantages over recursion by name: anonymous functions can
recursively call themselves and the compiler can enforce that recur must
be in the tail position. Can be found easily with a simple search.
Makes sense to keep that, and to dictate that recur is the idiomatic way
in Clojure for the most typical case of recursion.


André
-- 
Lisp is not dead. It’s just the URL that has changed:
http://clojure.org/
From: Pascal J. Bourguignon
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <87tz62wluy.fsf@galatea.local>
Andr� Thieme <······························@justmail.de> writes:

> Pascal Costanza schrieb:
>> Javier wrote:
>> 
>>> What I don't like about you and people like you (almost everyone here)
>>> is you intrinsic ability to constantly say that everything except
>>> CL sucks.
>> No Common Lisper I know says that Common Lisp is perfect in all
>> respects. To the contrary, every Common Lisper I have talked to has
>> something to criticize about it.
>
> True.
> And yes, true for any language.
> As soon you decide for one, you buy its load of advantages and dis-
> advantages. The one best programming language still needs to be
> invented.

However,

  (every (lambda (language)
            (<= (- (advantages language)    (disadvantages language))
                (- (advantages common-lisp) (disadvantages common-lisp))))
         (list-all-languages))


-- 
__Pascal Bourguignon__
From: Miles Bader
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <buo63ig1v91.fsf@dhlpc061.dev.necel.com>
···@informatimago.com (Pascal J. Bourguignon) writes:
>   (every (lambda (language)
>             (<= (- (advantages language)    (disadvantages language))
>                 (- (advantages common-lisp) (disadvantages common-lisp))))
>          (list-all-languages))

You forgot the APPLICATION-DOMAIN argument...

-Miles

-- 
Somebody has to do something, and it's just incredibly pathetic that it
has to be us.  -- Jerry Garcia
From: =?UTF-8?B?QW5kcsOpIFRoaWVtZQ==?=
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp3ofq$hcs$1@news.motzarella.org>
Tamas K Papp schrieb:
> On Mon, 09 Mar 2009 01:55:31 +0100, André Thieme wrote:
> 
>> neptundancer schrieb:
>>
>>> I worked for Java shop. You wouldn't believe how many troubles and
>>> surprises wait behind almost every corner when you want to do something
>>> a bit different than written in manual. Never again.
>> Do you have some examples? Maybe you can contrast how a lib in Java did
>> not let you do what you wanted, while the CL equivalent is more liberal
>> here.
> 
> Oh dear God,

Yes? You are lucky, I am listening to you now.


> this is the nth iteration of the following loop:
> 
> 1. André pushes Clojure,
> 2. [... things happen ...]
> 3. André ends up defending Java.

The correct pattern is:
1. Lisper X who never touched Clojure posts nonsense about it.
2. André clears up the issue.



> Please do realize that Clojure is a Lisp, and was created precisely
> because Lisp is more powerful than Java.  Comparing to Java, the
> differences between CL and Clojure are relatively minor, regardless of
> the endless threads on c.l.l which are picking on the differences
> between the two languages.

See, it was the guy to whom I responded who brought Java into the
discussion here.
I don't have a deep knowledge about Java, because I am a Lisper,
not a Java guy. I even never drink coffee. But I am interested to find
out more about the claims that were made. I don't see why you suddenly
jump into the discussion without having anything substantial to say
about the issue itself, but instead trying to educate me in public.
That's not good manners.


>> And is that common in your opinion? If yes, could you give several
>> examples where CL libs let you do things different than the manual says
>> while at the same time the Java equivalent must stick closely to the
>> examples given in the docs/tutorials?
> 
> Are you serious?  Just think stuff you did in Clojure which would be
> difficult or cumbersome to do in Java.  I am absolutely sure there are
> countless examples.  Then just imagine you did that in CL instead of
> Clojure: yes, surely the code is going to be a bit different, but
> pretty similar from the vantage point of Java.

Are you a Java expert? If yes, then maybe you can answer my question.
I am mostly interested in the use of some Java libs, not writing lots
of Java code myself. I mentioned elsewhere that it is typical to write
the business logic of a Clojure app purely in Clojure, and use Java libs
just for communication with the outside world.
In my posting where I said this I was talking about libs, not the core
logic of an application. So I must assume that neptundancer was talking
about Java libs when he said that they can mainly be used only in the
way the docs/tutorials state it.
I would just like to see some examples.


>> And see that I wrote about fitness in a given environment. If we see the
>> number of users of a language, the number of programs written in it, the
>> number of jobs for language users and the number of books for a language
>> as the basis for the fitness, then although CL can be regarded as
>> „better” in the opinion of a minority, it still is not as fit as Java.
> 
> Same applies to Clojure.  Again, serious and knowledgeable people
> could have the preference ordering CL > Clojure >> Java, or
> Clojure > CL >> Java.  Above, you seem to argue that Clojure > Java >
> CL, but sorry, I am not buying that, given that CL and Clojure have a
> lot in common.

I can fully understand that you don&#8217;t buy that, because this is
exactly as I see it too. If you really think that I was promoting Java,
then this is a serious misunderstanding.
In other threads I mentioned that I think that for me personally Clojure
is the "better" Lisp (opinion) but that CL is my second favourite
programming language. How often did you leave your home town to get a
CL job? How often did you leave your country to do it?
Can we agree on that someone who does so must have a high opinion about CL?
I did that, so please never again misrepresent my opinions. I am the
only person who has the right to state what I like and in what order.
And if you missed other postings or forgot parts of it this is not my
problem, but I want you to stop putting words into my mouth. It is
totally ridiculous how you make me look in respect to CL.
I prefer doing CL pretty much over any/most other languages.


> Anyhow, I don't really want to enter this pointless thread, I just
> want to point out three things to André:

Why then post in c.l.l? I have an email address.


> 1. You are pushing Clojure very aggressively.  Yes, I know the
> feeling, you found this amazing new toy and want people to share your
> joy.  That's fine, but sometime you enter Zealot Mode and border on
> the ridiculous.

It’s mild pushing, mostly defending against BS of some CLers.
But I stand out because I am +/- the only one who does not like that
too many wrong statements are made, regarding Clojure.
It is regarded as helpful - I get private emails, sometimes of very
experienced Lispers who became curious about Clojure. Some change the
camp, which is good.



> 2. You don't have to argue that CL sucks in order to show that Clojure
> is a nice language.

I am not the one who states that a language sucks. This is already the
job of a very prominent CLer here in c.l.l.


> 3. You don't have to defend Java in order to demonstrate that Clojure
> is a nice language.  That makes your life a whole lot easier, as Java
> is a reeking pile of dung.  But that's OK -- that why Clojure was
> invented.

I am not even in the position to defend Java, as I am not trained
enough to read/write Java code.
Besides that, I don't like the arrogant attitude to have Java as
the victim language, designed for idiots. It is a programming language,
and some of the best programmers in the world use it to write working
applications. Successful applications.
Objectively we can observe that Java must have done a lot of things
right. If it were so bad as some c.l.l guys want it to be (it seems
for some Java needs to suck so that Lisp can be good), then it would
not have been such a success.
This does of course not mean that Javahas to be your or mine language
of choice, only because for the majority of programmers it is an
extremly one.
Very possible that we are more productive with a Lisp.


André
-- 
Lisp is not dead. It’s just the URL that has changed:
http://clojure.org/
From: Tamas K Papp
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71lds2FlvajcU1@mid.individual.net>
On Mon, 09 Mar 2009 19:51:36 +0100, André Thieme wrote:

> issue itself, but instead trying to educate me in public. That's not
> good manners.

I apologize, no harm was intended.

But please realize that you are pushing Clojure quite aggressively,
and sometimes you do not sound convincing (to me at least, I realize
that these things are subjective).  For example, when people mention
things that are missing from Clojure (CLOS, lisp-like condition
system), I have frequently seen you take the position that this is a
good thing and is actually a feature.

> Are you a Java expert? If yes, then maybe you can answer my question. I

Nope, sorry.  I just programmed in Java for a while (agent-based
models, which are well-suited to OO), and learned to hate the
language and the architecture.

> Besides that, I don't like the arrogant attitude to have Java as the
> victim language, designed for idiots. It is a programming language, and

I don't see why criticizing Java, even heavily, counts as "arrogant". 
Perhaps as off-topic, on c.l.l.

> some of the best programmers in the world use it to write working
> applications. Successful applications. Objectively we can observe that
> Java must have done a lot of things right. If it were so bad as some

Same could be said for COBOL.  The "success" of languages (in terms of
how widespread they are, how easy it is to find a job for programmers,
etc) does not correlate much with how well-designed a language is.  It
is mostly successful marketing, historical accidents and hysteresis
that determine language "success" in the above sense.

Anyhow, I don't want to get into bashing Java.  And I thank you for
pointing out Clojure, I tried it out (but I am staying with CL in the
short run).  Just please market it less aggressively.

Tamas
From: =?UTF-8?B?QW5kcsOpIFRoaWVtZQ==?=
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp41cl$jji$1@news.motzarella.org>
Tamas K Papp schrieb:
> On Mon, 09 Mar 2009 19:51:36 +0100, André Thieme wrote:
> 
>> issue itself, but instead trying to educate me in public. That's not
>> good manners.
> 
> I apologize, no harm was intended.

Accepted, thanks.


> But please realize that you are pushing Clojure quite aggressively,
> and sometimes you do not sound convincing (to me at least, I realize
> that these things are subjective).  For example, when people mention
> things that are missing from Clojure (CLOS, lisp-like condition
> system), I have frequently seen you take the position that this is a
> good thing and is actually a feature.

About CLOS I really think so.
About the Condition System I said somewhere that this is indeed
something that would be nice. I personally don't miss it very much,
and I think most people use it mostly for the stuff that the Java
Exception system offers. But yes, if I could chose between a Clojure
without and with the Condition system, I personally would want it with.


>> Are you a Java expert? If yes, then maybe you can answer my question. I
> 
> Nope, sorry.  I just programmed in Java for a while (agent-based
> models, which are well-suited to OO), and learned to hate the
> language and the architecture.

I did Java around 99 and did not feel enlightened by the language.
When I discovered CL in late 2002 and started in early 2003 I knew very
fast that I am home now.


>> Besides that, I don't like the arrogant attitude to have Java as the
>> victim language, designed for idiots. It is a programming language, and
> 
> I don't see why criticizing Java, even heavily, counts as "arrogant". 
> Perhaps as off-topic, on c.l.l.

Well, I see it just as a tool, as the (or one of the) most popular
programming languages. It is not for me, but I see that Gosling and
Steele must have done something right.
And only because Guy Steele is a Java guy it does not mean that he
is unproductive.
Of course, I had those shocking moments...
I was listening to some first semester students. Their introdutory
language was scheme, it was end of the semester. They were very happy
that next Semester they will learn Java. Because it allows them to do
OOP, which is not possible in Scheme.
OMG.
It's the pisa generation of german students that hit the Universities.
So yeah, there is this dark side as well.


>> some of the best programmers in the world use it to write working
>> applications. Successful applications. Objectively we can observe that
>> Java must have done a lot of things right. If it were so bad as some
> 
> Same could be said for COBOL.  The "success" of languages (in terms of
> how widespread they are, how easy it is to find a job for programmers,
> etc) does not correlate much with how well-designed a language is.  It
> is mostly successful marketing, historical accidents and hysteresis
> that determine language "success" in the above sense.

Right, I have to agree.
I just want to attack it from the other side.
If there exists such a thing as "way more powerful because of the good
design", then it would not be ignored.


> Anyhow, I don't want to get into bashing Java.  And I thank you for
> pointing out Clojure, I tried it out (but I am staying with CL in the
> short run).  Just please market it less aggressively.

I will reduce my posting frequency. I prefer to spend my spare freetime
with more productive things. My CL/CLJ job keeps me busy enough.


André
-- 
Lisp is not dead. It’s just the URL that has changed:
http://clojure.org/
From: Pascal Costanza
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71mm0dFkkhkoU2@mid.individual.net>
André Thieme wrote:
> Tamas K Papp schrieb:
>> I don't see why criticizing Java, even heavily, counts as "arrogant". 
>> Perhaps as off-topic, on c.l.l.
> 
> Well, I see it just as a tool, as the (or one of the) most popular
> programming languages. It is not for me, but I see that Gosling and
> Steele must have done something right.
> And only because Guy Steele is a Java guy it does not mean that he
> is unproductive.


Guy Steele is not a Java guy: See 
http://www.ai.mit.edu/projects/dynlangs/wizards-panels.html and 
especially 
http://www.ai.mit.edu/projects/dynlangs/dynlang-wizards-10may01.mov


Pascal

-- 
ELS'09: http://www.european-lisp-symposium.org/
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
From: Pascal J. Bourguignon
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <87hc21wznt.fsf@galatea.local>
Pascal Costanza <··@p-cos.net> writes:

> Andr� Thieme wrote:
>> Tamas K Papp schrieb:
>>> I don't see why criticizing Java, even heavily, counts as
>>> "arrogant". Perhaps as off-topic, on c.l.l.
>> Well, I see it just as a tool, as the (or one of the) most popular
>> programming languages. It is not for me, but I see that Gosling and
>> Steele must have done something right.
>> And only because Guy Steele is a Java guy it does not mean that he
>> is unproductive.
>
>
> Guy Steele is not a Java guy: See
> http://www.ai.mit.edu/projects/dynlangs/wizards-panels.html and
> especially
> http://www.ai.mit.edu/projects/dynlangs/dynlang-wizards-10may01.mov

Java is no Steel.  On the other hand, SBCL...  :-)

-- 
__Pascal Bourguignon__
From: neptundancer
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <ef62d8de-0d7d-4908-b6a5-e76bc470e605@a12g2000yqm.googlegroups.com>
> Do you have some examples? Maybe you can contrast how a lib in Java did
> not let you do what you wanted, while the CL equivalent is more liberal
> here.
>
> And is that common in your opinion? If yes, could you give several
> examples where CL libs let you do things different than the manual says
> while at the same time the Java equivalent must stick closely to the
> examples given in the docs/tutorials?
>

Joking right? So, a fair share of java shops use abomination like
Struts for doing web development. Compare it to Weblocks for example.

> >> CLOS just was not fit enough to become more popular.
> > Great. Let's buy all Britney Spears now! A man is intelligent. A mass
> > of people is as much intelligent as the loudest of them.
>
> It still is possible that the most intelligent man of all is doing Java.
> Even if the average is not so intelligent.
> Besides, I think it does not buy us anything by degrading users of
> popular programming languages.

Possible, but not probable. Most intelligent of programmers don't care
much about specific language anymore. And I am not degrading anyone -
I am just saying that when you have a majority of people in specific
group, they will be average by any means of measurement. If they were
all smart, the median of "smartness" would move higher, and they will
became average by that new measurement.

>
> And see that I wrote about fitness in a given environment.
> If we see the number of users of a language, the number of programs
> written in it, the number of jobs for language users and the number of
> books for a language as the basis for the fitness, then although CL can
> be regarded as „better” in the opinion of a minority, it still is not
> as fit as Java.
>
> > Popularity of Java is mostly because of marketing targeted at management,
>
>  > not because of quality.
>
> I don’t believe that.

Well, a large majority of people in this earth believe in some
religion even when it's utter crap. Believe what you want, but don't
mistake it for reality.

> CL had waay more time to conquer the world. What were CLs competitors in
> the 80ies? Fortran, C and Pascal. Oh, Basic.

I wish you invest more brain power to formalization of your arguments.
Read more about AI-winter, think about how fast average computer was
in the 80ies, how much advances of compiler technology was done in
recent 20 years. Think about how massive investment of marketing
forces was quite recently able to burn the myth "GC is slow" and
"Languages running in VM are slow" - that's the only visible positive
things I can associate with Java.

> CL is clearly much more powerful than these.
> The myth about Suns amazing marketing will maybe never go away.

I am tired of myths. Check facts: http://stlouis.bizjournals.com/sanjose/stories/1999/10/25/weekinbiz.html
You will find as many as you wish.

> This is what I meant by putting lipstick on the pig. We try to invent
> all kinds of rationalizations to defend CL and it’s status of being not
> popular.

I don't care whether CL is popular. People using CL don't spend all
day crying about CL not being popular, I don't know where you found
basis for your latter statement.

> Maybe we should face the truth that other languages got better.
> If those old promises of the 80ies, of 5x to 20x more productivity with
> CL were really true, then nearly all would use it. CL programs would
> constantly prove this productivity. It would enable you to do within
> minutes what other people need a day for.

Vast majority of commercial projects are just minor variations of each
other. So they invented language for average programmers for easy
gluing libs together and supported it with massive marketing aimed at
managers, since they (unfortunately) choose technologies. Sounds
"crazy" and surreal doesn't it? ;)

CL is not for average programmer and never was. Average Joe can't get
even over parentheses "problem" even when it's no problem at all when
you have decent editor. Do you expect this kind of mouse-click-build-
everything-i-am-programmer-just-for-money to actually make an
conscious opinion on they own, and base metrics of what is better/
worse on what they (don't) think? But yes, go ahead and measure
popularity! I feel a bit strange, when I see I have to explain such
obvious things here.

Andre, be happy with Clojure, I wish you success with your new golden
hammer.

But do you see CL people hang in clojure group and bash clojure
there?
No.
If you believe that you must save our poor souls from using such bad
language as CL and show us something "better", I assure you that you
don't need to sacrifice yourself, we have other caring members of this
group like Xach and Jon Retard Frog to show us light.

> André
> --
> Lisp is not dead. It’s just the URL that has changed:http://clojure.org/
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp3rke$mkb$1@news.motzarella.org>
neptundancer schrieb:
>> Do you have some examples? Maybe you can contrast how a lib in Java did
>> not let you do what you wanted, while the CL equivalent is more liberal
>> here.
>>
>> And is that common in your opinion? If yes, could you give several
>> examples where CL libs let you do things different than the manual says
>> while at the same time the Java equivalent must stick closely to the
>> examples given in the docs/tutorials?
>>
> 
> Joking right? So, a fair share of java shops use abomination like
> Struts for doing web development. Compare it to Weblocks for example.

I am not joking. There are so many Java libs, I only know a part of
them. In the past 6 years I was nearly exclusively doing CL.
So I will need your explanations to understand better at what point
Java libs don't allow one to do things as one likes to, but where
this is possible at the same time in CL.
I don't know Struts, but I worked with AllegroServe (portable
aserve under sbcl, but also the official aserve with the wonderful ACL
Enterprise).
I was hoping for a more concrete example, but at least you now mentioned
one lib at which I can look. Are there other Java libs, +/- equivalent
to Struts? Do they have the same problem?
And are the Struts problems representative for the majority of Java
libs?


>>>> CLOS just was not fit enough to become more popular.
>>> Great. Let's buy all Britney Spears now! A man is intelligent. A mass
>>> of people is as much intelligent as the loudest of them.
>> It still is possible that the most intelligent man of all is doing Java.
>> Even if the average is not so intelligent.
>> Besides, I think it does not buy us anything by degrading users of
>> popular programming languages.
> 
> Possible, but not probable. Most intelligent of programmers don't care
> much about specific language anymore. And I am not degrading anyone -
> I am just saying that when you have a majority of people in specific
> group, they will be average by any means of measurement. If they were
> all smart, the median of "smartness" would move higher, and they will
> became average by that new measurement.

Yes, sounds plausible to me.



>> And see that I wrote about fitness in a given environment.
>> If we see the number of users of a language, the number of programs
>> written in it, the number of jobs for language users and the number of
>> books for a language as the basis for the fitness, then although CL can
>> be regarded as �better� in the opinion of a minority, it still is not
>> as fit as Java.
>>
>>> Popularity of Java is mostly because of marketing targeted at management,
>>  > not because of quality.
>>
>> I don�t believe that.
> 
> Well, a large majority of people in this earth believe in some
> religion even when it's utter crap. Believe what you want, but don't
> mistake it for reality.

The thing with religion is: there is no evidence at all for the
existance of Gods. But I presented evidence why the marketing myth is
nothing more than a myth.


>> CL had waay more time to conquer the world. What were CLs competitors in
>> the 80ies? Fortran, C and Pascal. Oh, Basic.
> 
> I wish you invest more brain power to formalization of your arguments.
> Read more about AI-winter, think about how fast average computer was
> in the 80ies, how much advances of compiler technology was done in
> recent 20 years. Think about how massive investment of marketing
> forces was quite recently able to burn the myth "GC is slow" and
> "Languages running in VM are slow" - that's the only visible positive
> things I can associate with Java.

The AI-winter again. Do you really see this as a valid point?
There is this amazing programming language CL, which makes you 20x
more productive than any other programming language. Although this
greatly reduces costs for software development the companies still
were not interested in it?

Until Java 1.4 Java was indeed very slow.
Even in 2002 SBCL outperformed the JVM in several areas.
CL had a long history and was years ahead. It had better compilers
way before Java code began to run at bearable speed.
Even if the AI winter reduced the number of users of Lisp, then still
it had so very much more time to convince the world than Java, which
was mostly unusable until 2000. What did CL do between 1995 and 2000?
Python, Ruby & Co. were niche languages if they existed at all.
There was not serious competition for a long time.


>> CL is clearly much more powerful than these.
>> The myth about Suns amazing marketing will maybe never go away.
> 
> I am tired of myths. Check facts: http://stlouis.bizjournals.com/sanjose/stories/1999/10/25/weekinbiz.html
> You will find as many as you wish.

See, if Sun were that good at marketing, how comes that not most people
or companies run on Sun hardware?
This seems like cherry picking to me.
If a non-CL language becomes successful, then the reason is marketing
and is not connected to the language itself.
But if the same marketer can�t sell other products, then the reason
has to be found in the products?
Makes no sense to me.


>> This is what I meant by putting lipstick on the pig. We try to invent
>> all kinds of rationalizations to defend CL and it�s status of being not
>> popular.
> 
> I don't care whether CL is popular. People using CL don't spend all
> day crying about CL not being popular, I don't know where you found
> basis for your latter statement.

Why don't you care? If CL were more popular then CL programmers
would benefit from that. More jobs, more competition in open source
implementations and commercial ones. More books, more compatible
software and potentially more customers.


>> Maybe we should face the truth that other languages got better.
>> If those old promises of the 80ies, of 5x to 20x more productivity with
>> CL were really true, then nearly all would use it. CL programs would
>> constantly prove this productivity. It would enable you to do within
>> minutes what other people need a day for.
> 
> Vast majority of commercial projects are just minor variations of each
> other. So they invented language for average programmers for easy
> gluing libs together and supported it with massive marketing aimed at
> managers, since they (unfortunately) choose technologies. Sounds
> "crazy" and surreal doesn't it? ;)

To some extent I agree.
Java makes it easy to glue libs together. This is one of the main
reasons IMO why it is so successful. When someone writes a lib, then
it will be most likely compatible with other programs. All is written
in the same style.
The reduction of power in Java reduces also the complexity of how to
implement code. Mostly there are 1-3 ways to solve a problem, and they
mostly work together.
In CL the programmer has more power, but that can easily lead to
incompatibilities even inside one project.
Some OOP here, some functional programming there, a bit of imperative
style and ready is the mix. But those parts are not compatible with
each other. It really sounds not intuitive that reduction of power can
actually be a good choice.


> CL is not for average programmer and never was.

Was it a stated design goal, to make CL explicitly unfit for average
programmers?
How was this achvied? Wasn�t CL supposed to be *easier*?
I think it is Java/C#/XYZ that need so many design patterns that the
average programmer has to study.


> Average Joe can't get
> even over parentheses "problem" even when it's no problem at all when
> you have decent editor. Do you expect this kind of mouse-click-build-
> everything-i-am-programmer-just-for-money to actually make an
> conscious opinion on they own, and base metrics of what is better/
> worse on what they (don't) think?

Sounds like 14-23 year old beginners to me.
They can�t write medicore applications in any of todays programming
languages, until they get more experienced.


> But yes, go ahead and measure
> popularity! I feel a bit strange, when I see I have to explain such
> obvious things here.

Java and C# are surely interesting for beginners, and popular amongst
them, as they come with very advanced IDEs.
And yes, they make it trivial to mouse-click tiny programs into existance.
But for example Allegro also has a GUI builder. I think Franz got
input from customers who like that feature to be available.

Anyway, I was thinking more about something different.
We have CL, a well designed language. It is outdated today, and if the
committee were to create CL today it would most likely be a very
different language. But even though it is outdated, one can still
write apps in it. Not as productive as for example with Clojure
(my opinion), but still fine.
So although it was well designed, it did not appeal to more people.
It�s theoretical power did not keep its promises.
The CL world has Naughty Dog, Paul Grahams webapp and a few more.
We have to repeat them over and over again, but the constant flow
of success stories is missing. For other languages we see this every
day. So even if we admit that CL can be potentially "more powerful"
than other languages, it did not keep its promise in practice.



> Andre, be happy with Clojure, I wish you success with your new golden
> hammer.

Thank you :)
Hope you enjoy Erlang. It�s a very nice language.


> But do you see CL people hang in clojure group and bash clojure
> there? No.

Of course not. Why should they post non-Clojure stuff in a forum that
was made explicitly for Clojure?
Here in c.l.l however our topic is Lisp. So, it means Clojure is the
topic for this group, as well as CL and Scheme and Dylan.
Also I am not here to bash CL.
I told you that I see it as an advantage to not have something like
CLOS in Clojure, in the core language. It offers mechanisms that I like
more and that seem to be more promising. I can�t see how you make
bashing out of it.
But on the other hand I see people making false claims about Clojure,
even experienced and/or famous Lispers, who better should write some
Clojure code first, and study it for 2-5 months before they make public
posts. I want to correct those false claims, to show the group of CLers
who are interested in Clojure, that it still is worth looking at it.
More and more people from c.l.l change the camp, which is great.


> If you believe that you must save our poor souls from using such bad
> language as CL and show us something "better", I assure you that you
> don't need to sacrifice yourself, we have other caring members of this
> group like Xach and Jon Retard Frog to show us light.

I believe I need to save poor souls from reading BS about Clojure.
The most stupid claims about Clojure that I could find in the net were
in c.l.l.
Of course, that BS came from people who complained in the past that
trolls come to c.l.l and try to explain why CL sucks. Now these are the
people who try to explain what the design errors/problems of Clojure are.


Andr�
-- 
Lisp is not dead. It�s just the URL that has changed:
http://clojure.org/
From: Pascal Costanza
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71j1mrFlmgrcU1@mid.individual.net>
Andr� Thieme wrote:
> neptundancer schrieb:
>> On Mar 8, 7:21 pm, Andr� Thieme <address.good.until.
>> ···········@justmail.de> wrote:
>>> Vagif Verdi schrieb:
>>>
>>>> On Mar 8, 1:10 am, Marco Antoniotti <·······@gmail.com> wrote:
>>>>> Too many things lacking at the language level
>>>> Care to elaborate ?
>>> I suppose he means something like defstruct and defclass, plus the
>>> metaobject protocol. So, built in mechanisms for oop.
>>> Also he may mean: lack of reader macros and some few macro special ops,
>>> such as symbol-macrolet.
>>> I personally see it as a strong advantage of not having built-in support
>>> for OOP. I like that Clojure concentrates more on functional 
>>> programming.
>>> OOP had enough years, now functional programming has its turn.
>>> Concentrating on a main paradigm can produce more compatible code, and
>>> will make it easier for teams to work together.
>>>
>>> Not having (user definable) reader macros.. well, I would like to have
>>> them, but can understand that they may do more harm than good.
>>>
>>> Andr�
>>> -- 
>>> Lisp is not dead. It�s just the URL that has changed:http://clojure.org/
>>
>> Funny, that you see absence of such a powerful think like CLOS an
>> advantage because it's "OOP" (albeit the best OO system used in
>> practice), and with the same breath you don't mind buying Java
>> libraries "advantage" and Java interop (main selling point of
>> Clojure), not bothering that it's built on the very most crippled
>> "object" system ever designed.
> 
> Yes, again criticism of one of those experts who never even wrote
> a single line of Clojure code, great.
> I smell the turing argument here, which makes no sense.
> You know that under the hood all is machine language, yes?
> Zeros and Ones.
> Many Java libs get more testing each year than all CL libs
> together since they began to exist. I don�t care at all if those
> people implemented it in Java, Delphi or Assembler.
> Fact is, those libs are there. They are usable, mature and have
> several orders of magnitude more testing than all of what CL
> ever had.
> 
> The Java stuff is used in Clojure nearly exclusively to communicate
> with the world. Reading/writing data from/to disk, network, DB, etc.
> It�s not typical that you run into oop from the Java world when you
> write Clojure programs. Of course, you can�t know this since you
> don�t know much about Clojure. Just enough to feel the need to post
> here.
> 
> 
> If there were an oop mechanism built in into Clojure then some people
> would give oop solutions while other would follow the route that makes
> more sense, i.e. the functional route. That would lead to more
> incompatibility. In CL you ask ten people to solve a problem and you�ll
> get eleven solutions. All incompatible to each other. That just makes
> not much sense.
> CLOS just was not fit enough to become more popular. I don�t want to
> talk about better/worse, as this is very subjective. But obviously it
> was not fit, in an evolutionary way.
> We CLers (many of us, yes, including me) tried for years to put lipstick
> on the pig. We tried to rationalize every time when someone said:
> �Hey, if CL is that good, why are not more people using it�.
> It�s nearly 2010 and we should realize that it simply is not that good.

It's good that you're enthusiastic about your new tool. But it's not 
good that you write so much Blech. Calm down, ok? ;)


Pascal

-- 
ELS'09: http://www.european-lisp-symposium.org/
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
From: William James
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp26ob02rgd@enews2.newsguy.com>
Pascal Costanza wrote:

> 
> It's good that you're enthusiastic about your new tool. But it's not 
> good that you write so much Blech.

Says the Blech-meister himself.
From: André Thieme
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <govclq$848$1@news.motzarella.org>
Javier schrieb:
> Have you already switched from CL or Scheme to Clojure?
> 
> 
> If you did, why?

Yes.
I did it because it increases my productivity.
There is IMO not one single extremly important reason for that, but the
complete package, of sometimes only small things.
It begins with having only one namespace. This makes much sense for a
functional programming language, as Kent Pitman explains in one of his
essays.
Regarding this check:
http://groups.google.de/group/ruby-talk-google/msg/d6789460e5c77114

The little nice reader macros for Vectors and Hashmaps, wonderful.
Having when-not instead of unless is worth a million! As a non native
speaker "when-not" sounds a million times more familiar to me, and in
all my (six) CL years I always read (unless ...) aloud as (when-not ..).
Some weeks ago I posted other reasons. And you can find a more complete
list here:
http://www.youtube.com/watch?v=Aoeav_T1ARU&fmt=18
(1 out of 10 videos, each around 8 minutes, english language)



Andr�
-- 
Lisp is not dead. It�s just the URL that has changed:
http://clojure.org/
From: Javier
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <govgnn$fj9$1@aioe.org>
Andr� Thieme escribi�:
> Javier schrieb:
>> Have you already switched from CL or Scheme to Clojure?
>>
>>
>> If you did, why?
> 
> Yes.
> I did it because it increases my productivity.
> There is IMO not one single extremly important reason for that, but the
> complete package, of sometimes only small things.
> It begins with having only one namespace. This makes much sense for a
> functional programming language, as Kent Pitman explains in one of his
> essays.
> Regarding this check:
> http://groups.google.de/group/ruby-talk-google/msg/d6789460e5c77114


Oh, it is the famous William James. Please let me reproduce the text here:

-----8<--------8<-------8<------
Commune Lisp code is incredibly bloated, inelegant, and ugly.
Those who use it seem to delight in writing 10 lines of code
when 1 line should do.

Those who use it have no taste.

Bernard Lang:

Common Lisp did kill Lisp. Period.

  (just languages take a long time dying ...)

It is to Lisp what C++ is to C.  A monstrosity that totally ignores
the basics of language design, simplicity and orthogonality to begin
with.

Gilles Kahn:

To this day I have not forgotten that Common Lisp killed Lisp, and
forced us to abandon a perfectly good system, LeLisp.

Paul Graham, May 2001:

A hacker's language is terse and hackable. Common Lisp is not.

The good news is, it's not Lisp that sucks, but Common Lisp.

Jeffrey M. Jacobs:

Common LISP is the PL/I of Lisps.  Too big and
too incomprehensible, with no examiniation of the real world of
software engineering.

...  The CL effort resembles a bunch of spoiled children,
each insisting "include my feature or I'll pull out, and then we'll all
go down the tubes".  Everybody had vested interests, both financial
and emotional.

CL is a nightmare; it has effectively killed LISP development in this
country.  It is not commercially viable and has virtually no future
outside of the traditional academic/defense/research arena.

Dick Gabriel:

Common Lisp is a significantly ugly language.  If Guy and I had been
locked in a room, you can bet it wouldn't have turned out like that.

Having separate "value cells" and "function cells" (to use the "street
language" way of saying it) was one of the most unfortuanate issues.
We did not want to break pre-existing programs that had a global
variable named "foo" and a global function named "foo" that were
distinct.  We at Symbolics were forced to insist on this, in the face
of everyone's knowing that it was not what we would have done absent
compatibility constraints. It's hard for me to remember all the
specific things like this, but if we had had fewer compatibility
issues, I think it would have come out looking more like Scheme in
general.  ---  Daniel Weinreb, 24 Feb 2003

I have found that the disciples of Commune Lisp (CL) are literally
that---disciples.   They are completely irrational in their
religious devotion to the language.  I suspect that to them,
CL stands for the name of their god: Commode Lord.

If you want to use a Lisp, I suggest Clojure.

-----8<--------8<-------8<------


> 
> The little nice reader macros for Vectors and Hashmaps, wonderful.
> Having when-not instead of unless is worth a million! As a non native
> speaker "when-not" sounds a million times more familiar to me, and in
> all my (six) CL years I always read (unless ...) aloud as (when-not ..).
> Some weeks ago I posted other reasons. And you can find a more complete
> list here:
> http://www.youtube.com/watch?v=Aoeav_T1ARU&fmt=18
> (1 out of 10 videos, each around 8 minutes, english language)

Apart from this videos and the wiki on clojure.org, is there any serious
free book I can read in order to fully learn and understand Clojure?
From: Raffael Cavallaro
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <8aabd5d3-c629-4cab-9adf-12ad9a162269@z9g2000yqi.googlegroups.com>
On Mar 7, 11:16 pm, Javier <·······@gmail.com> wrote:

[regurgitation of ruby-guy noise mercifully snipped]

>
> is there any serious
> free book I can read in order to fully learn and understand Clojure?

If you were really serious, you wouldn't insist on free.

There's Programming Clojure, by Stuart Holloway, but he's <gasp!>
actually asking to be paid for his work:
<http://www.pragprog.com/titles/shcloj/programming-clojure>
From: Javier
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <govtgb$nrv$1@aioe.org>
Raffael Cavallaro escribi�:
> On Mar 7, 11:16 pm, Javier <·······@gmail.com> wrote:
> 
> [regurgitation of ruby-guy noise mercifully snipped]
> 
>> is there any serious
>> free book I can read in order to fully learn and understand Clojure?
> 
> If you were really serious, you wouldn't insist on free.
> 
> There's Programming Clojure, by Stuart Holloway, but he's <gasp!>
> actually asking to be paid for his work:
> <http://www.pragprog.com/titles/shcloj/programming-clojure>
> 

You're right, I'm not serious, I only intend to have fun for the moment,
but looking for a "serious" free book, which is a different thing.

So all right, I change the question, is there any good free book,
serious or not, about Clojure?
From: carlitos
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <3e2e6029-35fb-4476-978e-a5c21fe73665@l39g2000yqn.googlegroups.com>
On Mar 8, 8:54 am, Javier <·······@gmail.com> wrote:
> So all right, I change the question, is there any good free book,
> serious or not, about Clojure?

You might find the following link interesting (even if it's not a
book):
http://www.ociweb.com/mark/clojure/article.html

Cheers,

Carlos
From: Vagif Verdi
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <643c8908-6bda-4606-ba86-06960a6c46b1@z9g2000yqi.googlegroups.com>
On Mar 8, 12:54 am, Javier <·······@gmail.com> wrote:
> So all right, I change the question, is there any good free book,
> serious or not, about Clojure?

Here's the free and good one: http://ociweb.com/jnb/jnbMar2009.html
From: Thomas Stenhaug
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <871vt7973f.fsf@sed.eklatla.org>
Javier <·······@gmail.com> writes:

> So all right, I change the question, is there any good free book,
> serious or not, about Clojure?

Have you tried http://clojure.org/ yet?  On the left bar, there's a
section called "Reference."  The first chapter is "Getting started".
The remaining chapter cover the language, written by the author of the
language.  Does that work for you?

-- 
Thomas
From: ·······@gmail.com
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <1ae34c0e-6b89-435b-bfd5-f4bdcaba8d41@l16g2000yqo.googlegroups.com>
On Mar 7, 6:24 pm, Javier <·······@gmail.com> wrote:
> Have you already switched from CL or Scheme to Clojure?
>
> If you did, why?
>
> If not, why not?

Let me be the first to answer your question.

I spent a few weeks on it and thereby had renewed interest
in CL.  Clojure's agents are plausible in CL, cl-stm already
exists, and ABCL provides with the usual linguistic benefits
of CL more facilities than Clojure would have to create a
more pleasant and powerful way to talk with Java, which
Clojure rehabilitated for me.

Also, I read Let Over Lambda.

--

André Thieme wrote:

> Also he may mean: lack of reader macros and some few macro
special ops, such as symbol-macrolet.

You speak dismissively of symbol-macrolet when you do not
even have macrolet.

Here is something that macrolet can do:

(defmacro cloop (bindings &body body)
  "\
(cloop [n 5 acc 0]
  (if (zerop n)
    acc
    (recur (1- n) (+ acc n))))"
  (let* ((binding-list (syntax-vector bindings))
         (vars (loop repeat (/ (length binding-list) 2)
                     collect (gensym)))
         (block (gensym))
         (tag (gensym)))
    `(macrolet ((recur ,vars
                  `(progn
                     (psetq ,.(loop for binding in ',binding-list
                                      by #'cddr
                                    for arg in (list ,@vars)
                                    collect binding
                                    collect arg))
                     (go ,',tag))))
       (block ,block
         (clet ,bindings
           (tagbody
              ,tag (return-from ,block (progn ,@body))))))))

The 'c' stands for 'clojure'.  There's some other code like
this at

  http://github.com/ayrnieu/disclojure/tree/master
From: Javier
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp2eqp$qgi$1@aioe.org>
·······@gmail.com escribi�:
> On Mar 7, 6:24 pm, Javier <·······@gmail.com> wrote:
>> Have you already switched from CL or Scheme to Clojure?
>>
>> If you did, why?
>>
>> If not, why not?
> 
> Let me be the first to answer your question.
> 
> I spent a few weeks on it and thereby had renewed interest
> in CL.  Clojure's agents are plausible in CL, cl-stm already
> exists, and ABCL provides with the usual linguistic benefits
> of CL more facilities than Clojure would have to create a
> more pleasant and powerful way to talk with Java, which
> Clojure rehabilitated for me.
> 
> Also, I read Let Over Lambda.
> 
> --
> 
> Andr� Thieme wrote:
> 
>> Also he may mean: lack of reader macros and some few macro
> special ops, such as symbol-macrolet.
> 
> You speak dismissively of symbol-macrolet when you do not
> even have macrolet.
> 
> Here is something that macrolet can do:
> 
> (defmacro cloop (bindings &body body)
>   "\
> (cloop [n 5 acc 0]
>   (if (zerop n)
>     acc
>     (recur (1- n) (+ acc n))))"
>   (let* ((binding-list (syntax-vector bindings))
>          (vars (loop repeat (/ (length binding-list) 2)
>                      collect (gensym)))
>          (block (gensym))
>          (tag (gensym)))
>     `(macrolet ((recur ,vars
>                   `(progn
>                      (psetq ,.(loop for binding in ',binding-list
>                                       by #'cddr
>                                     for arg in (list ,@vars)
>                                     collect binding
>                                     collect arg))
>                      (go ,',tag))))
>        (block ,block
>          (clet ,bindings
>            (tagbody
>               ,tag (return-from ,block (progn ,@body))))))))
> 
> The 'c' stands for 'clojure'.  There's some other code like
> this at
> 
>   http://github.com/ayrnieu/disclojure/tree/master


Very interesting, but did you manage to make CL behaves the same with
respect to mutability? (Both in style and performance).
I mean, I think this is the most important difference, and probably the
sencod is its ability to talk to java. About syntax, we all know that it
is something easily changeable, in both CL and Clojure.
From: ·······@gmail.com
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <183e00cb-cb9e-481f-baa5-2f46da3856cc@j35g2000yqh.googlegroups.com>
Javier wrote:
> Very interesting, but did you manage to make CL behaves the same
with respect to mutability? (Both in style and performance).

I've no interest in this.

> [Syntax] is something easily changeable, in both CL and Clojure.

You're half right.
From: Pascal Costanza
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71kgqqFkn6vkU2@mid.individual.net>
Javier wrote:
> Very interesting, but did you manage to make CL behaves the same with
> respect to mutability? (Both in style and performance).

This is a weird question. If you don't want to perform side effects, you 
just don't do side effects. What's the problem?

> I mean, I think this is the most important difference, and probably the
> sencod is its ability to talk to java.

Java is crap. Who wants to talk to that? ;-)



Pascal

-- 
ELS'09: http://www.european-lisp-symposium.org/
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
From: Javier
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp34dv$dar$1@aioe.org>
Pascal Costanza escribi�:
> Javier wrote:
>> Very interesting, but did you manage to make CL behaves the same with
>> respect to mutability? (Both in style and performance).
> 
> This is a weird question. If you don't want to perform side effects, you
> just don't do side effects. What's the problem?

That the language do not allow and/or encourages using only functional
constructs?
If I understand Ricky and people behind Clojure, the problem is not
exactly what you can do with CL, but what you are allowed.

> 
>> I mean, I think this is the most important difference, and probably the
>> sencod is its ability to talk to java.
> 
> Java is crap. Who wants to talk to that? ;-)

Java might be crap, but we are talking here about the JVM, and the big
amount of libraries available for it, its cross platform features, among
others, like easily scalable (both up and down), universality,
availability, support, speed.....
From: Pascal Costanza
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71kqhfFllbf5U2@mid.individual.net>
Javier wrote:
> Pascal Costanza escribi�:
>> Javier wrote:
>>> Very interesting, but did you manage to make CL behaves the same with
>>> respect to mutability? (Both in style and performance).
>> This is a weird question. If you don't want to perform side effects, you
>> just don't do side effects. What's the problem?
> 
> That the language do not allow and/or encourages using only functional
> constructs?

I'm not interested in "pure" languages. They hardly ever scale.

> If I understand Ricky and people behind Clojure, the problem is not
> exactly what you can do with CL, but what you are allowed.

I'm not into bondage and discipline. ;) (And to ensure that I'm not 
misunderstood: I also don't have the impression that Rich Hickey is into 
bondage and discipline.)

>>> I mean, I think this is the most important difference, and probably the
>>> sencod is its ability to talk to java.
>> Java is crap. Who wants to talk to that? ;-)
> 
> Java might be crap, but we are talking here about the JVM, and the big
> amount of libraries available for it, its cross platform features, among
> others, like easily scalable (both up and down), universality,
> availability, support, speed.....

The libraries have no chance other than to stick to some of the very 
artificial and sometimes outright stupid restrictions of the class file 
format, which closely resembles the limitations of the Java language.

Sorry, no, not interested.


Pascal

-- 
ELS'09: http://www.european-lisp-symposium.org/
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
From: ·············@gmail.com
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <87acea82-a80f-43e8-85d7-42ade47f94f2@f37g2000vbf.googlegroups.com>
On 7 mar, 21:24, Javier <·······@gmail.com> wrote:
> Have you already switched from CL or Scheme to Clojure?
>
> If you did, why?
>
> If not, why not?

I tried clojure, and had the following problems with it: (1) It is
difficult to use, with all those path stuff, that remembers me Java;
path management is one of the weakest points of Java; I fail to use
many Java applications because of the path stuff; Clojure seems to
share the problem. (2) It adds a large runtime to Java's huge runtime;
another problem of Java is the large and slow runtime; Clojure adds to
the problem. I would love to use Clojure, if these problems were
solved. For instance, I would like to write applets in Clojure, but I
do not want to send 2M of runtime.
From: ········@gmail.com
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <62523181-82d0-4183-9b8a-bcc0202a76ba@j35g2000yqh.googlegroups.com>
On 8 Mar, 01:24, Javier <·······@gmail.com> wrote:
> Have you already switched from CL or Scheme to Clojure?
>
> If you did, why?
>
> why not?

Look at ECL, compare the size of deploying a single executable (say
for a simple and small tool), the whole startup time, the memory
footprint, and then look at Clojure...

I'm quite perfectly happy with CL, and I really appreciate all the
experience of many different Lisp creators enriching this beautiful
language.

Nobody forces you to use every single bit of CL, the same as nobody
forces JVM users to use all of Java libraries.
In either case you are *able* to -- opening your mind in the 1st case
(and closing it in the 2nd one).

-PM
From: Javier
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp4ti7$srs$2@aioe.org>
········@gmail.com escribi�:
> On 8 Mar, 01:24, Javier <·······@gmail.com> wrote:
>> Have you already switched from CL or Scheme to Clojure?
>>
>> If you did, why?
>>
>> why not?
> 
> Look at ECL, compare the size of deploying a single executable (say
> for a simple and small tool), the whole startup time, the memory
> footprint, and then look at Clojure...
> 
> I'm quite perfectly happy with CL, and I really appreciate all the
> experience of many different Lisp creators enriching this beautiful
> language.
> 
> Nobody forces you to use every single bit of CL, the same as nobody
> forces JVM users to use all of Java libraries.
> In either case you are *able* to -- opening your mind in the 1st case
> (and closing it in the 2nd one).
> 
> -PM
> 

Thanks for your opinion.
From: ···········@hotmail.com
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <892599f0-792f-4a20-ab00-465aeb546e27@r34g2000vbp.googlegroups.com>
On Mar 7, 9:24 pm, Javier <·······@gmail.com> wrote:
> Have you already switched from CL or Scheme to Clojure?
>
> If you did, why?
>
> If not, why not?

Why so much hyping about Clojure going on? If a language doesn't solve
a real problem then it is useless. Being "better" than CL in the
creator's opinion means nothing.

Common Lisp standardizes Lisp to avoid fragmentation, organizing the
features that make sense in a sensible way. There's nothing wrong with
it or its goals.

This new language offers nothing except some "subjective" improvements
(vectors instead of cons cells, really? Cons cells archaic, really?).
What, will you enumerate the properties of a singly linked list versus
a vector again? The stupidest sales pitch I have ever heard in my
life, because they can't even say how it improves the developers'
life.

So, the question is what the hell are you thinking? If you believe you
have a product then highlight its features and show cases where it has
been successfully implemented. Why starting some flame-war and stupid
comparisons that mean absolutely nothing objectively speaking?
From: William James
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp49nj01k0n@enews5.newsguy.com>
···········@hotmail.com wrote:

> Why so much hyping about Clojure going on?

Why so much hyping about Commune Lisp going on?

>                                          If a language doesn't solve
> a real problem then it is useless.

Yes, Commune Lisp is useless.

>                                    Being "better" than CL in the
> creator's opinion means nothing.

Being "better" than Clojure in your opinion means nothing.

> 
> Common Lisp standardizes Lisp to avoid fragmentation, organizing the
> features that make sense in a sensible way.

Yes, making sense in a sensible way is clearly the best way
to make sense.  Am I making sense?

>                                            There's nothing wrong with
> it or its goals.

Did your mommy tell you that?  Or your priest?

They were both wrong.


[Brooks and Gabriel 1984, 'A Critique of Common Lisp']:

  Every decision of the committee can be locally rationalized as
  the right thing. We believe that the sum of these decisions,
  however, has produced something greater than its parts; an
  unwieldy, overweight beast, with significant costs (especially on
  other than micro-codable personal Lisp engines) in compiler size
  and speed, in runtime performance, in programmer overhead needed
  to produce efficient programs, and in intellectual overload for a
  programmer wishing to be a proficient COMMON LISP programmer.


-----


Dan Weinreb:

I was one of the "Gang of Five" coordinators of the design
of Common Lisp, and I was one of the co-founders of Symbolics....

When choosing a language for a real-world project, the inherent
properties of the language (e.g. does it have real closures) usually
are, and should be, secondary to many practical considerations.  Will
we be able to hire programmers who know the language?  And if not,
will programmers be scared off by the language (e.g. by an unfamiliar
syntax), whether their reasons be "good" or "bad"?  Are there
implementations that are very well-debugged, highly optimized,
available on all relevant platforms, and free?

Chris's original point about availability of libraries is particularly
valid and germane.  And not only "are the libraries available" but are
they available on all platforms and will they continue to be upgraded
as the computing ecosystem upgrades, to handle new revisions of
underlying resources such as hardware, network protocols, window
systems, etc?

I take no position on whether these criteria are or are not true for
Lisp right now.  My point is about which criteria are the appropriate
ones to consider.

Programming language acceptance is a positive-feedback phenomenon, a
snowball effect, a bandwagon effect.  There are lots of people out
there writing libraries for, say, Java, and making fast Java
implementations, and they are putting those efforts into Java because
there are lot of Java users, not because of which programming language
features Java has versus which Lisp has.  And the result of their
efforts is that there are more Java users.


-----


Bernard Lang:

Common Lisp did kill Lisp. Period.

  (just languages take a long time dying ...)

It is to Lisp what C++ is to C.  A monstrosity that totally ignores
the basics of language design, simplicity and orthogonality to begin
with.


-----

Gilles Kahn:

To this day I have not forgotten that Common Lisp killed Lisp, and
forced us to abandon a perfectly good system, LeLisp.


-----

Paul Graham, May 2001:

A hacker's language is terse and hackable. Common Lisp is not.

The good news is, it's not Lisp that sucks, but Common Lisp.

Historically, Lisp has been good at letting hackers have their
way. The political correctness of Common Lisp is an aberration.
Early Lisps let you get your hands on everything.


-----

Jeffrey M. Jacobs:

Common LISP is the PL/I of Lisps.  Too big and
too incomprehensible, with no examiniation of the real world of
software engineering.

...  The CL effort resembles a bunch of spoiled children,
each insisting "include my feature or I'll pull out, and then we'll all
go down the tubes".  Everybody had vested interests, both financial
and emotional.

CL is a nightmare; it has effectively killed LISP development in this
country.  It is not commercially viable and has virtually no future
outside of the traditional academic/defense/research arena.


-----


Dick Gabriel:

Common Lisp is a significantly ugly language.  If Guy and I had been
locked in a room, you can bet it wouldn't have turned out like that.


-----

Paul Graham:

Do you really think people in 1000 years want to be
constrained by hacks that got put into the foundations of
Common Lisp because a lot of code at Symbolics depended on
it in 1988?


-----


Daniel Weinreb, 24 Feb 2003:

Having separate "value cells" and "function cells" (to use the "street
language" way of saying it) was one of the most unfortuanate issues.
We did not want to break pre-existing programs that had a global
variable named "foo" and a global function named "foo" that were
distinct.  We at Symbolics were forced to insist on this, in the face
of everyone's knowing that it was not what we would have done absent
compatibility constraints. It's hard for me to remember all the
specific things like this, but if we had had fewer compatibility
issues, I think it would have come out looking more like Scheme in
general.
From: ···········@hotmail.com
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <cc665ad6-82f9-4ca4-bbda-ea1b55d01be4@m4g2000vbp.googlegroups.com>
On 9 mar, 20:45, "William James" <·········@yahoo.com> wrote:
> ···········@hotmail.com wrote:
> > Why so much hyping about Clojure going on?
>
> Why so much hyping about Commune Lisp going on?
>
> >                                          If a language doesn't solve
> > a real problem then it is useless.
>
> Yes, Commune Lisp is useless.
>

How old are you? 10?

The only purpose to any language is to solve real problems. No real
problems, no use. I am still waiting to see real use cases for
Clojure, things that real developers would need to do in real
projects. Is it too difficult to understand?

Too much hype. Too much BS. Too little applications that could
actually justify the existence of Clojure to begin with. Why does it
exist then? Is it to Lisp what PHP is to Perl?

Common Lisp provides a Lisp with those features interesting to
businesses, with which you can build real large scale applications.

Lisp is not even mainstream, why in the hell would anybody even want
to "improve" it? You are preaching to the wrong people. We know Lisp,
we know what it can do. Do you want a subset of the Lisp market share?
Why so small-minded? Jesus. If there's a reason why Lisp never got
mainstream it is this kind of stupid mentality.

Get a life.
From: Tamas K Papp
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <71lt6jFm43noU1@mid.individual.net>
On Mon, 09 Mar 2009 17:59:44 -0700, thiago_work wrote:

> On 9 mar, 20:45, "William James" <·········@yahoo.com> wrote:
>> ···········@hotmail.com wrote:
>> > Why so much hyping about Clojure going on?
>>
>> Why so much hyping about Commune Lisp going on?
>>
>> >                                          If a
>> >                                          language
>> >                                          doesn't
>> >                                          solve
>> > a real problem then it is useless.
>>
>> Yes, Commune Lisp is useless.
>>
>>
> How old are you? 10?

W J is a troll, don't talk to him, put him in your killfile and be
done with it.

> Too much hype. Too much BS. Too little applications that could actually
> justify the existence of Clojure to begin with. Why does it exist then?
> Is it to Lisp what PHP is to Perl?

I tried Clojure and didn't leave CL for it, nevertheless I don't think
that they have to "justify the existence" of the language to anyone.
It is enough that there are people working on it, the answer to nobody
but themselves, which is as it should be. 

> Lisp is not even mainstream, why in the hell would anybody even want to
> "improve" it? You are preaching to the wrong people. We know Lisp, we

He is not preaching, that would imply some semantic coherence.  He is
trolling.  Don't confuse him with actual Clojure users who can be
quite ok, even though some of them are preachy or zealous occasionally.

> so small-minded? Jesus. If there's a reason why Lisp never got
> mainstream it is this kind of stupid mentality.

Again, the troll lacks a mentality, that would require a mind.  He is
just baiting you.  Ignore him.

Tamas
From: Pillsy
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <4160a501-1936-4bb3-8d47-1d946adf1af0@a12g2000yqm.googlegroups.com>
On Mar 9, 7:45 pm, "William James" <·········@yahoo.com> wrote:
[...]
> Why so much hyping about Commune Lisp going on?

I'm glad you gave the "COBOL LISP" nickname up, because it showed a
glimmer of wit on your part.  Stick with "Commune Lisp": the sad,
nonsensical desperation is much truer to your character.

Later,
Pillsy
From: Javier
Subject: Re: Have you already switched to Clojure?
Date: 
Message-ID: <gp4tl9$srs$3@aioe.org>
···········@hotmail.com escribi�:
> On Mar 7, 9:24 pm, Javier <·······@gmail.com> wrote:
>> Have you already switched from CL or Scheme to Clojure?
>>
>> If you did, why?
>>
>> If not, why not?
> 
> Why so much hyping about Clojure going on? If a language doesn't solve
> a real problem then it is useless. Being "better" than CL in the
> creator's opinion means nothing.
> 
> Common Lisp standardizes Lisp to avoid fragmentation, organizing the
> features that make sense in a sensible way. There's nothing wrong with
> it or its goals.
> 
> This new language offers nothing except some "subjective" improvements
> (vectors instead of cons cells, really? Cons cells archaic, really?).
> What, will you enumerate the properties of a singly linked list versus
> a vector again? The stupidest sales pitch I have ever heard in my
> life, because they can't even say how it improves the developers'
> life.
> 
> So, the question is what the hell are you thinking? If you believe you
> have a product then highlight its features and show cases where it has
> been successfully implemented. Why starting some flame-war and stupid
> comparisons that mean absolutely nothing objectively speaking?


You gain nothing insulting other's works.