I'm constantly hearing that Lisp is the best computer language ever
designed. I am particulary interested in knowing why it is better than
Java.
I'd like to read opinions from people using both IN THE REAL WORLD,
day by day, in their work, not just in theory.
Thank you.
Fran.
········@gmail.com wrote:
> I'm constantly hearing that Lisp is the best computer language ever
> designed. I am particulary interested in knowing why it is better than
> Java.
> I'd like to read opinions from people using both IN THE REAL WORLD,
> day by day, in their work, not just in theory.
>
> Thank you.
>
> Fran.
I have to say, I've used lisp a little, and Java a lot. I like both of
them for different reasons, and if I had the time to devote to become a
lisp expert, I probably would abandon Java after some time.
The reason I like Java so much is the tool support. I use an IDE, called
IntelliJ IDEA, which lets me refactor and redesign my entire project,
practically on the fly and incrementally.
I haven't spent the time to learn an lisp-centric tools, so I don't know
if they have the same kind of power. As for the language itself, LISP
has more "metaprogramming" expressiveness than does Java. LISP
metaprogramming is written in LISP changing the way you program.
Metaprogramming in Java requires adding complex service layers using
reflection, or preprocessing. Java metaprogramming is generally limited
in adding new constructs.
LISP is a high-power swiss-army knife with the safety removed, Java is a
tool-chest with a built-in instruction sheet. You can "do more" in
lisp, you might be able to "get more done" in Java.
This is just my experience. I have never had to work on a large LISP
project, and I have never had to maintain old LISP code, so I can't
comment on that part of it (which is arguably the most important
life-cycle component of a project).
--
Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>
On 12 oct, 18:57, Daniel Pitts
<····················@virtualinfinity.net> wrote:
> ········@gmail.com wrote:
> > I'm constantly hearing that Lisp is the best computer language ever
> > designed. I am particulary interested in knowing why it is better than
> > Java.
> > I'd like to read opinions from people using both IN THE REAL WORLD,
> > day by day, in their work, not just in theory.
>
> > Thank you.
>
> > Fran.
>
> I have to say, I've used lisp a little, and Java a lot. I like both of
> them for different reasons, and if I had the time to devote to become a
> lisp expert, I probably would abandon Java after some time.
>
> The reason I like Java so much is the tool support. I use an IDE, called
> IntelliJ IDEA, which lets me refactor and redesign my entire project,
> practically on the fly and incrementally.
>
> I haven't spent the time to learn an lisp-centric tools, so I don't know
> if they have the same kind of power. As for the language itself, LISP
> has more "metaprogramming" expressiveness than does Java. LISP
> metaprogramming is written in LISP changing the way you program.
> Metaprogramming in Java requires adding complex service layers using
> reflection, or preprocessing. Java metaprogramming is generally limited
> in adding new constructs.
>
> LISP is a high-power swiss-army knife with the safety removed, Java is a
> tool-chest with a built-in instruction sheet. You can "do more" in
> lisp, you might be able to "get more done" in Java.
>
> This is just my experience. I have never had to work on a large LISP
> project, and I have never had to maintain old LISP code, so I can't
> comment on that part of it (which is arguably the most important
> life-cycle component of a project).
You opinnion is very useful, even if you haven't done nothing serius
in Lisp yet.
Talking about people not doing large projects in Lisp, this is one of
the things I'm more afraid of, because I think: if there are no serius
projects in Lisp, is it because there is something bad about the
language itself?
What do you think about emacs? Is it a competent IDE, any comparable
with the Java IDE you use, or Netbeans?
Cross-post dropped, as I don't want to fan flames in Java-land.
········@gmail.com writes:
> On 12 oct, 18:57, Daniel Pitts
> <····················@virtualinfinity.net> wrote:
>> ········@gmail.com wrote:
>> > I'm constantly hearing that Lisp is the best computer language ever
>> > designed. I am particulary interested in knowing why it is better than
>> > Java.
>> > I'd like to read opinions from people using both IN THE REAL WORLD,
>> > day by day, in their work, not just in theory.
>>
>> > Thank you.
>>
>> > Fran.
>>
>> I have to say, I've used lisp a little, and Java a lot. I like both of
>> them for different reasons, and if I had the time to devote to become a
>> lisp expert, I probably would abandon Java after some time.
>>
>> The reason I like Java so much is the tool support. I use an IDE, called
>> IntelliJ IDEA, which lets me refactor and redesign my entire project,
>> practically on the fly and incrementally.
>>
>> I haven't spent the time to learn an lisp-centric tools, so I don't know
>> if they have the same kind of power. As for the language itself, LISP
>> has more "metaprogramming" expressiveness than does Java. LISP
>> metaprogramming is written in LISP changing the way you program.
>> Metaprogramming in Java requires adding complex service layers using
>> reflection, or preprocessing. Java metaprogramming is generally limited
>> in adding new constructs.
>>
>> LISP is a high-power swiss-army knife with the safety removed, Java is a
>> tool-chest with a built-in instruction sheet. You can "do more" in
>> lisp, you might be able to "get more done" in Java.
>>
>> This is just my experience. I have never had to work on a large LISP
>> project, and I have never had to maintain old LISP code, so I can't
>> comment on that part of it (which is arguably the most important
>> life-cycle component of a project).
>
> You opinnion is very useful, even if you haven't done nothing serius
> in Lisp yet.
>
> Talking about people not doing large projects in Lisp, this is one of
> the things I'm more afraid of, because I think: if there are no serius
> projects in Lisp, is it because there is something bad about the
> language itself?
>
>
> What do you think about emacs? Is it a competent IDE, any comparable
> with the Java IDE you use, or Netbeans?
Lisp with Emacs + SLIME blows the socks off of Java with Eclipse, and I
would imagine Netbeans as well (although I haven't used Netbeans
myself). Lisp is designed to be explored, examined, and interactively
prodded while it is operating. SLIME exposes that to Emacs. The result
is that you don't edit/compile/run/hope it works -- you launch Lisp and
start coding. You test the results. If you don't like what you see,
you modify a function, tell the system to recompile/reload that
function, which it does in the running Lisp process, and try again. It
allows for very gentle interative development.
Now, for answering the general question: I do know both Java and Lisp,
and don't prefer Java for anything. Since I usually don't have others
imposing language choices on me, if I want the benefits Java has over
Lisp (pretty much just static type checking, and perhaps ease of
packaging/redistribution of programs, as any of Java's other features as
a language are done better in Common Lisp IMO), I'll use another
language like OCaml or perhaps C++.
In my experience/opinion, Java constrains the mind and the programmer's
ability to solve problems by confining them to a rather small set of
paradigms; Common Lisp takes off all the limits.
- Michael
--
mouse, n: A device for pointing at the xterm in which you want to type.
Confused by the strange files? I cryptographically sign my messages.
For more information see <http://www.elehack.net/resources/gpg>.
On 12 okt, 20:58, Michael Ekstrand <·······@elehack.net> wrote:
> In my experience/opinion, Java constrains the mind and the programmer's
> ability to solve problems by confining them to a rather small set of
> paradigms; Common Lisp takes off all the limits.
And does not impose anything that you do not need.
Regards,
Jurgen
········@gmail.com wrote:
> On 12 oct, 18:57, Daniel Pitts
> <····················@virtualinfinity.net> wrote:
>> ········@gmail.com wrote:
>>> I'm constantly hearing that Lisp is the best computer language ever
>>> designed. I am particulary interested in knowing why it is better than
>>> Java.
>>> I'd like to read opinions from people using both IN THE REAL WORLD,
>>> day by day, in their work, not just in theory.
>>> Thank you.
>>> Fran.
>> I have to say, I've used lisp a little, and Java a lot. I like both of
>> them for different reasons, and if I had the time to devote to become a
>> lisp expert, I probably would abandon Java after some time.
>>
>> The reason I like Java so much is the tool support. I use an IDE, called
>> IntelliJ IDEA, which lets me refactor and redesign my entire project,
>> practically on the fly and incrementally.
>>
>> I haven't spent the time to learn an lisp-centric tools, so I don't know
>> if they have the same kind of power. As for the language itself, LISP
>> has more "metaprogramming" expressiveness than does Java. LISP
>> metaprogramming is written in LISP changing the way you program.
>> Metaprogramming in Java requires adding complex service layers using
>> reflection, or preprocessing. Java metaprogramming is generally limited
>> in adding new constructs.
>>
>> LISP is a high-power swiss-army knife with the safety removed, Java is a
>> tool-chest with a built-in instruction sheet. You can "do more" in
>> lisp, you might be able to "get more done" in Java.
>>
>> This is just my experience. I have never had to work on a large LISP
>> project, and I have never had to maintain old LISP code, so I can't
>> comment on that part of it (which is arguably the most important
>> life-cycle component of a project).
>
> You opinnion is very useful, even if you haven't done nothing serius
> in Lisp yet.
>
> Talking about people not doing large projects in Lisp, this is one of
> the things I'm more afraid of, because I think: if there are no serius
> projects in Lisp, is it because there is something bad about the
> language itself?
There may be large-scale products that are created in lisp, I just
haven't worked on any.
>
>
> What do you think about emacs? Is it a competent IDE, any comparable
> with the Java IDE you use, or Netbeans?
I haven't used emacs, but from what I understand, it is more extensible
than most IDE's, because it has a built-in lisp interface. It probably
depends on how you use it and what your doing, rather than "as a
product, x is better than y."
--
Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>
In article <·························@newsrazor.net>,
Daniel Pitts <····················@virtualinfinity.net> wrote:
> ········@gmail.com wrote:
> > I'm constantly hearing that Lisp is the best computer language ever
> > designed. I am particulary interested in knowing why it is better than
> > Java.
> > I'd like to read opinions from people using both IN THE REAL WORLD,
> > day by day, in their work, not just in theory.
> >
> > Thank you.
> >
> > Fran.
> I have to say, I've used lisp a little, and Java a lot. I like both of
> them for different reasons, and if I had the time to devote to become a
> lisp expert, I probably would abandon Java after some time.
>
> The reason I like Java so much is the tool support. I use an IDE, called
> IntelliJ IDEA, which lets me refactor and redesign my entire project,
> practically on the fly and incrementally.
Lisp lets you refactor and redesign the entire application
practically on the fly and incrementally - while the
application is running.
>
> I haven't spent the time to learn an lisp-centric tools, so I don't know
> if they have the same kind of power. As for the language itself, LISP
> has more "metaprogramming" expressiveness than does Java. LISP
> metaprogramming is written in LISP changing the way you program.
> Metaprogramming in Java requires adding complex service layers using
> reflection, or preprocessing. Java metaprogramming is generally limited
> in adding new constructs.
>
> LISP is a high-power swiss-army knife with the safety removed, Java is a
> tool-chest with a built-in instruction sheet. You can "do more" in
> lisp, you might be able to "get more done" in Java.
>
> This is just my experience. I have never had to work on a large LISP
> project, and I have never had to maintain old LISP code, so I can't
> comment on that part of it (which is arguably the most important
> life-cycle component of a project).
--
http://lispm.dyndns.org/
P� Sun, 12 Oct 2008 18:57:06 +0200, skrev Daniel Pitts
<····················@virtualinfinity.net>:
> I have to say, I've used lisp a little, and Java a lot. I like both of
> them for different reasons, and if I had the time to devote to become a
> lisp expert, I probably would abandon Java after some time.
>
> The reason I like Java so much is the tool support. I use an IDE, called
> IntelliJ IDEA, which lets me refactor and redesign my entire project,
> practically on the fly and incrementally.
>
> I haven't spent the time to learn an lisp-centric tools, so I don't know
> if they have the same kind of power. As for the language itself, LISP
> has more "metaprogramming" expressiveness than does Java. LISP
> metaprogramming is written in LISP changing the way you program.
> Metaprogramming in Java requires adding complex service layers using
> reflection, or preprocessing. Java metaprogramming is generally limited
> in adding new constructs.
>
> LISP is a high-power swiss-army knife with the safety removed, Java is a
> tool-chest with a built-in instruction sheet. You can "do more" in
> lisp, you might be able to "get more done" in Java.
>
> This is just my experience. I have never had to work on a large LISP
> project, and I have never had to maintain old LISP code, so I can't
> comment on that part of it (which is arguably the most important
> life-cycle component of a project).
>
Personally I am sold on LispWorks which to me is the most workable Lisp
environment. Don't even think of using it without Edi Weitz starter pack.
But in combo they produce a very strong environment. Not easy to
understand at first, but after a week you will be laughing and you will be
wondering why other IDE's don't provide these things. I've tried other
things, but I keep returning to this one when I need serious work done.
--------------
John Thingstad
········@gmail.com wrote:
> I'm constantly hearing that Lisp is the best computer language ever
> designed. I am particulary interested in knowing why it is better than
> Java.
> I'd like to read opinions from people using both IN THE REAL WORLD,
> day by day, in their work, not just in theory.
The answer lies in a question: why does Groovy exist?
hth,kzo
On Sun, 12 Oct 2008 09:41:49 -0700, franrgez wrote:
> I'm constantly hearing that Lisp is the best computer language ever
> designed. I am particulary interested in knowing why it is better than
> Java.
> I'd like to read opinions from people using both IN THE REAL WORLD, day
> by day, in their work, not just in theory.
How can you _use_ a computer language "in theory"? AFAIK all of us
operate IN THE REAL WORLD.
Go ahead and devote two months of your time to exploring both languages.
A good book for lisp is Practical Common Lisp, also available online.
Then decide for yourself.
Please understand that posting the question "Which is better, Foo or
Bar?" to comp.lang.foo and comp.lang.bar will not give you any useful
information. Your question is so general that you will only hear
generalities. You will have to see for yourself and make up your own
mind, nobody else can do that for you.
Some useful essays by Graham:
http://paulgraham.com/icad.html
http://paulgraham.com/diff.html
http://paulgraham.com/javacover.html
HTH,
Tamas
PS.: I have removed comp.lang.java* from my reply, as I see little use in
cross-posting.
TKP> Go ahead and devote two months of your time to exploring both
TKP> languages. A good book for lisp is Practical Common Lisp, also
TKP> available online. Then decide for yourself.
Practical Common Lisp also answers the question to some extent, since
Peter Seibel has Java experience and explains some Java vs Lisp arguments
in intro.
Some entity, AKA ········@gmail.com,
wrote this mindboggling stuff:
(selectively-snipped-or-not-p)
> I'm constantly hearing that Lisp is the best computer language ever
> designed. I am particulary interested in knowing why it is better than
> Java.
> I'd like to read opinions from people using both IN THE REAL WORLD,
> day by day, in their work, not just in theory.
Ah, the old question about what is the better hammer.
Well, it's like conquering a multi course meal, you know.
At first there is that fluid stuff one can battle with a spoon, but
there are a lot of different spoons to choose from, from theaspoon to
laddle.
Not only those but sometimes even a vork could be sufficient to
gobble up the stuff, provided one knows the differences between a
soupe, a potage and a consommee.
The same goes for a porkchop, a lot of knives can be used to cut a
piece that fits your mouth, but then again being the barbarian I am I
rather take the job in hand and gnaw it bare to the bone.
Hammers only suffice to crunch frozen yoghurt into swallow size pieces
or killing the roaches escaping from your salad.
Cor
HTH
--
Mijn Tools zijn zo modern dat ze allemaal eindigen op 'saurus'
(defvar My-Computer '((OS . "GNU/Emacs") (IPL . "GNU/Linux")))
SPAM DELENDA EST http://www.clsnet.nl/mail.php
Prime directive of crimeprevention : Present a Gun
········@gmail.com wrote:
> I'm constantly hearing that Lisp is the best computer language ever
> designed. I am particulary interested in knowing why it is better than
> Java.
> I'd like to read opinions from people using both IN THE REAL WORLD,
> day by day, in their work, not just in theory.
>
> Thank you.
Ah, you crossposted. You want a flamewar...
Pascal
--
Lisp50: http://www.lisp50.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/
On 12 oct, 18:52, Pascal Costanza <····@p-cos.net> wrote:
> ········@gmail.com wrote:
> > I'm constantly hearing that Lisp is the best computer language ever
> > designed. I am particulary interested in knowing why it is better than
> > Java.
> > I'd like to read opinions from people using both IN THE REAL WORLD,
> > day by day, in their work, not just in theory.
>
> > Thank you.
>
> Ah, you crossposted. You want a flamewar...
I don't exactly know what is a flamewar, but all I want is to reach
the maximum audence, both Java and Lisp users.
I have read some messages from you, you seem to know a lot of Lisp.
Have you used Java? Can you compare them? What do you actually use?
········@gmail.com wrote:
> On 12 oct, 18:52, Pascal Costanza <····@p-cos.net> wrote:
>> ········@gmail.com wrote:
>>> I'm constantly hearing that Lisp is the best computer language ever
>>> designed. I am particulary interested in knowing why it is better than
>>> Java.
>>> I'd like to read opinions from people using both IN THE REAL WORLD,
>>> day by day, in their work, not just in theory.
>>> Thank you.
>> Ah, you crossposted. You want a flamewar...
>
> I don't exactly know what is a flamewar, but all I want is to reach
> the maximum audence, both Java and Lisp users.
>
> I have read some messages from you, you seem to know a lot of Lisp.
> Have you used Java? Can you compare them? What do you actually use?
I have used both Java and Lisp, and strongly prefer Lisp.
You can find some reasons here: http://p-cos.net/lisp/guide.html (which
needs to be updated, but is still fairly accurate).
Pascal
--
Lisp50: http://www.lisp50.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/
On Oct 12, 9:52 am, Pascal Costanza <····@p-cos.net> wrote:
> ········@gmail.com wrote:
> > I'm constantly hearing that Lisp is the best computer language ever
> > designed. I am particulary interested in knowing why it is better than
> > Java.
> > I'd like to read opinions from people using both IN THE REAL WORLD,
> > day by day, in their work, not just in theory.
>
> > Thank you.
>
> Ah, you crossposted. You want a flamewar...
The one who wanted a flamewar is probably you, cause else you could
have just shut up.
Although i deem the original poster rather dim or inexperienced in
using online forum, but as far as his cross-posting goes, kudos!
See:
Cross-posting & Language Factions
http://xahlee.org/Netiquette_dir/cross-post.html
plain text version follows:
---------------------------------
Cross-posting & Language Factions
Xah Lee, 2007-03-29
(The following article is originally cross-posted on 2007-04-16 to the
folowing newsgroups: comp.lang.perl.misc, comp.lang.python,
comp.lang.lisp, comp.lang.java.programmer, comp.lang.functional.)
Dear tech geekers,
In a couple of posts in the past year i have crossed-posted (e.g.
recently What are OOP's Jargons and Complexities, Is laziness a
programer's virtue?, On Java's Interface (the meaning of interface in
computer programing), there are a some controversy, and lots of off-
topic and careless follow ups.
I think a few things today's tech geekers should remind themselves:
• If you deem something off-topic to “your” newsgroup, and want to
tech-geek by changing the “follow-up group”, start with yourself.
Please do not cross-post yourself, and tweak the follow-up, and
proudly proclaim that you changed the follow-up as a benign gesture.
• Please remind yourself what is on-topic and off-topic. Unless you
are the auhority of a online forum, otherwise, Meta-talk, and
policing, are off-topic in general, and only tends to worsen the
forum's quality. This issue is cleared up in online communications as
early as early 1990s.
• The facility of cross-posting is a good thing as a progress of
communication technology, and the action of cross-posting is a good
thing with respect to communication. What the common tech-geekers's
sensitivity to cross-posting are due to this collective's lack of
understanding of social aspects of communication. Cross-posting isn't
a problem. The problem is the power-struggling male nature and
defensiveness in propergating the tongues of a tech geeker's own.
Tech-geeker's behavior towards cross-posting over the years did
nothing to enhance the content quality of newsgroups, but engendered
among computing language factions incommunicado, and aided in the
proliferation of unnecessary re-invention (e.g. the likes of Perl,
PHP, Python, Ruby that are essentially the same) and stagnation (e.g.
the lisp camp with their above-it attitude).
If you are a programer of X and is learning Y or wondering about Y,
please do cross-post it. If your article is relevant to X, Y, and Z,
please cross post it. If you are really anti-cross-posting, please use
a online forum that is more specialized with controlled communication,
such as mailing lists, developer's blogs, and website-based forums.
I hope that the computing newsgroups will revive to its ancient nature
of verdant cross communication of quality content, as opposed to
today's rampant messages focused on politics, mutual sneering, closed-
mindedness, and careless postings.
References:
Tech Geekers versus Spammers
Netiquette Guidelines, 1995, by S Hambridge. (RFC 1855)
http://tools.ietf.org/html/rfc1855
Xah
∑ http://xahlee.org/
☄
········@gmail.com writes:
> I'm constantly hearing that Lisp is the best computer language ever
> designed. I am particulary interested in knowing why it is better than
> Java.
> I'd like to read opinions from people using both IN THE REAL WORLD,
> day by day, in their work, not just in theory.
For example:
http://groups.google.com/group/comp.programming/msg/9e7b8aaec1794126
--
__Pascal Bourguignon__ http://www.informatimago.com/
Our enemies are innovative and resourceful, and so are we. They never
stop thinking about new ways to harm our country and our people, and
neither do we. -- Georges W. Bush
On 12 oct, 19:01, ····@informatimago.com (Pascal J. Bourguignon)
wrote:
> ········@gmail.com writes:
> > I'm constantly hearing that Lisp is the best computer language ever
> > designed. I am particulary interested in knowing why it is better than
> > Java.
> > I'd like to read opinions from people using both IN THE REAL WORLD,
> > day by day, in their work, not just in theory.
>
> For example:http://groups.google.com/group/comp.programming/msg/9e7b8aaec1794126
I don't understand the Lisp code... seems very complicated. (I have
only basic Lisp knowledge for now). Is Lisp tipical code that way?
I think Lisp requires another way of thinking about problems...
········@gmail.com wrote:
> I think Lisp requires another way of thinking about problems...
s/requires/allows/
--
Joost Kremers ············@yahoo.com
Selbst in die Unterwelt dringt durch Spalten Licht
EN:SiS(9)
········@gmail.com writes:
> On 12 oct, 19:01, ····@informatimago.com (Pascal J. Bourguignon)
> wrote:
>> ········@gmail.com writes:
>> > I'm constantly hearing that Lisp is the best computer language ever
>> > designed. I am particulary interested in knowing why it is better than
>> > Java.
>> > I'd like to read opinions from people using both IN THE REAL WORLD,
>> > day by day, in their work, not just in theory.
>>
>> For example:http://groups.google.com/group/comp.programming/msg/9e7b8aaec1794126
>
> I don't understand the Lisp code... seems very complicated.
So there, you have your answer.
IN THE REAL WORLD, lisp code seems very complicated.
Stay with Java.
> (I have only basic Lisp knowledge for now).
But you've got the primordial Lisp knowledge: you put the parentheses
right. Now you only need to move the operator in first position, and
you'll be all set:
(have I :only (knowledge Lisp basic) :for now)
> Is Lisp tipical code that way?
Yes. And even more.
> I think Lisp requires another way of thinking about problems...
It's the reverse. Lisp doesn't impose you a way of thinking about
problems. YOU impose to lisp YOUR way of thinking about the
solutions.
- You've got a problem,
- you've got a brain,
- you thing about the problem with your brain,
- you write a solution,
- you shape lisp like clay to make it implement your solution.
--
__Pascal Bourguignon__ http://www.informatimago.com/
You're always typing.
Well, let's see you ignore my
sitting on your hands.
On 2008-10-12, ········@gmail.com <········@gmail.com> wrote:
> On 12 oct, 19:01, ····@informatimago.com (Pascal J. Bourguignon)
> wrote:
>> ········@gmail.com writes:
>> > I'm constantly hearing that Lisp is the best computer language ever
>> > designed. I am particulary interested in knowing why it is better than
>> > Java.
>> > I'd like to read opinions from people using both IN THE REAL WORLD,
>> > day by day, in their work, not just in theory.
>>
>> For example:http://groups.google.com/group/comp.programming/msg/9e7b8aaec1794126
>
> I don't understand the Lisp code... seems very complicated.
The Lisp code is complicated, because it's a much more complete implementation
of Memento than the Java code, with a level of automation that is not even
possible in Java (without writing Java source code to text files to be
fed back into the Java system).
The Java code shows only a hand-coded Memento for a single class, which knows
only how to save and restore a single data member (a String called state). You
have to write a new class like Memento each time, for each different class that
you want to be able to snapshot.
The Lisp code extends the language with an easy-to-use memento-defining
construct.
> (I have
> only basic Lisp knowledge for now). Is Lisp tipical code that way?
It's quite common for Lisp programs to provide language extensions for
themselves.
On 12 out, 14:41, ········@gmail.com wrote:
> I'd like to read opinions from people using both IN THE REAL WORLD,
> day by day, in their work, not just in theory.
IN THE REAL WORLD, I use whatever the bozo paying me a salary imposes
on me, be it Java, C++, .NET or any other crappy standardized
straitjacket programming environment targetted at easily replaceable
programmers/drones. It's never Lisp, Ruby, Python or whatever deemed
too dangerous for their potentially creativeness-liberating properties
in few unimpressive LOCs...
On Oct 12, 9:41 am, ········@gmail.com wrote:
> I'm constantly hearing that Lisp is the best computer language ever
> designed. I am particulary interested in knowing why it is better than
> Java.
> I'd like to read opinions from people using both IN THE REAL WORLD,
> day by day, in their work, not just in theory.
I've used both in real world. Java as a in-house developed web server
applet (~1999), and emacs lisp as rather personal hacks (since 2006).
between the 2, i think java the lang is a magnitude worse, but lisp in
practice due to its age-accumalted baggage and still lack of major
libraries... so on the whole, as far as real world coding is
concerned, i can't say one is better or worse. It really depends on
your need and area. Personally i'll choose lisp over java anyday as
much as i could.
I have writen a lot tutorials and criticisms on both. You might start
at these articles:
• Fundamental Problems of Lisp
http://xahlee.org/UnixResource_dir/writ/lisp_problems.html
• The Concepts and Confusions of Prefix, Infix, Postfix and Fully
Nested Notations
http://xahlee.org/UnixResource_dir/writ/notations.html
• What are OOP's Jargons and Complexities
http://xahlee.org/Periodic_dosage_dir/t2/oop.html
> I'm constantly hearing that Lisp is the best computer language ever
> designed.
Btw, that is pure bull shit. You can ignore it like one'd ignore
supertitions and housewife gossipes, or perhaps spend your next 10
years trying to believe it, and end up thinking you had bull shit sit
in your mind for a decade.
Xah
∑ http://xahlee.org/
☄
On Oct 12, 6:41 pm, ········@gmail.com wrote:
> I'm constantly hearing that Lisp is the best computer language ever
> designed.
From people who think it's the best computer language.
>I am particulary interested in knowing why it is better than
> Java.
It's a personal thing, I love it because of s-expressions, my brother
in law hates it because of the very same reason.
> I'd like to read opinions from people using both IN THE REAL WORLD,
> day by day, in their work, not just in theory.
And I want to know what's better violin or a piano?
Don't forget to crosspost to music.instrument.violin &
music.instrument.piano in your answer.
bobi
>
> Thank you.
>
> Fran.
On Oct 12, 12:41 pm, ········@gmail.com wrote:
> I'm constantly hearing that Lisp is the best computer language ever
> designed. I am particulary interested in knowing why it is better than
> Java.
Which is better, a minivan or a pickup truck? Depends on what you are
hauling, people or materials.
Which is better, a jet or a helicopter? Depends on where you are
going, the local heliport or across the country.
Which is better, Java or Lisp? Depends on what you are writing. I've
written very little Lisp, some Java, some C++, and a whole lot of
Perl. In my job, I mostly manipulate large text files, write to and
read from databases, and output various kinds of formats (CSV, Excel,
PDF, RTF, etc). Perl is just the right tool for this kind of work. If
I were writing large GUI apps, I'd use Java for sure.
Not sure what I'd use Lisp for, still figuring that one out, but I'll
tell you this as a Lisp newbie -- it will do things that are
unthinkable in either Perl or Java, and surely that is some kind of
advantage for appropriate tasks.
CC
cartercc wrote:
> Not sure what I'd use Lisp for, still figuring that one out, but I'll
> tell you this as a Lisp newbie -- it will do things that are
> unthinkable in either Perl or Java, and surely that is some kind of
> advantage for appropriate tasks.
Do you have an example of such an unthinkable thing? Everything you can do
in Lisp can be done in Java, even without rewriting a single line of
Lisp-code:
http://www.cliki.net/Armed%20Bear%20Lisp
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
On Oct 13, 8:25 am, Frank Buss <····@frank-buss.de>
> Do you have an example of such an unthinkable thing? Everything you can do
> in Lisp can be done in Java, even without rewriting a single line of
> Lisp-code:
Writing a program that rewrites the program every time it's run.
I was tasked to do exactly that -- write a program that would rewrite
itself every time it was executed. This was for a security project.
Couldn't do it in Java so I switched to C, and wound up using some
assembly that C called, but had to admit defeat after four months of
hard effort. The closest I got was changing the COFF to change the
memory addresses, but this was on Windows and the PE just wiped me
out.
When I learned about macros, I wrote a toy piece of code that changed
itself after every execution. I was so easy that I laughed out loud,
and got some very curious stares from the people I work around. (Each
run created some random data and wrote the random data back into the
source with every execution. Never did figure out how to do this with
Java.)
CC
cartercc wrote:
> Writing a program that rewrites the program every time it's run.
This is easy. E.g. take a look at Tomcat JSP, or one of the bytecode
generators, if you want more low-level access:
http://java-source.net/open-source/bytecode-libraries
This was even possible with some older JDKs, but starting with Java 6 now
it is officially integrated:
http://www.java2s.com/Code/Java/JDK-6/CompileaJavafilewithJavaCompiler.htm
Together with some classloader tricks (see the Tomcat example) it is
possible to rewrite a class, load and instantiate it multiple times.
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
On Oct 13, 9:09 am, Frank Buss <····@frank-buss.de> wrote:
> cartercc wrote:
> > Writing a program that rewrites the program every time it's run.
>
> This is easy. E.g. take a look at Tomcat JSP, or one of the bytecode
> generators, if you want more low-level access:
How can you rewrite a Windows PE file in Java while the program that
the PE file relates to is executing? How can you recompile the exe
while the process is running and loaded in memory? I can rewrite the
source file, but Windows won't let you recompile the executable while
the executable is running. The trick is to change the memory locations
to now locations while the old locations are still in the IP and the
SP.
CC
cartercc wrote:
> How can you rewrite a Windows PE file in Java while the program that
> the PE file relates to is executing? How can you recompile the exe
> while the process is running and loaded in memory? I can rewrite the
> source file, but Windows won't let you recompile the executable while
> the executable is running. The trick is to change the memory locations
> to now locations while the old locations are still in the IP and the
> SP.
In pure Java this is no problem. If you are using some Java to native
compiler, it could be more difficult, but in Windows it is possible to
rename an exe file while it is running. Then you can compile the file again
and start the new file, which deletes the copy on start.
Compiling to memory and executing from it is easy, too. See Win32Forth for
an example how to do it.
But I wonder why this should make your program more secure?
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
On Oct 13, 9:32 am, Frank Buss <····@frank-buss.de>
> In pure Java this is no problem. If you are using some Java to native
> compiler, it could be more difficult, but in Windows it is possible to
> rename an exe file while it is running. Then you can compile the file again
> and start the new file, which deletes the copy on start.
Windows will not let you recompile an executable while it is loaded in
memory. If you can do this, I would like very much to see your code.
Please post it.
> Compiling to memory and executing from it is easy, too. See Win32Forth for
> an example how to do it.
I looked at http://win32forth.sourceforge.net/ but did not see it. Can
you post a link?
> But I wonder why this should make your program more secure?
The point was to write metamorphic code in order to test antivirus
software. That is, at every execution, the program presents a
different name, a different code segment, a different data segment, a
different stack segment, and a different hash. IOW, *during execution*
the 'virus' would rewrite itself and recompile itself so that, the
next time it ran, it would be a different program and so fool software
designed to detect it.
It can be done, but I didn't have the skill to do it.
CC
From: Andrea Taverna (Tavs)
Subject: Re: Lisp vs Java
Date:
Message-ID: <gcv8h3$q51$1@aioe.org>
········@gmail.com ha scritto:
> I'm constantly hearing that Lisp is the best computer language ever
> designed. I am particulary interested in knowing why it is better than
> Java.
> I'd like to read opinions from people using both IN THE REAL WORLD,
> day by day, in their work, not just in theory.
>
> Thank you.
>
> Fran.
If I may, I'd like to add my humble opinion.
Java and Lisp are different languages with different stories and aims.
the former is statically typed, safe and object oriented.
Lisp is multiparadigm and dynamically typed, with the ability to use
static typing. It is also safe. But, IIRC, you could turn off some
run-time checks for efficiency. As you can do with Ada...
Both are strongly typed.
Java code is meant to be spread on networking environments and executed
safely as it is. The jvm has a built-in notion of sand-boxing
Lisp is a general purpose language.
Java is (or was) meant to be a simple language, with the best OO
features taken from other statically typed languages, like
Modula,Eiffel,Ada. It took the C syntax, which is not that bad, except,
maybe, for the <switch> statement...
Common Lisp is a big, complex language, whose last standard appeared in
1994. It is said to be bloated, 'cause the standardization commitee
tried to achieve lots of different goals while keeping some vestiges
from the past. IMO, it does need a new standard.
It could be said to be a bit ugly in some parts, but this happens, to
some degree, with every powerful and mulitparadigm language.
So, they're really different, hard to compare. Your question, moreover,
is about which one is better. It depends.
You can do almost anything with CL. It provides syntactic abstraction
which allows implementation to be hidden easily. It is highly dynamic.
OTOH, simple languages can be easier to program with. Being able to do
anything may not be necessary to get the things done.
The ability to abstract syntax may not keep up with the semantic
involved, i.e. you may read very terse lines of code whose semantic is
almost obscure.
You may have lazy evaluation, futures, any construct you may read in a
PLT book. You just have to install a proper package. You don't have to
wait a standard commitee to approve anything.
However having these features interacting with each other or with
preexisting code is maddening. And the lack of a common reference, to
tidy up the mess developers made by adding features on features, leads
to bloatness, poor documentation and "anarchy", i.e. you can't rely on a
"standardly used" library like JDK, which, in turn, scare away newcomers.
That's the reason for which simple or "bonding" languages are preferred
to Lisp when working in large environments.
As for Java, it is widely used. But in some areas it should be avoided.
For example, you may need more dynamism or weak typing. For such things
other languages are best suited. Scripting languages like perl, python,
ruby, (lisp) may accomplish the same goal with less effort.
Unfortunately, when you get a good tool, and I think java is one of
them, you'd like to use it as much as possible.
It may be extended in some ways. However, adding featuers to Java is
hard. there's always the risk of messing it up with "incompatible"
constructs.
I had the same question of yours before. To find the answer I forced
myself to know the reasons of positive and negative criticism of both
languages. It is said that to know a language, you have to know at least
10 things you don't like about it.
Here are some useful links
http://c2.com/cgi/wiki?search=lisp
http://c2.com/cgi/wiki?search=java
PS: Due to CL defects, new lisp dialactes have been spawning meantime.
There's a new one, _Clojure_, which runs on the JVM and can access Java
classes natively. Have fun
PPS: I personally find Grahams' opinion on programming languages vs lisp
arguable and distressing. If you do too, please remember that lisp
doesn't require you think that way ;)
AT
In article <············@aioe.org>,
"Andrea Taverna (Tavs)" <······@libero.it> wrote:
> ········@gmail.com ha scritto:
> > I'm constantly hearing that Lisp is the best computer language ever
> > designed. I am particulary interested in knowing why it is better than
> > Java.
> > I'd like to read opinions from people using both IN THE REAL WORLD,
> > day by day, in their work, not just in theory.
> >
> > Thank you.
> >
> > Fran.
>
> If I may, I'd like to add my humble opinion.
>
> Java and Lisp are different languages with different stories and aims.
> the former is statically typed, safe and object oriented.
> Lisp is multiparadigm and dynamically typed, with the ability to use
> static typing. It is also safe. But, IIRC, you could turn off some
> run-time checks for efficiency. As you can do with Ada...
> Both are strongly typed.
> Java code is meant to be spread on networking environments and executed
> safely as it is. The jvm has a built-in notion of sand-boxing
> Lisp is a general purpose language.
>
> Java is (or was) meant to be a simple language, with the best OO
> features taken from other statically typed languages, like
> Modula,Eiffel,Ada. It took the C syntax, which is not that bad, except,
> maybe, for the <switch> statement...
> Common Lisp is a big, complex language, whose last standard appeared in
> 1994. It is said to be bloated, 'cause the standardization commitee
> tried to achieve lots of different goals while keeping some vestiges
> from the past. IMO, it does need a new standard.
> It could be said to be a bit ugly in some parts, but this happens, to
> some degree, with every powerful and mulitparadigm language.
Much in CL is just library functionality. There is a relatively
small kernel of functionality that is needed to implement
much of the stuff above that. An extreme example is the
extended LOOP macro. It could be safely removed from the language
without doing any harm. Similar for CLOS.
On the opposite I thought that Java libraries tend to be very large
complicated object spaghetti with added sprinkles of
XML (remember EJBs?). If that were not enough, libraries
like JDO manipulate the byte code (!!!) to add persistence.
From watching highly-non-productive Java-teams in enterprises
I got the impression that Java-technology creates
a bigger maintenance nightmare than COBOL was ever able to.
I was watching a corporate intranet needed to be rebooted
every day for some years because of a memory leak in
a Java app (it was the clock that was displayed on every login
page for the corporate intranet user that was leaking the
memory - ha!). Complex websites were re-implemented with
ZERO reuse.
>
> So, they're really different, hard to compare. Your question, moreover,
> is about which one is better. It depends.
> You can do almost anything with CL. It provides syntactic abstraction
> which allows implementation to be hidden easily. It is highly dynamic.
> OTOH, simple languages can be easier to program with. Being able to do
> anything may not be necessary to get the things done.
> The ability to abstract syntax may not keep up with the semantic
> involved, i.e. you may read very terse lines of code whose semantic is
> almost obscure.
> You may have lazy evaluation, futures, any construct you may read in a
> PLT book. You just have to install a proper package. You don't have to
> wait a standard commitee to approve anything.
> However having these features interacting with each other or with
> preexisting code is maddening. And the lack of a common reference, to
> tidy up the mess developers made by adding features on features, leads
> to bloatness, poor documentation and "anarchy", i.e. you can't rely on a
> "standardly used" library like JDK, which, in turn, scare away newcomers.
> That's the reason for which simple or "bonding" languages are preferred
> to Lisp when working in large environments.
>
> As for Java, it is widely used. But in some areas it should be avoided.
> For example, you may need more dynamism or weak typing. For such things
> other languages are best suited. Scripting languages like perl, python,
> ruby, (lisp) may accomplish the same goal with less effort.
> Unfortunately, when you get a good tool, and I think java is one of
> them, you'd like to use it as much as possible.
> It may be extended in some ways. However, adding featuers to Java is
> hard. there's always the risk of messing it up with "incompatible"
> constructs.
>
> I had the same question of yours before. To find the answer I forced
> myself to know the reasons of positive and negative criticism of both
> languages. It is said that to know a language, you have to know at least
> 10 things you don't like about it.
> Here are some useful links
> http://c2.com/cgi/wiki?search=lisp
> http://c2.com/cgi/wiki?search=java
>
That is a mess.
> PS: Due to CL defects, new lisp dialactes have been spawning meantime.
> There's a new one, _Clojure_, which runs on the JVM and can access Java
> classes natively. Have fun
There is a Common Lisp implementation that does that, too.
>
> PPS: I personally find Grahams' opinion on programming languages vs lisp
> arguable and distressing. If you do too, please remember that lisp
> doesn't require you think that way ;)
>
> AT
--
http://lispm.dyndns.org/
P� Mon, 13 Oct 2008 20:05:48 +0200, skrev Rainer Joswig <······@lisp.de>:
>
> Much in CL is just library functionality. There is a relatively
> small kernel of functionality that is needed to implement
> much of the stuff above that. An extreme example is the
> extended LOOP macro. It could be safely removed from the language
> without doing any harm. Similar for CLOS.
>
loop yes. Removing CLOS would be troublesome. For instance the whole
exception system is buildt on top of it.
--------------
John Thingstad
On Oct 13, 8:59 pm, "John Thingstad" <·······@online.no> wrote:
> På Mon, 13 Oct 2008 20:05:48 +0200, skrev Rainer Joswig <······@lisp.de>:
>
>
>
> > Much in CL is just library functionality. There is a relatively
> > small kernel of functionality that is needed to implement
> > much of the stuff above that. An extreme example is the
> > extended LOOP macro. It could be safely removed from the language
> > without doing any harm. Similar for CLOS.
>
> loop yes. Removing CLOS would be troublesome. For instance the whole
> exception system is buildt on top of it.
>
> --------------
> John Thingstad
Well, you would just simplify a bit and use structures...
P� Mon, 13 Oct 2008 21:05:06 +0200, skrev ······@corporate-world.lisp.de
<······@corporate-world.lisp.de>:
> On Oct 13, 8:59 pm, "John Thingstad" <·······@online.no> wrote:
>> P� Mon, 13 Oct 2008 20:05:48 +0200, skrev Rainer Joswig
>> <······@lisp.de>:
>>
>>
>>
>> > Much in CL is just library functionality. There is a relatively
>> > small kernel of functionality that is needed to implement
>> > much of the stuff above that. An extreme example is the
>> > extended LOOP macro. It could be safely removed from the language
>> > without doing any harm. Similar for CLOS.
>>
>> loop yes. Removing CLOS would be troublesome. For instance the whole
>> exception system is buildt on top of it.
>>
>> --------------
>> John Thingstad
>
> Well, you would just simplify a bit and use structures...
Oh did I forget to mention that the entire stream library is also based on
CLOS.
Without read-object and print-object you would find yourself unable to say
print a integer value. Hardly a good place to be. Not that it can't be
done. You essentially end up with something equivalent of CLTL1. But this
is a MAJOR rewrite. Remember all exception handling should now be changed
to use just a string. That affects almost all functions. Many CL
implementors though it would be simpler to start with CLTL1 and then
extend from there. What they end up doing is having to essentially
implement everything twice thus taking twice the time rather than saving
time from not having to implement the rather forbidding internals of CLOS.
--------------
John Thingstad
On Oct 14, 12:09 am, "John Thingstad" <·······@online.no> wrote:
> På Mon, 13 Oct 2008 21:05:06 +0200, skrev ······@corporate-world.lisp.de
> <······@corporate-world.lisp.de>:
>
>
>
> > On Oct 13, 8:59 pm, "John Thingstad" <·······@online.no> wrote:
> >> På Mon, 13 Oct 2008 20:05:48 +0200, skrev Rainer Joswig
> >> <······@lisp.de>:
>
> >> > Much in CL is just library functionality. There is a relatively
> >> > small kernel of functionality that is needed to implement
> >> > much of the stuff above that. An extreme example is the
> >> > extended LOOP macro. It could be safely removed from the language
> >> > without doing any harm. Similar for CLOS.
>
> >> loop yes. Removing CLOS would be troublesome. For instance the whole
> >> exception system is buildt on top of it.
>
> >> --------------
> >> John Thingstad
>
> > Well, you would just simplify a bit and use structures...
>
> Oh did I forget to mention that the entire stream library is also based on
> CLOS.
It's not. In ANSI CL streams are not required to be CLOS objects.
> Without read-object and print-object you would find yourself unable to say
> print a integer value.
There is no READ-OBJECT in Common Lisp.
You can print integers with WRITE.
> Hardly a good place to be. Not that it can't be
> done. You essentially end up with something equivalent of CLTL1. But this
> is a MAJOR rewrite. Remember all exception handling should now be changed
> to use just a string.
Structures. Pre-CLtL2 had conditions defined independent of CLOS.
> That affects almost all functions. Many CL
> implementors though it would be simpler to start with CLTL1 and then
> extend from there. What they end up doing is having to essentially
> implement everything twice thus taking twice the time rather than saving
> time from not having to implement the rather forbidding internals of CLOS.
In ANSI CL CLOS is not needed much. Some CLOS functions have been
provided
(like PRINT-OBJECT or DOCUMENTATION), but there is nothing much that
couldn't be replaced by normal functions and structures. CLOS was
added
late in the game and it shows... Now, in many implementations CLOS
is used a lot (streams might be implemented with Gray Streams, etc.).
>
> --------------
> John Thingstad
On 14 oct, 00:31, ·······@corporate-world.lisp.de" <······@corporate-
world.lisp.de> wrote:
> On Oct 14, 12:09 am, "John Thingstad" <·······@online.no> wrote:
>
>
>
> > På Mon, 13 Oct 2008 21:05:06 +0200, skrev ······@corporate-world.lisp.de
> > <······@corporate-world.lisp.de>:
>
> > > On Oct 13, 8:59 pm, "John Thingstad" <·······@online.no> wrote:
> > >> På Mon, 13 Oct 2008 20:05:48 +0200, skrev Rainer Joswig
> > >> <······@lisp.de>:
>
> > >> > Much in CL is just library functionality. There is a relatively
> > >> > small kernel of functionality that is needed to implement
> > >> > much of the stuff above that. An extreme example is the
> > >> > extended LOOP macro. It could be safely removed from the language
> > >> > without doing any harm. Similar for CLOS.
>
> > >> loop yes. Removing CLOS would be troublesome. For instance the whole
> > >> exception system is buildt on top of it.
>
> > >> --------------
> > >> John Thingstad
>
> > > Well, you would just simplify a bit and use structures...
>
> > Oh did I forget to mention that the entire stream library is also based on
> > CLOS.
>
> It's not. In ANSI CL streams are not required to be CLOS objects.
>
> > Without read-object and print-object you would find yourself unable to say
> > print a integer value.
>
> There is no READ-OBJECT in Common Lisp.
>
> You can print integers with WRITE.
>
> > Hardly a good place to be. Not that it can't be
> > done. You essentially end up with something equivalent of CLTL1. But this
> > is a MAJOR rewrite. Remember all exception handling should now be changed
> > to use just a string.
>
> Structures. Pre-CLtL2 had conditions defined independent of CLOS.
>
> > That affects almost all functions. Many CL
> > implementors though it would be simpler to start with CLTL1 and then
> > extend from there. What they end up doing is having to essentially
> > implement everything twice thus taking twice the time rather than saving
> > time from not having to implement the rather forbidding internals of CLOS.
>
> In ANSI CL CLOS is not needed much. Some CLOS functions have been
> provided
> (like PRINT-OBJECT or DOCUMENTATION), but there is nothing much that
> couldn't be replaced by normal functions and structures. CLOS was
> added
> late in the game and it shows... Now, in many implementations CLOS
> is used a lot (streams might be implemented with Gray Streams, etc.).
>
>
>
> > --------------
> > John Thingstad
I don't understand nothing. :)
P� Tue, 14 Oct 2008 16:52:24 +0200, skrev Franccesco <········@gmail.com>:
>
> I don't understand nothing. :)
Well it's about like this. The ANSI committee started work in 1982. In
1984 they produced Common Lisp the Language which was a preliminary work
of the standards committee. This contained many of the elements of ANSI
common Lisp but lacked the Common Lisp Object system. This functions like
print and exceptions were implemented without them. In 1988 work started
on integrating the Common Lisp Object System. To utilize CLOS most
implementors reimplemented the stream system with CLOS. Also in 1990 a new
condition system based on CLOS was written. The point Joswig is making is
that the specification of the print, documentation and the exception
system were mostly written before CLOS was integrated. Thus the loss of
functionality implementing it without CLOS is not that great. That said if
you were to remove CLOS from a modern implementation things would stop
working and a major rewrite would be needed.
(I took the dates from the top of my head. There may be some inaccuracies.)
--------------
John Thingstad
On Oct 14, 6:08 pm, "John Thingstad" <·······@online.no> wrote:
> På Tue, 14 Oct 2008 16:52:24 +0200, skrev Franccesco <········@gmail.com>:
>
>
>
> > I don't understand nothing. :)
>
> Well it's about like this. The ANSI committee started work in 1982. In
> 1984 they produced Common Lisp the Language which was a preliminary work
> of the standards committee.
Almost. The book "Common Lisp the Language, first edition" was
published in
1984. AFTER that the effort to create an ANSI standard for Common Lisp
was decided
in Dec 1985. X3J13 was formed in 1986. New goals then:
'stricter standardization for portability, an object-oriented
programming system,
a condition system, iteration facilities, and a way to handle large
character sets'.
See also:
http://www.softwarepreservation.org/projects/LISP/conference/ilc02/Masayuki-Ida.pdf
The History of Lisp Standardization during 1984 – 1990, Masayuki Ida
> This contained many of the elements of ANSI
> common Lisp but lacked the Common Lisp Object system. This functions like
> print and exceptions were implemented without them. In 1988 work started
> on integrating the Common Lisp Object System. To utilize CLOS most
> implementors reimplemented the stream system with CLOS. Also in 1990 a new
> condition system based on CLOS was written. The point Joswig is making is
> that the specification of the print, documentation and the exception
> system were mostly written before CLOS was integrated. Thus the loss of
> functionality implementing it without CLOS is not that great. That said if
> you were to remove CLOS from a modern implementation things would stop
> working and a major rewrite would be needed.
Yep.
> (I took the dates from the top of my head. There may be some inaccuracies.)
>
> --------------
> John Thingstad
>>>>> "John" == John Thingstad <·······@online.no> writes:
John> P� Tue, 14 Oct 2008 16:52:24 +0200, skrev Franccesco <········@gmail.com>:
>>
>> I don't understand nothing. :)
John> Well it's about like this. The ANSI committee started work in 1982. In
John> 1984 they produced Common Lisp the Language which was a preliminary
John> work of the standards committee. This contained many of the elements
John> of ANSI common Lisp but lacked the Common Lisp Object system. This
John> functions like print and exceptions were implemented without them. In
John> 1988 work started on integrating the Common Lisp Object System. To
John> utilize CLOS most implementors reimplemented the stream system with
John> CLOS. Also in 1990 a new condition system based on CLOS was
John> written. The point Joswig is making is that the specification of the
John> print, documentation and the exception system were mostly written
John> before CLOS was integrated. Thus the loss of functionality
John> implementing it without CLOS is not that great. That said if you were
John> to remove CLOS from a modern implementation things would stop working
John> and a major rewrite would be needed.
Why would things stop working if CLOS were removed? Well, of course,
if you used CLOS, things would break, but if you didn't, there
wouldn't need to be any breakage would there?
Ray
On 15 oct, 00:42, Raymond Toy <···········@ericsson.com> wrote:
> Why would things stop working if CLOS were removed? Well, of course,
> if you used CLOS, things would break, but if you didn't, there
> wouldn't need to be any breakage would there?
Acording to HyperSpec:
"A type is a (possibly infinite) set of objects. An object can belong
to more than one type. Types are never explicitly represented as
objects by Common Lisp. Instead, they are referred to indirectly by
the use of type specifiers, which are objects that denote types.
New types can be defined using deftype, defstruct, defclass, and
define-condition. "
So the question is: what is the limit of what do you consider CLOS?
Just "defclass" and satelite macros and functions, or do you also
include more profound statements like deftype? Does not defstruct
define an object? Do you include defgeneric and defmethod too? Do you
consider built-in types CLOS objects?
I think CLOS is very much integrated into CL, up to the point that it
is not clear where are its boundaries... I would not say that you can
remove it without side effects...
Javier <·······@gmail.com> wrote:
+---------------
| Raymond Toy <···········@ericsson.com> wrote:
| > Why would things stop working if CLOS were removed? �Well, of course,
| > if you used CLOS, things would break, but if you didn't, there
| > wouldn't need to be any breakage would there?
|
| Acording to HyperSpec:
...[trimmed]...
| So the question is: what is the limit of what do you consider CLOS?
| Just "defclass" and satelite macros and functions, or do you also
| include more profound statements like deftype? Does not defstruct
| define an object? Do you include defgeneric and defmethod too? Do you
| consider built-in types CLOS objects?
|
| I think CLOS is very much integrated into CL, up to the point that it
| is not clear where are its boundaries... I would not say that you can
| remove it without side effects...
+---------------
I think what Raymond may be referring to is that even in some
current implementions of Common Lisp, CLOS is still very much
an "add-on", specifically, those whose CLOS implementation is
based on PCL (Portable Common Loops). For example, when rebuilding
CMUCL (as Raymond is quite aware!), first a very small "kernel"
core image is built without CLOS or even the compiler, then the
compiler is loaded in, and only then is CLOS compiled and loaded in
and the whole image saved out as the final core image. So during
this process there is a considerable period of time when there
*isn't* a CLOS in the system yet, yet there *is* DEFSTRUCT & DEFTYPE!!
[They are, in fact, used to bootstrap CLOS.]
-Rob
-----
Rob Warnock <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
>>>>> "Rob" == Rob Warnock <····@rpw3.org> writes:
Rob> Javier <·······@gmail.com> wrote:
Rob> +---------------
Rob> | Raymond Toy <···········@ericsson.com> wrote:
Rob> | > Why would things stop working if CLOS were removed? �Well, of course,
Rob> | > if you used CLOS, things would break, but if you didn't, there
Rob> | > wouldn't need to be any breakage would there?
Rob> |
Rob> | Acording to HyperSpec:
Rob> ...[trimmed]...
Rob> | So the question is: what is the limit of what do you consider CLOS?
Rob> | Just "defclass" and satelite macros and functions, or do you also
Rob> | include more profound statements like deftype? Does not defstruct
Rob> | define an object? Do you include defgeneric and defmethod too? Do you
Rob> | consider built-in types CLOS objects?
Rob> |
Rob> | I think CLOS is very much integrated into CL, up to the point that it
Rob> | is not clear where are its boundaries... I would not say that you can
Rob> | remove it without side effects...
Rob> +---------------
Rob> I think what Raymond may be referring to is that even in some
Rob> current implementions of Common Lisp, CLOS is still very much
Rob> an "add-on", specifically, those whose CLOS implementation is
Rob> based on PCL (Portable Common Loops). For example, when rebuilding
Rob> CMUCL (as Raymond is quite aware!), first a very small "kernel"
Rob> core image is built without CLOS or even the compiler, then the
Rob> compiler is loaded in, and only then is CLOS compiled and loaded in
Rob> and the whole image saved out as the final core image. So during
Rob> this process there is a considerable period of time when there
Rob> *isn't* a CLOS in the system yet, yet there *is* DEFSTRUCT & DEFTYPE!!
Rob> [They are, in fact, used to bootstrap CLOS.]
Yes, this was precisely what I was getting at, but I didn't want to
spill the beans quite yet. :-)
I think gcl uses pcl. Clisp used to, but doesn't anymore, I think.
Ray
>>>>> "Javier" == Javier <·······@gmail.com> writes:
Javier> On 15 oct, 00:42, Raymond Toy <···········@ericsson.com> wrote:
>> Why would things stop working if CLOS were removed? �Well, of course,
>> if you used CLOS, things would break, but if you didn't, there
>> wouldn't need to be any breakage would there?
Javier> Acording to HyperSpec:
Javier> "A type is a (possibly infinite) set of objects."
One should not be confused by the use of "object" here. According to the
Hyperspec glossary, we have this definition for "object":
object n. 1. any Lisp datum.
In other words, an object does not have to involve CLOS; cons also
produces objects in the hyperspec terminology. The objects produced by
`defclass' are just a particular kind of objects with special
characteristics.
The condition system was mentioned; without having looked very carefully
it does not seem obvious that SBCL implements conditions as CLOS
objects, so indeed I think that one could carve out CLOS if one wanted
to relatively easy (depending on the specific implementation).
------------------------+-----------------------------------------------------
Christian Lynbech | christian ··@ defun #\. dk
------------------------+-----------------------------------------------------
Hit the philistines three times over the head with the Elisp reference manual.
- ·······@hal.com (Michael A. Petonic)
On 15 oct, 21:50, Christian Lynbech <·········@defun.dk> wrote:
> >>>>> "Javier" == Javier <·······@gmail.com> writes:
>
> Javier> On 15 oct, 00:42, Raymond Toy <···········@ericsson.com> wrote:
>
> >> Why would things stop working if CLOS were removed? Well, of course,
> >> if you used CLOS, things would break, but if you didn't, there
> >> wouldn't need to be any breakage would there?
>
> Javier> Acording to HyperSpec:
>
> Javier> "A type is a (possibly infinite) set of objects."
>
> One should not be confused by the use of "object" here. According to the
> Hyperspec glossary, we have this definition for "object":
>
> object n. 1. any Lisp datum.
>
> In other words, an object does not have to involve CLOS; cons also
> produces objects in the hyperspec terminology. The objects produced by
> `defclass' are just a particular kind of objects with special
> characteristics.
So what do you consider CLOS, just defclass? Do you consider
defgeneric and defmethod part of CLOS, or not?
CLOS is the acronym of Common Lisp Object System. That is, object
system. I agree that you can remove defclass and defgeneric and
defmethod without side effects, but consider deftype, in which I
suppose defclass and defgeneric is based, would it exist if every data
was not considered to be an object? I think the influence of CLOS is
clearly visible in the entire type system of CL. Lot of things in its
design would not make any sense if CLOS was not there.
Javier wrote:
> On 15 oct, 21:50, Christian Lynbech <·········@defun.dk> wrote:
>
>>>>>>>"Javier" == Javier <·······@gmail.com> writes:
>>
>>Javier> On 15 oct, 00:42, Raymond Toy <···········@ericsson.com> wrote:
>>
>>
>>>>Why would things stop working if CLOS were removed? Well, of course,
>>>>if you used CLOS, things would break, but if you didn't, there
>>>>wouldn't need to be any breakage would there?
>>
>>Javier> Acording to HyperSpec:
>>
>>Javier> "A type is a (possibly infinite) set of objects."
>>
>>One should not be confused by the use of "object" here. According to the
>>Hyperspec glossary, we have this definition for "object":
>>
>> object n. 1. any Lisp datum.
>>
>>In other words, an object does not have to involve CLOS; cons also
>>produces objects in the hyperspec terminology. The objects produced by
>>`defclass' are just a particular kind of objects with special
>>characteristics.
>
>
> So what do you consider CLOS, just defclass? Do you consider
> defgeneric and defmethod part of CLOS, or not?
Great question. I always hesitate on that when denouncing the big
umbrella of CLOS. Can I dump CLOS and the MOP nad still have GFs? Please?
>
> CLOS is the acronym of Common Lisp Object System. That is, object
> system. I agree that you can remove defclass and defgeneric and
> defmethod without side effects, but consider deftype, in which I
> suppose defclass and defgeneric is based, would it exist if every data
> was not considered to be an object? I think the influence of CLOS is
> clearly visible in the entire type system of CL. Lot of things in its
> design would not make any sense if CLOS was not there.
Maybe go with PG's coolio idea of never banning anything, just use the
imagine a tax on the ugly stuff. Keep the freedom, but make explicit the
cost of something daft like CLOS. Lately we have seen folks here
struggling to wrestle CLOS into doing what they wanted the computer to
do. What they wanted was straightforward and clear to them and any
observer, but the whole of c.l.l ended up enlisted in the struggle to
get CLOS to do it. Man, is that the anithesis of a good tool.
kt
Kenny <·········@gmail.com> writes:
> Javier wrote:
>> On 15 oct, 21:50, Christian Lynbech <·········@defun.dk> wrote:
>>
>>>>>>>>"Javier" == Javier <·······@gmail.com> writes:
>>>
>>>Javier> On 15 oct, 00:42, Raymond Toy <···········@ericsson.com> wrote:
>>>
>>>
>>>>>Why would things stop working if CLOS were removed? Well, of course,
>>>>>if you used CLOS, things would break, but if you didn't, there
>>>>>wouldn't need to be any breakage would there?
>>>
>>>Javier> Acording to HyperSpec:
>>>
>>>Javier> "A type is a (possibly infinite) set of objects."
>>>
>>>One should not be confused by the use of "object" here. According to the
>>>Hyperspec glossary, we have this definition for "object":
>>>
>>> object n. 1. any Lisp datum.
>>>
>>>In other words, an object does not have to involve CLOS; cons also
>>>produces objects in the hyperspec terminology. The objects produced by
>>>`defclass' are just a particular kind of objects with special
>>>characteristics.
>> So what do you consider CLOS, just defclass? Do you consider
>> defgeneric and defmethod part of CLOS, or not?
>
> Great question. I always hesitate on that when denouncing the big
> umbrella of CLOS. Can I dump CLOS and the MOP nad still have GFs?
> Please?
You can define sublanguages of Common Lisp, and call them officially
"subsets of Common Lisp". As long as programs written in your
sublanguage work the same in a full Common Lisp implementation.
For example, we could define a subset of Common Lisp with no bignum,
where all integers are 32-bit, (and with (safety 3), where any
overflowing operation signals an ARITHMETIC-ERROR). A program that
works correctly in such a sublanguage would work correctly in a full
CL. (Formally, "work correctly" would need some definition, between
"conformant" and "does what we expected if we didn't shoot ourselves
in the feet").
So yes, you can dump whatever you want of CLOS and MOP and keep GFs,
and call the result a "subset of Common Lisp".
http://www.lispworks.com/documentation/HyperSpec/Body/01_g.htm
>> CLOS is the acronym of Common Lisp Object System. That is, object
>> system. I agree that you can remove defclass and defgeneric and
>> defmethod without side effects, but consider deftype, in which I
>> suppose defclass and defgeneric is based, would it exist if every data
>> was not considered to be an object? I think the influence of CLOS is
>> clearly visible in the entire type system of CL. Lot of things in its
>> design would not make any sense if CLOS was not there.
>
> Maybe go with PG's coolio idea of never banning anything, just use the
> imagine a tax on the ugly stuff. Keep the freedom, but make explicit
> the cost of something daft like CLOS. Lately we have seen folks here
> struggling to wrestle CLOS into doing what they wanted the computer to
> do. What they wanted was straightforward and clear to them and any
> observer, but the whole of c.l.l ended up enlisted in the struggle to
> get CLOS to do it. Man, is that the anithesis of a good tool.
When you have a hammer, everything looks like a nail. When you have
CLOS, everything looks like objects. Perhaps they shouldn't have
tried to use CLOS to do what was so clear in the beginning: just
implement their own DSL to write clearly what is clear.
--
__Pascal Bourguignon__
On 16 oct, 03:07, Javier <·······@gmail.com> wrote:
> On 15 oct, 21:50, Christian Lynbech <·········@defun.dk> wrote:
>
>
>
> > >>>>> "Javier" == Javier <·······@gmail.com> writes:
>
> > Javier> On 15 oct, 00:42, Raymond Toy <···········@ericsson.com> wrote:
>
> > >> Why would things stop working if CLOS were removed? Well, of course,
> > >> if you used CLOS, things would break, but if you didn't, there
> > >> wouldn't need to be any breakage would there?
>
> > Javier> Acording to HyperSpec:
>
> > Javier> "A type is a (possibly infinite) set of objects."
>
> > One should not be confused by the use of "object" here. According to the
> > Hyperspec glossary, we have this definition for "object":
>
> > object n. 1. any Lisp datum.
>
> > In other words, an object does not have to involve CLOS; cons also
> > produces objects in the hyperspec terminology. The objects produced by
> > `defclass' are just a particular kind of objects with special
> > characteristics.
>
> So what do you consider CLOS, just defclass? Do you consider
> defgeneric and defmethod part of CLOS, or not?
If you look at the spec, you'll notice that Chapter 7, "Objects", and
§ 4.3, "Classes" are stand apart textually, and there's not much
accommodation to them in the rest of the spec. Obvious things like a
sequence class aren't there, for example. The condition system is
annoyingly vague regarding the question of just what a condition is.
The mere existence of the define-condition macro shows that until
quite late in the game bets were hedged regarding CLOS, and throwing
the whole thing out was a distinct possibility.
It does weave its tendrils a little bit into the rest of the language,
but it's really not at all difficult to see what part of the spec is
CLOS, if you know that it was a semi-independent proposal and you're
not being intentionally dense.
On 16 oct, 12:57, "Thomas F. Burdick" <········@gmail.com> wrote:
> On 16 oct, 03:07, Javier <·······@gmail.com> wrote:
>
>
>
> > On 15 oct, 21:50, Christian Lynbech <·········@defun.dk> wrote:
>
> > > >>>>> "Javier" == Javier <·······@gmail.com> writes:
>
> > > Javier> On 15 oct, 00:42, Raymond Toy <···········@ericsson.com> wrote:
>
> > > >> Why would things stop working if CLOS were removed? Well, of course,
> > > >> if you used CLOS, things would break, but if you didn't, there
> > > >> wouldn't need to be any breakage would there?
>
> > > Javier> Acording to HyperSpec:
>
> > > Javier> "A type is a (possibly infinite) set of objects."
>
> > > One should not be confused by the use of "object" here. According to the
> > > Hyperspec glossary, we have this definition for "object":
>
> > > object n. 1. any Lisp datum.
>
> > > In other words, an object does not have to involve CLOS; cons also
> > > produces objects in the hyperspec terminology. The objects produced by
> > > `defclass' are just a particular kind of objects with special
> > > characteristics.
>
> > So what do you consider CLOS, just defclass? Do you consider
> > defgeneric and defmethod part of CLOS, or not?
>
> If you look at the spec, you'll notice that Chapter 7, "Objects", and
> § 4.3, "Classes" are stand apart textually, and there's not much
> accommodation to them in the rest of the spec. Obvious things like a
> sequence class aren't there, for example. The condition system is
> annoyingly vague regarding the question of just what a condition is.
> The mere existence of the define-condition macro shows that until
> quite late in the game bets were hedged regarding CLOS, and throwing
> the whole thing out was a distinct possibility.
Yes... I think we are meaning the same in essence, but each one from
the opposite point of view... I tend to view Lisp like any other
object oriented language, with the capability to manage code as data
(and the functions having a type or a class), and you tend to view
Lisp as a meta-programming language with an added object system.
> It does weave its tendrils a little bit into the rest of the language,
> but it's really not at all difficult to see what part of the spec is
> CLOS, if you know that it was a semi-independent proposal and you're
> not being intentionally dense.
If we speak strict with your logic, you can also remove, separately,
defmacro, loop and any other imperative feature, the REPL, and of
course CLOS, etc...
But CL is the sum of every one part, and they are very much mixed, and
every part must be perfectly integrated into the whole system.
Ok, being a little dense... what was before, the chicken or the egg,
that is, the data or the type? :-)
I think that deftype and conditions are there because someone thought
that they might be convenient for an object system. I think that if
you don't use them for defining CLOS, you end up using them for
defining your own object system. And this affect the entire system
because we are talking about defining types, the foundation of any
language.
>>>>> "Javier" == Javier <·······@gmail.com> writes:
Javier> I think that deftype and conditions are there because someone thought
Javier> that they might be convenient for an object system. I think that if
Javier> you don't use them for defining CLOS, you end up using them for
Javier> defining your own object system. And this affect the entire system
Javier> because we are talking about defining types, the foundation of any
Javier> language.
I disagree with the claim that deftype is there for the purpose of
CLOS. To me, CLOS is something on top, ie. that which you get from
`defclass' and `defmethod' and you could easily have a lisp without
it. It wouldn't be ANSI CL of course because the standard specifies that
CLOS must be there.
It makes perfectly good sense to talk about the type of that which
`cons' returns. However, few people would agree that a cons is an object
in the traditional OO sense (even though it is an object in the
terminology of the hyperspec). The fact that generic functions are able
to select methods based on generic types could be considered an
extension that allows GFs to play nicely with "ordinary" lisp objects.
Real OO objects (ie. those defined with `defclass' and created with
`make-instance') on the other hand are special in that they are (as part
of their definition) part of an inheritance hierarchy and are subject to
the metaobject protocols.
Structs admittedly have a limited kind of inheritance and thus navigate
a grey area between completely ordinary data and the sophisticated world
of OO data.
That types form a hierarchy as well is completely orthogonal to the
fact that CL is also OO. Even C has a type system and C types also form
hierarchies (and if C is claimed to be an OO language, all languages are
effectively OO and the concept looses all meaning).
------------------------+-----------------------------------------------------
Christian Lynbech | christian ··@ defun #\. dk
------------------------+-----------------------------------------------------
Hit the philistines three times over the head with the Elisp reference manual.
- ·······@hal.com (Michael A. Petonic)
Christian Lynbech <·········@defun.dk> wrote:
+---------------
| The condition system was mentioned; without having looked very carefully
| it does not seem obvious that SBCL implements conditions as CLOS
| objects, so indeed I think that one could carve out CLOS if one wanted
| to relatively easy (depending on the specific implementation).
+---------------
I can't speak to SBCL, but CMUCL implements conditions as a variant
of structure [which, however, is not actually of type STRUCTURE]:
cmu> (make-condition 'error)
#<ERROR {4898CC95}>
cmu> (describe *)
#<ERROR {4898CC95}> is a structure of type ERROR.
FUNCTION-NAME: NIL.
ACTUAL-INITARGS: NIL.
ASSIGNED-SLOTS: NIL.
cmu> (type-of **)
ERROR
cmu> (subtypep * 'condition)
T
T
cmu> (subtypep ** 'structure)
NIL
T
cmu>
But then there are special type hacks layered on top that make such
objects *appear* to be CLOS types, even though they aren't, really. ;-}
cmu> (find-class 'error)
#<CONDITION-CLASS ERROR {290C9EFD}>
cmu> (type-of *)
PCL::CONDITION-CLASS
cmu>
But as the CLHS says, you can't use MAKE-INSTANCE to make a CONDITION,
you have to use MAKE-CONDITION[1].
-Rob
[1] Or ERROR, CERROR, etc., which call MAKE-CONDITION internally:
cmu> (describe
(second
(multiple-value-list
(ignore-errors
(error "Wrong value: ~s" 5)))))
#<SIMPLE-ERROR {489DA80D}> is a structure of type SIMPLE-ERROR.
FUNCTION-NAME: "Top-Level Form".
ACTUAL-INITARGS: (:FORMAT-CONTROL "Wrong value: ~s" :FORMAT-ARGUMENTS (5)).
ASSIGNED-SLOTS: NIL.
cmu>
-----
Rob Warnock <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
John Thingstad wrote:
> P� Mon, 13 Oct 2008 20:05:48 +0200, skrev Rainer Joswig <······@lisp.de>:
>
>>
>> Much in CL is just library functionality. There is a relatively
>> small kernel of functionality that is needed to implement
>> much of the stuff above that. An extreme example is the
>> extended LOOP macro. It could be safely removed from the language
>> without doing any harm. Similar for CLOS.
Actually, one would do incredible harm because by the time yer done
you'll have Scheme.
CL without Loop? Unthinkable (and I was anti-loop until I learned it and
realized it was a DSL for iteration).
Isn't this how CL got to be CL? No one wanted to lose their favorite toys?
>>
>
> loop yes. Removing CLOS would be troublesome. For instance the whole
> exception system is buildt on top of it.
It's a slippery slope, eh? With a Turing machine at the bottom.
kt
On Oct 13, 3:26 pm, Kenny <·········@gmail.com> wrote:
> It's a slippery slope, eh? With a Turing machine at the bottom.
>
> kt
Or Lambda Calculus, depending on which way you go.
Brian <··············@gmail.com> writes:
> On Oct 13, 3:26�pm, Kenny <·········@gmail.com> wrote:
>> It's a slippery slope, eh? With a Turing machine at the bottom.
>>
>> kt
> Or Lambda Calculus, depending on which way you go.
Please, let us frighten little children.
TURING MACHINES at the bottom!
--
__Pascal Bourguignon__ http://www.informatimago.com/
NOTE: The most fundamental particles in this product are held
together by a "gluing" force about which little is currently known
and whose adhesive power can therefore not be permanently
guaranteed.
From: Raffael Cavallaro
Subject: Re: Lisp vs Java - ignore test reply
Date:
Message-ID: <gd2irb$9eq$1@aioe.org>
On 2008-10-13 18:49:16 -0400, ···@informatimago.com (Pascal J.
Bourguignon) said:
>
> Please, let us frighten little children.
> TURING MACHINES at the bottom!
Please ignore the contents of this post - it is just a test reply.
Sorry for the noise
We now return you to your regularly scheduled language flamewar...
"John Thingstad" <·······@online.no> writes:
> P� Mon, 13 Oct 2008 20:05:48 +0200, skrev Rainer Joswig <······@lisp.de>:
>
>>
>> Much in CL is just library functionality. There is a relatively
>> small kernel of functionality that is needed to implement
>> much of the stuff above that. An extreme example is the
>> extended LOOP macro. It could be safely removed from the language
>> without doing any harm. Similar for CLOS.
>>
>
> loop yes. Removing CLOS would be troublesome. For instance the whole
> exception system is buildt on top of it.
Not exactly:
error-clause::= (typespec ([var]) declaration* form*)
typespec---a type specifier.
Condition Type CONDITION
etc...
The exception mechanism is built on top of plain lisp types. When we
have CLOS, it's a smart move to implement these lisp types as the
shadow types of CLOS classes, but AFAIR it could live without CLOS.
--
__Pascal Bourguignon__ http://www.informatimago.com/
NOTE: The most fundamental particles in this product are held
together by a "gluing" force about which little is currently known
and whose adhesive power can therefore not be permanently
guaranteed.
On Mon, 13 Oct 2008 12:39:26 +0200, Andrea Taverna (Tavs) wrote:
> As for Java, it is widely used. But in some areas it should be avoided.
> For example, you may need more dynamism or weak typing. For such things
> other languages are best suited. Scripting languages like perl, python,
> ruby, (lisp) may accomplish the same goal with less effort.
Can't speak for Perl, but neither Python or Ruby are weakly typed but
instead categorized as "strong, dynamic".
regards,
Marek
> For example, you may need more dynamism or weak typing. For such things
> other languages are best suited. Scripting languages like perl, python,
> ruby, (lisp) may accomplish the same goal with less effort.
"If you need more of features foo and bar, then maybe you should look
at language Baz which implements foo and bar"
But features "foo" and "bar" are vague to the point of not saying
anything.
Why do you /really/ need foo and bar?
--
Mikael Jansson
http://mikael.jansson.be
Mikael Jansson <··············@gmail.com> writes:
>> For example, you may need more dynamism or weak typing. For such things
>> other languages are best suited. Scripting languages like perl, python,
>> ruby, (lisp) may accomplish the same goal with less effort.
>
> "If you need more of features foo and bar, then maybe you should look
> at language Baz which implements foo and bar"
>
> But features "foo" and "bar" are vague to the point of not saying
> anything.
But if there's no Baz which implements foo and bar, or such a Baz
contains a feature quux that is prohibitive, then you can use Lisp and
implement these foo and bar features and make it your dream language.
(defmacro foo ...)
(defmacro bar ...) ;-)
> Why do you /really/ need foo and bar?
--
__Pascal Bourguignon__
Pascal J. Bourguignon wrote:
> Mikael Jansson <··············@gmail.com> writes:
>
>>> For example, you may need more dynamism or weak typing. For such things
>>> other languages are best suited. Scripting languages like perl, python,
>>> ruby, (lisp) may accomplish the same goal with less effort.
>> "If you need more of features foo and bar, then maybe you should look
>> at language Baz which implements foo and bar"
>>
>> But features "foo" and "bar" are vague to the point of not saying
>> anything.
>
> But if there's no Baz which implements foo and bar, or such a Baz
> contains a feature quux that is prohibitive, then you can use Lisp and
> implement these foo and bar features and make it your dream language.
>
> (defmacro foo ...)
> (defmacro bar ...) ;-)
>
>
>> Why do you /really/ need foo and bar?
>
>
My dream language is case sensitive and uses infix operators. Oops,
sorry lisp. ;-)
--
Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>
Daniel Pitts <····················@virtualinfinity.net> writes:
> Pascal J. Bourguignon wrote:
>> Mikael Jansson <··············@gmail.com> writes:
>>
>>>> For example, you may need more dynamism or weak typing. For such things
>>>> other languages are best suited. Scripting languages like perl, python,
>>>> ruby, (lisp) may accomplish the same goal with less effort.
>>> "If you need more of features foo and bar, then maybe you should look
>>> at language Baz which implements foo and bar"
>>>
>>> But features "foo" and "bar" are vague to the point of not saying
>>> anything.
>> But if there's no Baz which implements foo and bar, or such a Baz
>> contains a feature quux that is prohibitive, then you can use Lisp and
>> implement these foo and bar features and make it your dream language.
>> (defmacro foo ...)
>> (defmacro bar ...) ;-)
>>
>>> Why do you /really/ need foo and bar?
>>
> My dream language is case sensitive and uses infix operators. Oops,
> sorry lisp. ;-)
(SETF (READTABLE-CASE *READTABLE*) :PRESERVE)
(DEFMACRO INFIX (&BODY BODY)
`(PROGN
,@(MAPCAR (LAMBDA (EXPR)
(COND
((ATOM EXPR) EXPR)
((= 3 (LENGTH EXPR))
(DESTRUCTURING-BIND (A OP B) EXPR
`(,OP (INFIX ,A) (INFIX ,B))))
(T (CONS (FIRST EXPR) (MAPCAR (LAMBDA (X) `(INFIX ,X)) (REST EXPR))))))
BODY)))
(INFIX ((3 + 4) * 6))
--> 42
(DEFUN INFIX-REPL ()
(LOOP
(TERPRI)
(PRINT
(EVAL
(PROGN (PRINC "> ") (FINISH-OUTPUT) `(INFIX ,(READ)))))))
C/USER[63]> (INFIX-REPL)
> ((3 + 4) * 6)
42
> (5 * (4 * (3 * 2)))
120
> (IF (3 = (1 + 2))
((40 + 2) PRINT *STANDARD-OUTPUT*)
((20 + 4) PRINT *STANDARD-OUTPUT*))
42
42
> (ABC SETF 1)
1
> (Abc SETF 2)
2
> (ABC LIST Abc)
(1 2)
>
This is just a sketch, you will have to work more on the integration
of infix expressions with lisp, if you want to inhering enough lisp to
make it usable, but you can see that the principle is quite trivial.
PS: In my opinion, INFIX is quite silly... But that's just me.
--
__Pascal Bourguignon__
P� Wed, 15 Oct 2008 18:07:18 +0200, skrev Pascal J. Bourguignon
<···@informatimago.com>:
>
> This is just a sketch, you will have to work more on the integration
> of infix expressions with lisp, if you want to inhering enough lisp to
> make it usable, but you can see that the principle is quite trivial.
>
>
> PS: In my opinion, INFIX is quite silly... But that's just me.
There is a infix package
http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/lisp/code/syntax/infix/0.html
Useful for formulas. Not for general functions.
--------------
John Thingstad
Pascal J. Bourguignon <···@informatimago.com> wrote:
+---------------
| Daniel Pitts <····················@virtualinfinity.net> writes:
| > My dream language is case sensitive and uses infix operators. Oops,
| > sorry lisp. ;-)
|
| (SETF (READTABLE-CASE *READTABLE*) :PRESERVE)
+---------------
Personally, I find that (SETF (READTABLE-CASE *READTABLE*) :INVERT)
is a more natural way to get a case-sensitive CL without having to
type all one's programs in uppercase. [But that's just me, maybe...]
+---------------
| PS: In my opinion, INFIX is quite silly... But that's just me.
+---------------
Here we agree! ;-}
-Rob
-----
Rob Warnock <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
On 16 oct, 12:02, ····@rpw3.org (Rob Warnock) wrote:
> Pascal J. Bourguignon <····@informatimago.com> wrote:
> +---------------
> | Daniel Pitts <····················@virtualinfinity.net> writes:
> | > My dream language is case sensitive and uses infix operators. Oops,
> | > sorry lisp. ;-)
> |
> | (SETF (READTABLE-CASE *READTABLE*) :PRESERVE)
> +---------------
>
> Personally, I find that (SETF (READTABLE-CASE *READTABLE*) :INVERT)
> is a more natural way to get a case-sensitive CL without having to
> type all one's programs in uppercase. [But that's just me, maybe...]
WHAT ARE YOU CRAZY, ROB? WHAT COULD POSSIBLY BE MORE NATURAL THAN
WRITING LISP IN UPPERCASE?! LISP IS FRUSTRATING AND PROGRAMMING IS AN
ANGRY ENDEAVOR!!! IF YOU'RE NOT SHOUTING AT YOUR COMPUTER, YOU SHOULD
BE SCREAMING AT ·····@!
Ahem. What I meant to say is, :invert readtable-case is one of the
under-appreciated gems in CL.
"Thomas F. Burdick" <········@gmail.com> writes:
> On 16 oct, 12:02, ····@rpw3.org (Rob Warnock) wrote:
>> Pascal J. Bourguignon <····@informatimago.com> wrote:
>> +---------------
>> | Daniel Pitts <····················@virtualinfinity.net> writes:
>> | > My dream language is case sensitive and uses infix operators. Oops,
>> | > sorry lisp. ;-)
>> |
>> | (SETF (READTABLE-CASE *READTABLE*) :PRESERVE)
>> +---------------
>>
>> Personally, I find that (SETF (READTABLE-CASE *READTABLE*) :INVERT)
>> is a more natural way to get a case-sensitive CL without having to
>> type all one's programs in uppercase. [But that's just me, maybe...]
>
> WHAT ARE YOU CRAZY, ROB? WHAT COULD POSSIBLY BE MORE NATURAL THAN
> WRITING LISP IN UPPERCASE?! LISP IS FRUSTRATING AND PROGRAMMING IS AN
> ANGRY ENDEAVOR!!! IF YOU'RE NOT SHOUTING AT YOUR COMPUTER, YOU SHOULD
> BE SCREAMING AT ·····@!
>
> Ahem. What I meant to say is, :invert readtable-case is one of the
> under-appreciated gems in CL.
I don't mind :PRESERVE.
It allows to define user symbols as mixed or lowercase, and have CL
symbols stand out, like in Modula-2.
(DEFUN fact (x) (IF (< x 1) 1 (* x (fact (1- x)))))
(DEFSTRUCT (possessions (:CONC-NAME ""))
car house money)
(car (CAR (LIST (MAKE-possessions :car 'volvo) (MAKE-possessions :car 'renault))))
--> volvo
--
__Pascal Bourguignon__
Pascal J. Bourguignon wrote:
> Daniel Pitts <····················@virtualinfinity.net> writes:
>> My dream language is case sensitive and uses infix operators. Oops,
>> sorry lisp. ;-)
> This is just a sketch, you will have to work more on the integration
> of infix expressions with lisp, if you want to inhering enough lisp to
> make it usable, but you can see that the principle is quite trivial.
Indeed, it seems like it was more possible than I thought, however, it
will definitely reduce the maintainability of that program, since it
doesn't follow standard LISP concepts :-)
>
>
> PS: In my opinion, INFIX is quite silly... But that's just me.
Actually, infix is *very* silly, but it is also conventional notation in
mathematics and algebra.
Anyway, thanks for the enlightenment. Lisp is truly *the* meta language. ;-)
--
Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>
From: Andrea Taverna (Tavs)
Subject: Re: Lisp vs Java
Date:
Message-ID: <gd52v7$p0d$1@aioe.org>
Mikael Jansson ha scritto:
> But features "foo" and "bar" are vague to the point of not saying
> anything.
>
> Why do you /really/ need foo and bar?
>
Because they may save me some effort, depending on the project on which
I'm working.
regards,
Andrea
········@gmail.com wrote:
> I'm constantly hearing that Lisp is the best computer language ever
> designed. I am particulary interested in knowing why it is better than
> Java.
> I'd like to read opinions from people using both IN THE REAL WORLD,
> day by day, in their work, not just in theory.
>
> Thank you.
>
> Fran.
I am a java programmer ,but i never touch lisp ,somebody tell me that
lisp is more simple and more stronger,i laught at him utill one
day i touch EMACS, i had understood I had make a mistake.I want to
learn Lisp immedately ,not only because EMACS, but also for my mistake.
On Oct 12, 8:41 pm, ········@gmail.com wrote:
> I'm constantly hearing that Lisp is the best computer language ever
> designed.
true.
I am particulary interested in knowing why it is better than
> Java.
Java is the worst language ever designed (from those generally used),
so anything slightly better is already better then Java.
:-)
> I'd like to read opinions from people using both IN THE REAL WORLD,
> day by day, in their work, not just in theory.
I would mention two key differences:
-- In Java you have to write much more code. And most of the time
it is rather stupid code which serves only for the environment,
not to solve the problem.
-- In Java you have to study a lot of spagetty classes and wast API,
as everything in Java is mady by means of objects and interfaces.
I like OO, but it is needed only when it is needed. E.g. higher order
functions in LISP are much better for simple things.