This article on Lisp appeared today on IBM's DeveloperWorks (link via
Richard Cook):
http://www-128.ibm.com/developerworks/java/library/j-cb02067.html
I suppose any publicity is good publicity, but the article is pretty
disappointing. It disregards the most important features of Lisp to
focus on exciting things like defining functions and using recursion.
Macros get two paragraphs and one bizarre code snippet:
>(defmacro times_two (x) (* 2 x))
TIMES_TWO
>(setf a 4)
4
>(times_two a)
8
This is a pretty poor use of a macro, but it's certainly interesting
that he was able to convince his Lisp implementation (GCL, according to
the article) to produce that output.
Bill Atkins
Bill Atkins <················@not-a-real-domain.com> writes:
> >(defmacro times_two (x) (* 2 x))
> TIMES_TWO
>
> >(setf a 4)
> 4
>
> >(times_two a)
> 8
>
> This is a pretty poor use of a macro, but it's certainly interesting
> that he was able to convince his Lisp implementation (GCL, according to
> the article) to produce that output.
You're right.
It pretty much only works by accident.
;)
Fortunately, lisp is an interpreted and not compiled language, or else
the macro example wouldn't work at all. On the other hand, the
multiplication of the resulting times_two code would be blazingly fast
at run time.
=;'O
--
Thomas A. Russ, USC/Information Sciences Institute
And yes, the last paragraph is meant tongue-in-cheek.
On Tue, 06 Feb 2007 13:43:09 -0800, Thomas A. Russ wrote:
>
> Fortunately, lisp is an interpreted and not compiled language, or else
Nope. Lisp is always compiled, because macros run at compile time.
--
My address happens to be com (dot) gmail (at) usenet (plus) chbarts,
wardsback and translated.
It's in my header if you need a spoiler.
----== Posted via Newsfeeds.Com - Unlimited-Unrestricted-Secure Usenet News==----
http://www.newsfeeds.com The #1 Newsgroup Service in the World! 120,000+ Newsgroups
----= East and West-Coast Server Farms - Total Privacy via Encryption =----
In article <······························@tznvy.pbz>,
Chris Barts <··············@tznvy.pbz> wrote:
> On Tue, 06 Feb 2007 13:43:09 -0800, Thomas A. Russ wrote:
>
> >
> > Fortunately, lisp is an interpreted and not compiled language, or else
>
> Nope. Lisp is always compiled, because macros run at compile time.
HINT: read the last line of Mr. Russ's post.
Bill Atkins wrote:
> This article on Lisp appeared today on IBM's DeveloperWorks (link via
> Richard Cook):
>
> http://www-128.ibm.com/developerworks/java/library/j-cb02067.html
>
> I suppose any publicity is good publicity, but the article is pretty
> disappointing. It disregards the most important features of Lisp to
> focus on exciting things like defining functions and using recursion.
Lessee, Bruce Tate, author of "Beyond Java", climbs onto an IBM Java
developers' site and in an article entitled "The Beauty of Lisp" says
"This 48-year-old language comes with incredible power and flexibility
that the Java language can't begin to match." and concludes "But if you
dig a little bit, you'll find an incredibly powerful language with
higher abstractions that are as valid and productive today as when they
were created 50 years ago. Many more-modern languages borrow from Lisp,
and most still do not provide as much power. If Lisp had a fraction of
the marketing behind Java or .NET and similar mindshare across
universities, we might well all be writing it right now."
And we deem this disappointing? Hmmm...
kenneth
--
Well, I've wrestled with reality for 35 years, Doctor, and
I'm happy to state I finally won out over it.
-- Elwood P. Dowd
In this world, you must be oh so smart or oh so pleasant.
-- Elwood's Mom
In article <···················@newsfe09.lga>,
Ken Tilton <·········@gmail.com> wrote:
> Lessee, Bruce Tate, author of "Beyond Java", climbs onto an IBM Java
> developers' site and in an article entitled "The Beauty of Lisp" says
> "This 48-year-old language comes with incredible power and flexibility
> that the Java language can't begin to match." and concludes "But if you
> dig a little bit, you'll find an incredibly powerful language with
> higher abstractions that are as valid and productive today as when they
> were created 50 years ago. Many more-modern languages borrow from Lisp,
> and most still do not provide as much power. If Lisp had a fraction of
> the marketing behind Java or .NET and similar mindshare across
> universities, we might well all be writing it right now."
>
> And we deem this disappointing? Hmmm...
You and Pascal are right. It's great that there's an article about Lisp
in such a high-profile place.
The reason I'm whining is that the content of the article doesn't back
up all the nice things in the introduction. We are _told_ that Lisp is
"incredibly powerful" and is "as valid and productive as when [it was]
created 50 years ago," but we are never given any reason to believe this.
Most programmers have already heard the stories about how Lisp (or
Smalltalk or whatever) was insanely productive in the past, miles above
anything else. Or they've heard that it's the language of choice at MIT
or heard it compared to programming "enlightenment." The author repeats
these notions, but doesn't convince the reader that Lisp is worth
looking into.
Instead, he reinforces what most programmers learn in college: Lisp is
just about lists and recursion, and there's not much more to it.
Pretend you are a Java programmer coming across this article; would it
intrigue you enough to spend some time learning Lisp, or would you
conclude that it was more or less as useless and academic as you'd
thought? Would you conclude that macros are a useful and totally unique
technique, or that they're overrated and can be straightforwardly
replaced with other techniques? In the recent c.l.p vs. c.l.l
showdown, all the Pythonistas wanted to do was convince Lispers that
macros aren't necessary. If TIMES_TWO is passed off as a reasonable
example of a macro, that doesn't help our case.
The problem isn't that people haven't heard enough praise for Lisp; the
problem is that people don't believe the praise is grounded in reality.
They don't believe that Lisp offers serious advantages over anything
else and/or they don't believe that it's relevant these days. I think a
couple of well-placed screenshots of a GUI inspector or class browser
would have done a good deal more for Lisp than what's currently there.
Maybe a DEFINE-BINARY-CLASS kind of macro, definitely something about
restarts. And everybody likes the generic sequence functions and
:BEFORE and :AFTER specifiers. I think it's more important that the
reader see what's possible (even without understanding what's going on
behind the scenes) than that he or she understand the basics of list
manipulation.
I guess it's a good first step, though. Anyway...back to looking on the
bright side of things.
Bill Atkins wrote:
> In article <···················@newsfe09.lga>,
> Ken Tilton <·········@gmail.com> wrote:
>
>
>>Lessee, Bruce Tate, author of "Beyond Java", climbs onto an IBM Java
>>developers' site and in an article entitled "The Beauty of Lisp" says
>>"This 48-year-old language comes with incredible power and flexibility
>>that the Java language can't begin to match." and concludes "But if you
>>dig a little bit, you'll find an incredibly powerful language with
>>higher abstractions that are as valid and productive today as when they
>>were created 50 years ago. Many more-modern languages borrow from Lisp,
>>and most still do not provide as much power. If Lisp had a fraction of
>>the marketing behind Java or .NET and similar mindshare across
>>universities, we might well all be writing it right now."
>>
>>And we deem this disappointing? Hmmm...
>
>
> You and Pascal are right. It's great that there's an article about Lisp
> in such a high-profile place.
>
> The reason I'm whining is that the content of the article doesn't back
> up all the nice things in the introduction. We are _told_ that Lisp is
> "incredibly powerful" and is "as valid and productive as when [it was]
> created 50 years ago," but we are never given any reason to believe this.
You think Tate was going to achieve in a short article what Graham did
not achieve with a book, Kent Pitman did not achieve with a big Slashdot
appearance, and what two huge flamewars with c.l.p involving several
intense Lispniks did not?
How many people are using Cells? 5? How long have I been shilling that?
It has 44 years of prior and concurrent art and two or three portable CL
GUIs and is an indisputably better paradigm and has about five users.
Lispniks really should not be puzzled about the illusion of rationality
in tool choice. In fact...
...the only thing that matters is Becoming the Latest Thing. What is the
latest thing? The (a) new thing (b) being recommended (c) by Famous
People (d) in respectable places. (hint) And when the "recommendation"
is so hyperbolic...
Look, all I am saying is that everyone hear is reacting to Tate's work
like we do to anyone masochistic enough to post code here, so I actually
find it pretty funny. We are so code-obsessed (in a great educational
way) that I seem to be the only one who saw a positive article on Lisp
in a mainstream location (and not an advertorial arranged by Franz).
kt
--
Well, I've wrestled with reality for 35 years, Doctor, and
I'm happy to state I finally won out over it.
-- Elwood P. Dowd
In this world, you must be oh so smart or oh so pleasant.
-- Elwood's Mom
On Wed, 07 Feb 2007 16:54:30 +0100, Ken Tilton <·········@gmail.com> wrote:
Or you could just listen to what people tell you.
Tough though it may seem.
They want:
1. documenation
2. complete reference
3. history
This has been said before and sucessfully ignored so I don't know why I
bother.
Using Opera's revolutionary e-mail client: http://www.opera.com/mail/
Ken Tilton wrote:
>
>
> Bill Atkins wrote:
>> This article on Lisp appeared today on IBM's DeveloperWorks (link via
>> Richard Cook):
>>
>> http://www-128.ibm.com/developerworks/java/library/j-cb02067.html
>>
>> I suppose any publicity is good publicity, but the article is pretty
>> disappointing. It disregards the most important features of Lisp to
>> focus on exciting things like defining functions and using recursion.
>
> Lessee, Bruce Tate, author of "Beyond Java", climbs onto an IBM Java
> developers' site and in an article entitled "The Beauty of Lisp" says
> "This 48-year-old language comes with incredible power and flexibility
> that the Java language can't begin to match." and concludes "But if you
> dig a little bit, you'll find an incredibly powerful language with
> higher abstractions that are as valid and productive today as when they
> were created 50 years ago. Many more-modern languages borrow from Lisp,
> and most still do not provide as much power. If Lisp had a fraction of
> the marketing behind Java or .NET and similar mindshare across
> universities, we might well all be writing it right now."
>
> And we deem this disappointing? Hmmm...
Kenny is right. It's a good sign that such articles get posted, and it's
a better idea to start from that point of view. (For example, you can
link to that article, but mention links to more current resources...)
Things are currently going in a pretty interesting direction. Now that
Steve Jobs, the boss of a major IT company, has stated that Java is not
interesting anymore, we can expect more players to jump on that
bandwagon. The fact that an article connected to IBM, another major IT
company, mentions (no wait, the whole article is about) Lisp is another
good sign. Things are moving...
Pascal
--
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 Feb 6, 11:09 pm, Pascal Costanza <····@p-cos.net> wrote:
> Things are currently going in a pretty interesting direction. Now that
> Steve Jobs, the boss of a major IT company, has stated that Java is not
> interesting anymore
Major IT company. Hmm...
Anyway, he said that a Java plug-in for a web browser on a cell phone
isn't needed, because Java for websites isn't that interesting
anymore. That's a /bit/ different from what you wrote above, isn't
it? Maybe you should work as a spin doctor for Dubya... :)
Cheers,
Edi.
·······@gmail.com writes:
> Anyway, he said that a Java plug-in for a web browser on a cell phone
> isn't needed, because Java for websites isn't that interesting
> anymore. That's a /bit/ different from what you wrote above, isn't
> it? Maybe you should work as a spin doctor for Dubya... :)
That Apple is losing interest in java, isn't just some speculation
based on the iPhone presentation. Have a look at developer.apple.com,
it's Objective-C all the way, and they've deprecated the Cocoa java
API.
--
(espen)
On Feb 7, 10:28 am, Espen Vestre <····@vestre.net> wrote:
> That Apple is losing interest in java, isn't just some speculation
> based on the iPhone presentation. Have a look at developer.apple.com,
> it's Objective-C all the way, and they've deprecated the Cocoa java
> API.
Yes, I've heard that as well. They also still say this:
"Apple has optimized Java on Mac OS X to look great and perform
superbly, making Mac OS X the ultimate platform for developing and
deploying cross-platform Java applications. Java has become the
de-facto standard language for developing cross-platform
applications. Recognizing this, Apple has made Java a core
component of Mac OS X. [...] Java applications act as first-class
citizens on Mac OS X."
<http://www.apple.com/macosx/features/java/>
Go figure...
My point is that it is wishful thinking to believe that the IT
industry (whoever that is) will soon lose interest in Java just
because Steve Jobs doesn't like it anymore - no matter how many iPods
and iPhones Apple sells.
Cheers,
Edi.
·······@gmail.com writes:
> My point is that it is wishful thinking to believe that the IT
> industry (whoever that is) will soon lose interest in Java just
> because Steve Jobs doesn't like it anymore - no matter how many iPods
> and iPhones Apple sells.
I don't think anyone here meant anything like that. Apple's fading
interest in java may be taken as an /indication/ of a broader trend.
--
(espen)
·······@gmail.com wrote:
> My point is that it is wishful thinking to believe that the IT
> industry (whoever that is) will soon lose interest in Java just
> because Steve Jobs doesn't like it anymore - no matter how many iPods
> and iPhones Apple sells.
And one reason why Lisp isn't as popular as Java is because it is difficult
to write platform independant programs with a GUI in Lisp and you have to
do some reasearch before you find the right library for e.g. network
connections, which is standard in Java and Python. There are some GUI
frameworks, like LTK and the lispbuilder libraries, but it is still
difficult to create one-click-installable applications with it. With Java
you just distribute a JAR file and that's all. On Windows some users have
to download Java, first, too start it, but it has a simple installer and on
some computers it is pre-installed, like on some Dell and Lenovo computers.
Maybe a good idea would be something like a platform and Lisp
implementation independant byte code layer for Lisp. On top of this
something like application archives could be defined, like the Java JAR
files. Different Lisp implementations could still provide different
high-level features or different byte code JIT compilers, but once you have
a byte code file, it runs on every system and Lisp implementation.
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
Frank Buss wrote:
> ·······@gmail.com wrote:
>
>> My point is that it is wishful thinking to believe that the IT
>> industry (whoever that is) will soon lose interest in Java just
>> because Steve Jobs doesn't like it anymore - no matter how many iPods
>> and iPhones Apple sells.
>
> And one reason why Lisp isn't as popular as Java is because it is difficult
> to write platform independant programs with a GUI in Lisp and you have to
> do some reasearch before you find the right library for e.g. network
> connections, which is standard in Java and Python. There are some GUI
> frameworks, like LTK and the lispbuilder libraries, but it is still
> difficult to create one-click-installable applications with it. With Java
> you just distribute a JAR file and that's all. On Windows some users have
> to download Java, first, too start it, but it has a simple installer and on
> some computers it is pre-installed, like on some Dell and Lenovo computers.
Not quite. See for example
http://www.artima.com/weblogs/viewpost.jsp?thread=193593 - especially
the section about "The Installation Problem" (and this is from a guy who
actually likes Java).
(One problem with users of non-mainstream languages is that they seem to
believe that many infrastructure issues are greener on the other side,
while that is actually not the case.)
> Maybe a good idea would be something like a platform and Lisp
> implementation independant byte code layer for Lisp. On top of this
> something like application archives could be defined, like the Java JAR
> files. Different Lisp implementations could still provide different
> high-level features or different byte code JIT compilers, but once you have
> a byte code file, it runs on every system and Lisp implementation.
Bytecodes are a very bad distribution format. See for example
http://www.ics.uci.edu/~franz/Site/pubs-pdf/C05.pdf for some reasons. It
is indeed the case that the JVM has to reconstruct information from
bytecodes that would be easy to obtain from an AST in order to perform
optimizations.
Based on this observation, the best distribution format for Lisp code is
minimally compiled Lisp as defined in
http://www.lispworks.com/documentation/HyperSpec/Body/03_bbb.htm - or
maybe even just plain source code...
Pascal
--
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
Pascal Costanza wrote:
> Not quite. See for example
> http://www.artima.com/weblogs/viewpost.jsp?thread=193593 - especially
> the section about "The Installation Problem" (and this is from a guy who
> actually likes Java).
ok, then substitute "Java" with "Flash", like the author did :-) With the
Flash authoring tool it is just a one-click to produce Executables for
Windows and Mac (both executable formats can be produced on both authoring
programs for Mac and Windows), so you even don't need to install anything.
> Bytecodes are a very bad distribution format. See for example
> http://www.ics.uci.edu/~franz/Site/pubs-pdf/C05.pdf for some reasons. It
> is indeed the case that the JVM has to reconstruct information from
> bytecodes that would be easy to obtain from an AST in order to perform
> optimizations.
The article says, that is is extraordinarily difficult to reconstruct Java
source from Java byte code. But I have used decompilers, which reconstruct
the Java source nearly like the original source code, only private variable
names and methods are substituted with index based names, if the source was
compiled without debug information. So nearly no information is lost and a
good optimizer could work as good as if the source code would be available.
But the idea of slim binaries sounds interesting, because then it might be
easier to do optimizations.
> Based on this observation, the best distribution format for Lisp code is
> minimally compiled Lisp as defined in
> http://www.lispworks.com/documentation/HyperSpec/Body/03_bbb.htm - or
> maybe even just plain source code...
Maybe you are right, but another intention for me to use byte code is to
minimize ambigious code, like different sizes of fixnum and float,
different FFI interfaces etc., by defining a platform independant virtual
machine, which gurantees that the same sequence of byte code produces
always the same result.
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
Frank Buss wrote:
> Pascal Costanza wrote:
>
>> Not quite. See for example
>> http://www.artima.com/weblogs/viewpost.jsp?thread=193593 - especially
>> the section about "The Installation Problem" (and this is from a guy who
>> actually likes Java).
>
> ok, then substitute "Java" with "Flash", like the author did :-) With the
> Flash authoring tool it is just a one-click to produce Executables for
> Windows and Mac (both executable formats can be produced on both authoring
> programs for Mac and Windows), so you even don't need to install anything.
...just wait until Flash has diverged as well. ;-)
>> Bytecodes are a very bad distribution format. See for example
>> http://www.ics.uci.edu/~franz/Site/pubs-pdf/C05.pdf for some reasons. It
>> is indeed the case that the JVM has to reconstruct information from
>> bytecodes that would be easy to obtain from an AST in order to perform
>> optimizations.
>
> The article says, that is is extraordinarily difficult to reconstruct Java
> source from Java byte code. But I have used decompilers, which reconstruct
> the Java source nearly like the original source code, only private variable
> names and methods are substituted with index based names, if the source was
> compiled without debug information. So nearly no information is lost and a
> good optimizer could work as good as if the source code would be available.
Of course, it's not impossible to do this. However, the stress is on the
overhead in having to do this. When you want to build a platform that is
supposed to enable just-in-time compilation or dynamic compilation to
achieve performance optimization, it's not a particularly bright idea to
base it on technology that actually costs performance.
> But the idea of slim binaries sounds interesting, because then it might be
> easier to do optimizations.
Right, that's the point.
>> Based on this observation, the best distribution format for Lisp code is
>> minimally compiled Lisp as defined in
>> http://www.lispworks.com/documentation/HyperSpec/Body/03_bbb.htm - or
>> maybe even just plain source code...
>
> Maybe you are right, but another intention for me to use byte code is to
> minimize ambigious code, like different sizes of fixnum and float,
> different FFI interfaces etc., by defining a platform independant virtual
> machine, which gurantees that the same sequence of byte code produces
> always the same result.
Yes, but that's on orthogonal issue.
Pascal
--
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 Wed, 07 Feb 2007 15:24:11 +0100, Frank Buss <··@frank-buss.de> wrote:
Lispworks can produce fat binaries on Mac..
They run on PowerPC and on Intel architecture.
Is that what you mean?
--
Using Opera's revolutionary e-mail client: http://www.opera.com/mail/
John Thingstad wrote:
> Lispworks can produce fat binaries on Mac..
> They run on PowerPC and on Intel architecture.
> Is that what you mean?
Yes, that's nice and together with CAPI good for professional usage, that's
the reason I have bought it. But nowadays many competing development
environments are for free, which is important for many hobby projects.
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
On Wed, 07 Feb 2007 16:28:31 +0100, Frank Buss <··@frank-buss.de> wrote:
> John Thingstad wrote:
>
>> Lispworks can produce fat binaries on Mac..
>> They run on PowerPC and on Intel architecture.
>> Is that what you mean?
>
> Yes, that's nice and together with CAPI good for professional usage,
> that's
> the reason I have bought it. But nowadays many competing development
> environments are for free, which is important for many hobby projects.
>
Well I think you know the answer to that!
SBCL
--
Using Opera's revolutionary e-mail client: http://www.opera.com/mail/
On 8 Feb, 12:53, "John Thingstad" <··············@chello.no> wrote:
> On Wed, 07 Feb 2007 16:28:31 +0100, Frank Buss <····@frank-buss.de> wrote:
> > the reason I have bought it. But nowadays many competing development
> > environments are for free, which is important for many hobby projects.
>
> Well I think you know the answer to that!
> SBCL
I'd second that.
I've downloaded some fully-compiled-and-bundled-with-SBCL
applications, unzipped them on Ubuntu and they've ran first time
(mainly stuff mentioned on Planet Lisp).
The only downside is the size of the executables produced by SBCL
which might be a problem for end users (although the size is roughly
on a par with a download of the JVM so in some ways it's easier for
them as they only need to go to one place to get your program). Just a
thought...
Phil
Pascal Costanza <··@p-cos.net> writes:
> Frank Buss wrote:
>> ·······@gmail.com wrote:
>>
>>> My point is that it is wishful thinking to believe that the IT
>>> industry (whoever that is) will soon lose interest in Java just
>>> because Steve Jobs doesn't like it anymore - no matter how many iPods
>>> and iPhones Apple sells.
>>
>> And one reason why Lisp isn't as popular as Java is because it is difficult
>> to write platform independant programs with a GUI in Lisp and you have to
>> do some reasearch before you find the right library for e.g. network
>> connections, which is standard in Java and Python. There are some GUI
>> frameworks, like LTK and the lispbuilder libraries, but it is still
>> difficult to create one-click-installable applications with it. With Java
>> you just distribute a JAR file and that's all. On Windows some users have
>> to download Java, first, too start it, but it has a simple installer and on
>> some computers it is pre-installed, like on some Dell and Lenovo computers.
>
> Not quite. See for example
> http://www.artima.com/weblogs/viewpost.jsp?thread=193593 - especially the
> section about "The Installation Problem" (and this is from a guy who actually
> likes Java).
>
> (One problem with users of non-mainstream languages is that they seem to
> believe that many infrastructure issues are greener on the other side, while
> that is actually not the case.)
>
>> Maybe a good idea would be something like a platform and Lisp
>> implementation independant byte code layer for Lisp. On top of this
>> something like application archives could be defined, like the Java JAR
>> files. Different Lisp implementations could still provide different
>> high-level features or different byte code JIT compilers, but once you have
>> a byte code file, it runs on every system and Lisp implementation.
>
> Bytecodes are a very bad distribution format. See for example
> http://www.ics.uci.edu/~franz/Site/pubs-pdf/C05.pdf for some reasons. It is
> indeed the case that the JVM has to reconstruct information from bytecodes that
> would be easy to obtain from an AST in order to perform optimizations.
>
> Based on this observation, the best distribution format for Lisp code is
> minimally compiled Lisp as defined in
> http://www.lispworks.com/documentation/HyperSpec/Body/03_bbb.htm - or maybe
> even just plain source code...
>
to some extent, I suspect one significant reason we (the lisp user community)
has problems getting increased acceptance/support from the IT community is
because we have too many smart users with strong theoretical grounding. It
often seems that every suggestion for improvement ends up in a thread debating
every small issue and ends up going nowhere. this is not a negative criticism
and debate is important. Most of the time, the issues raised are valid and need
to be considered. However, it does seem that the result is extremely
slow progress. I sometimes wonder if we do get caught up in the small (but
important) details and miss the big picture and whether we would be better off
adopting a more pragmatic "full speed ahead and damn the torpedoes" attitude
and what that would cost in the long run.
It is possible part of the problem here is that lisp is so powerful and one of
the few languages which is able to adapt to the complexities of the real world
with such ease and elegance. Often it seems that change will either lose some
of this power or elegance or, as a result of having such a powerful
combination, there are just too many alternatives to get community consensus.
Maybe its simply we don't have a benevolent dictator that is able to monitor
debate and when they feel there has been enough make a decision which is
accepted as final (noting of course that I'd be pretty upset if some aspect of
the language I loved was changed because some dictator made a decision to do
so).
While I'd love to be using lisp at work, I'm skeptical we will ever see it as
one of the maintstream development platforms. However, i have a similar
attitude to this as to the development of GNU linux as a mainstream operating
system. While I like both a lot and think they should have wider acceptance
than they do, I don't really care if they don't. I'm pleased I have lisp to
code with and I'm pleased I have GNU Linux, but if the rest of the world cannot
see the advantages, well, thats their loss and I'd rather keep things as they
are than sacrifice power, elegance or reliability simply to see increased
popularity. I'd rather not have a portable networking library if its not as
good as one I can write myself, I'd rather distribute source code if machine
independent byte code made things as clunky, slow or ugly as java and I'd
rather have a world with a lot of different lisp dialects than one unified, but
crippled or restricted "standard" and accepted version.
another point is that the real acid test is success. GNU Linux has been quite
successful in the server environment because it provides a reliable OS on
commodity hardware that avoids many of the issues with Windows and isn't as
expensive as *nixes like Solaris. GNU Linux has not been as successful on the
desktop because, from the average end-user perspective, its not as easy to use
or allow simple easy access to common requirements, such as accessing different
multimedia content or collaborate with the majority of users using Office etc.
Likewise, while there are a few success stories based on lisp, these seem very
insignificant when compared to the number of success stories for other
languages. If the rest of the industry is to be convinced regarding the
superiority of lisp, then someone had better come up with the goods. However,
there is a significant problem here. Software has become large, complex and
feature rich. The day of the single developer creating a multi-million dollar
success story coding a killer app are pretty much gone. These days, you need
significant venture capital and a bloody good original idea (and a team of good
developers). However, venture capitalists are conservative by nature and
obtaining significant investment for something written in lisp is a lot harder
than attempting the same with a trendier language with recent success stories.
I even heard that many venture capitalists these days won't consider your
proposal unless you also plan to out source the development to India/Chaina -
apparently the reasoning goes that most start-ups fail and as its half the cost
to do development in India, this means it will fail for half the cost. Rather
simplistic and misleading analysis in my view, but my opinion is irrelevant
since I'm not a venture capitalist. There is also the problem that business
really doesn't care how elegant, efficient or even extensible your application
and evelopment platform are. All business cares about is that the application
solves the problem and does it today - it doesn't matter if its slow, requires
more processing power, storage or maintenance, it just needs to solve the
problem. Its efficiency, elegance or probable usable life is irrelevant udner
todays management paradigm - just as long as its here today and words to
address the problem now is all that matters. Like other aspects of modern
society, form is often sacrificed for function - look at all the ugly houses
built today. Even if you wanted to build one that is both functional and
attractive, your going to have a hard time because you can't get the raw
materials or the skilled trades people to build it unless your willing to put
in significantly higher investment. Even when you do, your likely to run into
local government planning restrictions or zoneing problems - for IT, replace
planning/zoneing with patent and copyright!
Tim
--
tcross (at) rapttech dot com dot au
I had a good conversation yesterday with a commercial Lisp developer.
His company was using a mix of Lisp and Java -- they weren't willing
to do without the Java. Unfortunately they had to get Lisp and Java
to speak to each other, and the only solution they could find was
CORBA, which wasn't fitting their needs at all. (They were committed
to a commercial Lisp instead of doing the obvious thing and running
ABCL, because the commercial Lisp had binary-only libraries they
needed.) As a result, they switched to all Java.
I've heard this echoed in other software houses -- it's considered
difficult to get Lisps to talk to other processes and interoperate
with languages other than straight C. I don't know whether this is a
valid assessment, but it's a big concern, because software companies
have a strong incentive to stick with known working solutions and
extend them incrementally.
mfh
············@gmail.com wrote:
> I had a good conversation yesterday with a commercial Lisp developer.
No, you had a bad conversation. See below.
> His company was using a mix of Lisp and Java -- they weren't willing
> to do without the Java. Unfortunately they had to get Lisp and Java
> to speak to each other, and the only solution they could find was
> CORBA, which wasn't fitting their needs at all.
Not ACL, then, I guess; that has a JFLI.
> (They were committed
> to a commercial Lisp instead of doing the obvious thing and running
> ABCL, because the commercial Lisp had binary-only libraries they
> needed.) As a result, they switched to all Java.
>
> I've heard this echoed in other software houses -- it's considered
> difficult to get Lisps to talk to other processes and interoperate
> with languages other than straight C. I don't know whether this is a
> valid assessment, but it's a big concern, because software companies
> have a strong incentive to stick with known working solutions and
> extend them incrementally.
Risk-averse companies with the resources to squander on glacial Java
development will be the last to abandon Java, perhaps too late as the
one or three crazy little companies with nothing to lose first survive
and then dominate with more agile technology (hmm, I guess it depends on
how one defines risk) so... your report was a boring take-away. A good
conversation would have found out why on earth they even /tried/ to use
a dead language like Lisp. How did that happen? A lone Lisp champion?
This alone could be yet another sign of Lisp's ascendance. So... get
back in there, man!
ken
--
Well, I've wrestled with reality for 35 years, Doctor, and
I'm happy to state I finally won out over it.
-- Elwood P. Dowd
In this world, you must be oh so smart or oh so pleasant.
-- Elwood's Mom
On Feb 11, 10:08 am, Ken Tilton <·········@gmail.com> wrote:
> Risk-averse companies with the resources to squander on glacial Java
> development will be the last to abandon Java, perhaps too late as the
> one or three crazy little companies with nothing to lose first survive
> and then dominate with more agile technology (hmm, I guess it depends on
> how one defines risk) so... your report was a boring take-away. A good
> conversation would have found out why on earth they even /tried/ to use
> a dead language like Lisp. How did that happen? A lone Lisp champion?
> This alone could be yet another sign of Lisp's ascendance. So... get
> back in there, man!
Hi Ken!!! ;P
Yeah, I would have fought with him a little more but he wasn't
expressing his own opinion, just that of his company. Besides, he's
leaving it anyway to go back to grad school and do really cool stuff
(in which I presume he, as an experienced Lisper, will take advantage
of that skill and avoid using the abomination that is Java as much as
possible ;P ).
Y'all gotta start pushin' parallel Lisp now, I'm serious, Intel's
already taped out an 80-core chip that they predict will be in
consumers' hands in five years:
http://www.businessweek.com/technology/content/feb2007/tc20070211_730122.htm?chan=technology_technology+index+page_more+of+today's+top+stories
See e.g. the following thread:
http://groups.google.com/group/comp.lang.lisp/browse_thread/thread/fefb6741bd0bcdbc?hl=en
happy n00b-thrashing ;P
mfh
On Feb 11, 11:01 am, ·············@gmail.com" <············@gmail.com>
wrote:
> I had a good conversation yesterday with a commercial Lisp developer.
> His company was using a mix of Lisp and Java -- they weren't willing
> to do without the Java. Unfortunately they had to get Lisp and Java
> to speak to each other, and the only solution they could find was
> CORBA, which wasn't fitting their needs at all. (They were committed
> to a commercial Lisp instead of doing the obvious thing and running
> ABCL, because the commercial Lisp had binary-only libraries they
> needed.) As a result, they switched to all Java.
>
> I've heard this echoed in other software houses -- it's considered
> difficult to get Lisps to talk to other processes and interoperate
> with languages other than straight C. I don't know whether this is a
> valid assessment, but it's a big concern, because software companies
> have a strong incentive to stick with known working solutions and
> extend them incrementally.
>
> mfh
This is exactly what happened at our company. We also had a Java/Lisp
mix. We tried using CORBA, JFLI. etc... but it just didn't work
either for performance and/or unicode issues. We were only able to
use LispWorks because the ACL licensing was unacceptable to upper
level management and SBCL was not cross platform friendly in any
stable way at the time.
The reason we chose Lisp to begin with was because I championed it.
And it did not dissappoint. Development in Lisp proved to be easy,
fun, and powerful. Unfortunately, we only had three Lisp
knowledgeable developers out of about seventeen (otherwise I would
have proposed doing the whole project in Lisp).
So, I don't see this as a failure for Lisp. The current commercial
development community is not equipped to handle a language like Lisp
that does not have the community support and resources that Java
et.al. enjoy.
If Sun were to come out tomorrow with a commercial common lisp
environment, and they put resources behind it and pushed it like they
did Java, I have no doubt that Lisp would take off and become a
mainstream language.
-- DS
I must say that we also have a mix of commercial Lisp and Java; Java
on the "front end", both on the server-side. Heavy communication
between the two is a must, and our environment is soft real-time. We
made it work because we wanted *both* platforms. Lisp is essential for
the success of our app, and Java is desired for much of the framework.
It's an engineering problem, and we found a solution that works for
us. I'm not at liberty to say what that solution is; my point is that
Lisp and Java can play nicely together.
We're using Lispworks 5.0, by the way.
-- david
David E. Young wrote:
> I must say that we also have a mix of commercial Lisp and Java; Java
> on the "front end", both on the server-side. Heavy communication
> between the two is a must, and our environment is soft real-time. We
> made it work because we wanted *both* platforms. Lisp is essential for
> the success of our app, and Java is desired for much of the framework.
> It's an engineering problem, and we found a solution that works for
> us.
Right. Whenever someone talks about what prevented them from using Lisp,
I just hear "We did not really care if we used Lisp, so we punted on
second and seven."
kxo
--
Well, I've wrestled with reality for 35 years, Doctor, and
I'm happy to state I finally won out over it.
-- Elwood P. Dowd
In this world, you must be oh so smart or oh so pleasant.
-- Elwood's Mom
DS wrote:
> On Feb 11, 11:01 am, ·············@gmail.com" <············@gmail.com>
> wrote:
>
>>I had a good conversation yesterday with a commercial Lisp developer.
>>His company was using a mix of Lisp and Java -- they weren't willing
>>to do without the Java. Unfortunately they had to get Lisp and Java
>>to speak to each other, and the only solution they could find was
>>CORBA, which wasn't fitting their needs at all. (They were committed
>>to a commercial Lisp instead of doing the obvious thing and running
>>ABCL, because the commercial Lisp had binary-only libraries they
>>needed.) As a result, they switched to all Java.
>>
>>I've heard this echoed in other software houses -- it's considered
>>difficult to get Lisps to talk to other processes and interoperate
>>with languages other than straight C. I don't know whether this is a
>>valid assessment, but it's a big concern, because software companies
>>have a strong incentive to stick with known working solutions and
>>extend them incrementally.
>>
>>mfh
>
>
> This is exactly what happened at our company. We also had a Java/Lisp
> mix. We tried using CORBA, JFLI. etc... but it just didn't work
> either for performance and/or unicode issues. We were only able to
> use LispWorks because the ACL licensing was unacceptable to upper
> level management and SBCL was not cross platform friendly in any
> stable way at the time.
>
> The reason we chose Lisp to begin with was because I championed it.
> And it did not dissappoint. Development in Lisp proved to be easy,
> fun, and powerful. Unfortunately, we only had three Lisp
> knowledgeable developers out of about seventeen (otherwise I would
> have proposed doing the whole project in Lisp).
>
> So, I don't see this as a failure for Lisp. The current commercial
> development community is not equipped to handle a language like Lisp
> that does not have the community support and resources that Java
> et.al. enjoy.
>
> If Sun were to come out tomorrow with a commercial common lisp
> environment, and they put resources behind it and pushed it like they
> did Java, I have no doubt that Lisp would take off and become a
> mainstream language.
Like this?
http://www-128.ibm.com/developerworks/java/library/j-pg09205/
:)
kzo
--
Well, I've wrestled with reality for 35 years, Doctor, and
I'm happy to state I finally won out over it.
-- Elwood P. Dowd
In this world, you must be oh so smart or oh so pleasant.
-- Elwood's Mom
Am 12.02.2007 17:12 Uhr schrieb "DS" unter <······@riverglassinc.com> in
························@a34g2000cwb.googlegroups.com:
> On Feb 11, 11:01 am, ·············@gmail.com" <············@gmail.com>
> wrote:
>> I had a good conversation yesterday with a commercial Lisp developer.
>> His company was using a mix of Lisp and Java -- they weren't willing
>> to do without the Java. Unfortunately they had to get Lisp and Java
>> to speak to each other, and the only solution they could find was
>> CORBA, which wasn't fitting their needs at all. (They were committed
>> to a commercial Lisp instead of doing the obvious thing and running
>> ABCL, because the commercial Lisp had binary-only libraries they
>> needed.) As a result, they switched to all Java.
>>
>> I've heard this echoed in other software houses -- it's considered
>> difficult to get Lisps to talk to other processes and interoperate
>> with languages other than straight C. I don't know whether this is a
>> valid assessment, but it's a big concern, because software companies
>> have a strong incentive to stick with known working solutions and
>> extend them incrementally.
>>
>> mfh
>
> This is exactly what happened at our company. We also had a Java/Lisp
> mix. We tried using CORBA, JFLI. etc... but it just didn't work
> either for performance and/or unicode issues. We were only able to
> use LispWorks because the ACL licensing was unacceptable to upper
> level management and SBCL was not cross platform friendly in any
> stable way at the time.
Usually COMMERCIAL vendors can improve their products if there is demand for
these improvements and customers are willing to pay for it. If companies are
interested in improvements to LispWorks, there better invest some money for
that. Plus there also needs to be technical expertise on the vendor side.
>
> The reason we chose Lisp to begin with was because I championed it.
> And it did not dissappoint. Development in Lisp proved to be easy,
> fun, and powerful. Unfortunately, we only had three Lisp
> knowledgeable developers out of about seventeen (otherwise I would
> have proposed doing the whole project in Lisp).
Then I would just develop the whole thing in Java. Mixed language
development just brings in additional problems.
> So, I don't see this as a failure for Lisp. The current commercial
> development community is not equipped to handle a language like Lisp
> that does not have the community support and resources that Java
> et.al. enjoy.
Again. Use Java.
> If Sun were to come out tomorrow with a commercial common lisp
> environment, and they put resources behind it and pushed it like they
> did Java, I have no doubt that Lisp would take off and become a
> mainstream language.
I doubt that.
Plus, SUN will never come out with a commercial Lisp again.
You can wait for that like for rain in the desert. Waiting for the big
sponsor is useless. Lisp had that and then the AI winter came.
SUN at that time was selling SLE (Symbolic Language Environment) - a Common
Lisp IDE based on Lucid's Common Lisp implementation. It was also the time
when Norvig was working for SUN. That's long gone.
The best way to move forward is to invest in removing the technical
obstacles one by one and making the solutions available to others. But you
won't see that with Lisp that often anymore on the commercial side. Take the
biggest commercial users of Lisp right now, say, ITA. What kind of support
for the Lisp community is coming from them? Maybe I'm wrong, but I don't see
much. Unless these customers invest in Lisp not only for themselves, the
whole community (for me the whole Common Lisp community includes commercial
vendors and users of commercial Lisp systems, just as it includes the free
software side) will not move forward. During the AI boom, government
(research labs, military, ...) invested and there was lots of benefits from
that. Government does not invest much nowadays and commercial companies
(users of Lisp) currently don't invest much either - the latter mostly take.
Atleast that is my impression. Though, there are some exceptions to that.
My 0.02 Euros.
Rainer Joswig
>
> -- DS
>
>
>
On Feb 12, 9:52 am, Rainer Joswig <······@lisp.de> wrote:
> Then I would just develop the whole thing in Java. Mixed language
> development just brings in additional problems.
I would say that mixed language development is the natural way to
solve problems: pick the language that suits the task. Of course it
helps if they can talk to each other, but I consider the benefit of
using the language appropriate to the task to outweigh by far the cost
of engineering inter-language communication.
For example, our research group does low-level HPC codes in C or UPC,
but uses higher-level embedded languages to encode transformations on
data structures, and scripting languages to generate C code for ATLAS-
style tuning or to script benchmark jobs on clusters. 10% performance
gains save our "clients" a lot of money and time so we have to do do
the low-level stuff in C (come on CL developers, get me access to SIMD
and prefetch instructions! port to AIX and Itanium and Cray! ;P ), but
C is totally unsuited for complex data structures or scripting. So we
develop in several languages and deal with it just fine.
We get good traction out of plugging ECL (Juanjo rocks!) or a Lua
interpreter into our C code.
mfh
Am 13.02.2007 19:22 Uhr schrieb ·············@gmail.com" unter
<············@gmail.com> in
·······················@v45g2000cwv.googlegroups.com:
> On Feb 12, 9:52 am, Rainer Joswig <······@lisp.de> wrote:
>> Then I would just develop the whole thing in Java. Mixed language
>> development just brings in additional problems.
>
> I would say that mixed language development is the natural way to
> solve problems: pick the language that suits the task. Of course it
> helps if they can talk to each other, but I consider the benefit of
> using the language appropriate to the task to outweigh by far the cost
> of engineering inter-language communication.
>
I doubt that. Most inter-language communication is added fat.
Embedded languages are a bit different.
An embedded language simplifies integration quite a bit and has been used
very successful. That's also the Lisp approach. Often one embeds/extends
some language via C. The same in Lisp. Multiple embedded languages are not
unusual. Common Lisp even comes with a few embedded languages by default:
FORMAT, CLOS, LOOP. You can argue that Common Lisp also embeds a subset of
MacLisp. ;-)
But tightly connecting two different high-level runtimes (say,
Java and Lisp) is something I'd usually avoid unless there is some real
benefit to it (say, an existing large amount of working code).
> For example, our research group does low-level HPC codes in C or UPC,
> but uses higher-level embedded languages to encode transformations on
> data structures, and scripting languages to generate C code for ATLAS-
> style tuning or to script benchmark jobs on clusters. 10% performance
> gains save our "clients" a lot of money and time so we have to do do
> the low-level stuff in C (come on CL developers, get me access to SIMD
> and prefetch instructions! port to AIX and Itanium and Cray! ;P ), but
> C is totally unsuited for complex data structures or scripting. So we
> develop in several languages and deal with it just fine.
>
> We get good traction out of plugging ECL (Juanjo rocks!) or a Lua
> interpreter into our C code.
>
> mfh
>
[ Sorry if this appears as a duplicate. My normal news server seems to
have stopped propagating articles. ]
On Feb 12, 7:52 pm, Rainer Joswig <······@lisp.de> wrote:
>Take the
> biggest commercial users of Lisp right now, say,ITA. What kind of support
> for the Lisp community is coming from them? Maybe I'm wrong, but I don't see
> much.
ITA has for example funded work on a significant amount of publically
released improvements to SBCL.
--
Juho Snellman
Tim X wrote:
> Pascal Costanza <··@p-cos.net> writes:
>
>> Bytecodes are a very bad distribution format. See for example
>> http://www.ics.uci.edu/~franz/Site/pubs-pdf/C05.pdf for some reasons. It is
>> indeed the case that the JVM has to reconstruct information from bytecodes that
>> would be easy to obtain from an AST in order to perform optimizations.
>>
>> Based on this observation, the best distribution format for Lisp code is
>> minimally compiled Lisp as defined in
>> http://www.lispworks.com/documentation/HyperSpec/Body/03_bbb.htm - or maybe
>> even just plain source code...
>
> to some extent, I suspect one significant reason we (the lisp user community)
> has problems getting increased acceptance/support from the IT community is
> because we have too many smart users with strong theoretical grounding. It
> often seems that every suggestion for improvement ends up in a thread debating
> every small issue and ends up going nowhere. this is not a negative criticism
> and debate is important. Most of the time, the issues raised are valid and need
> to be considered. However, it does seem that the result is extremely
> slow progress. I sometimes wonder if we do get caught up in the small (but
> important) details and miss the big picture and whether we would be better off
> adopting a more pragmatic "full speed ahead and damn the torpedoes" attitude
> and what that would cost in the long run.
It's interesting that you make this remark at this stage of the
discussion. Defining a bytecode format for distribution of (compiled)
Lisp code would require a major effort, while the concept of minimal
compilation is already well-defined for Common Lisp, and distribution of
source code actually requires no effort at all. (The infrastructure for
that is mostly already in place.)
In other words: Moving to a bytecode format would not only mean no
progress, it would actually be a regress _and_ consume time and money.
> It is possible part of the problem here is that lisp is so powerful and one of
> the few languages which is able to adapt to the complexities of the real world
> with such ease and elegance. Often it seems that change will either lose some
> of this power or elegance or, as a result of having such a powerful
> combination, there are just too many alternatives to get community consensus.
> Maybe its simply we don't have a benevolent dictator that is able to monitor
> debate and when they feel there has been enough make a decision which is
> accepted as final (noting of course that I'd be pretty upset if some aspect of
> the language I loved was changed because some dictator made a decision to do
> so).
The nice thing about Lisp is that we can have many benevolent dictators.
Actually, one can just take the concepts of Lisp that one likes, and
since they should be set in stone, right?, invent an arbitrary fixed
syntax for those. Ah, wait, that has already happened quite a few
times... ;)
> another point is that the real acid test is success. GNU Linux has been quite
> successful in the server environment because it provides a reliable OS on
> commodity hardware that avoids many of the issues with Windows and isn't as
> expensive as *nixes like Solaris. GNU Linux has not been as successful on the
> desktop because, from the average end-user perspective, its not as easy to use
> or allow simple easy access to common requirements, such as accessing different
> multimedia content or collaborate with the majority of users using Office etc.
> Likewise, while there are a few success stories based on lisp, these seem very
> insignificant when compared to the number of success stories for other
> languages. If the rest of the industry is to be convinced regarding the
> superiority of lisp, then someone had better come up with the goods.
I think this is impossible. Lisp is a general-purpose approach
(remember, it's a family of languages, not _a_ language). It's as
general as you can get. If you want to show that a language is
specifically good at a task that end-users actually care about, you have
to turn it into a domain-specific one, or at least restrict it in such a
way that the killer application is especially easy to implement while
other applications are comparatively harder to write.
I can imagine killer applications, though, that show the advantage of
certain Lisp libraries. Since Lisp enables extension with language
constructs through macros and metaprogramming, you can actually provide
the domain-specific language that makes implementing such specific
killer applications especially easy.
The limiting factor here is not the language or the infrastructure, but
only your imagination. That's the same for any programming language /
killer application combination for that matter.
Pascal
--
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 Feb 11, 9:19 am, Tim X <····@nospam.dev.null> wrote:
> to some extent, I suspect one significant reason we (the lisp user community)
> has problems getting increased acceptance/support from the IT community is
> because we have too many smart users with strong theoretical grounding.
Personally, I do not call smart one able to understand most advanced
theoretical framework but one is able to use the correct framework for
specific problems.
> I sometimes wonder if we do get caught up in the small (but
> important) details and miss the big picture and whether we would be better off
> adopting a more pragmatic "full speed ahead and damn the torpedoes" attitude
> and what that would cost in the long run.
A physicist using quantum gravity for falling apples would be
considered a bad physicist. Classical newtonian theory _is_ enough
there. It is not pragmatism, it is science. Same may be applied to
LISP community to TeX or to any other community claiming smartness...
> It is possible part of the problem here is that lisp is so powerful and one of
> the few languages which is able to adapt to the complexities of the real world
> with such ease and elegance.
Are not both relative concepts?
> While I'd love to be using lisp at work, I'm skeptical we will ever see it as
> one of the maintstream development platforms. However, i have a similar
> attitude to this as to the development of GNU linux as a mainstream operating
> system. While I like both a lot and think they should have wider acceptance
> than they do, I don't really care if they don't. I'm pleased I have lisp to
> code with and I'm pleased I have GNU Linux, but if the rest of the world cannot
> see the advantages, well, thats their loss and I'd rather keep things as they
> are than sacrifice power, elegance or reliability simply to see increased
> popularity.
This is the traditional but flawed attitude towards LISP. Advantages
are relative also. I know scientists using Linux when they need some
Linux advantage and using Windows when needing some Windows advantage
and using Mac also. Why do you believe that professor X has three
machines, one with XP, other with some Linux and a third one with a
SGI SO? If Linux were the only one needed, then he would forgot other
machines (specially the very expensive SGI WS).
> If the rest of the industry is to be convinced regarding the
> superiority of lisp, then someone had better come up with the goods.
As remarked, there is not such one "superiority" in absolute terms.
> All business cares about is that the application
> solves the problem and does it today - it doesn't matter if its slow, requires
> more processing power, storage or maintenance, it just needs to solve the
> problem. Its efficiency, elegance or probable usable life is irrelevant udner
> todays management paradigm - just as long as its here today and words to
> address the problem now is all that matters.
Again you focuse on relative points. Maybe you call elegant is to be
considered an ugly solution from other perspective. How many times i
heard that LISP recursive posibilities to computing factorials are
elegant? How many times i said, from my perspective, it is a very ugly
solution?
> Like other aspects of modern
> society, form is often sacrificed for function - look at all the ugly houses
> built today.
And why would be not form sacrified? Because you consider so?
I can live with people thinking form is more important. I can live
with people thinking function is more important. I can also live with
people thinking both are important. That I find rather disturbing is
the tendency of some subset of LISP community to force others to
accept their own views as the only one acceptable views. Maybe you
call "ugly houses" are beatiful for others. Are you asked?
"Juan R." <··············@canonicalscience.com> writes:
> A physicist using quantum gravity for falling apples would be
> considered a bad physicist. Classical newtonian theory _is_ enough
> there. It is not pragmatism, it is science. Same may be applied to
> LISP community to TeX or to any other community claiming smartness...
Well, i'm no quantum physicists, but has any one tried to apply
quantum gravity to falling apples? Perhaps he could discover a way to
have them fall directly in my fruit basket at home? ;-)
--
__Pascal Bourguignon__ http://www.informatimago.com/
"Klingon function calls do not have "parameters" -- they have
"arguments" and they ALWAYS WIN THEM."
On Feb 17, 2:25 pm, Pascal Bourguignon <····@informatimago.com> wrote:
> "Juan R." <··············@canonicalscience.com> writes:
> > A physicist using quantum gravity for falling apples would be
> > considered a bad physicist. Classical newtonian theory _is_ enough
> > there. It is not pragmatism, it is science. Same may be applied to
> > LISP community to TeX or to any other community claiming smartness...
>
> Well, i'm no quantum physicists, but has any one tried to apply
> quantum gravity to falling apples? Perhaps he could discover a way to
> have them fall directly in my fruit basket at home? ;-)
Irony apart, i do not know such one bad physicist doing that.
The remark was on LISP (as in TeX) community tendency to promote LISP
(or TeX) as the only approach to problems.
LISP people dismish PHP, Perl somewhat as TeX people dismish Word. But
if PHP and Word are by far more popular than LISP and Word is because
are rather fine for the tasks they were designed to do.
The criticism is constructive. LISP deserves more credit than usual
but postings as that of Tim X trying to present people do not using
LISP as a kind of stupids disliking "elegance" (a term of course
matching Tim X favourite measure of it) may not help to LISP promotion
(despite being a false argument).
"Juan R." <··············@canonicalscience.com> writes:
> LISP people dismish PHP, Perl somewhat as TeX people dismish Word. But
> if PHP and Word are by far more popular than LISP and Word is because
> are rather fine for the tasks they were designed to do.
It's possible that PHP and Word are popular for reasons other
than "being fine for the tasks they were designed to do".
And the "tasks they were designed to do" have a way of metamorphosing
into "tasks they were never designed to do". e.g. writing a book,
or serious technical documentation in Word, or writing a serious
web app in PHP.
Alain Picard <············@memetrics.com> writes:
> "Juan R." <··············@canonicalscience.com> writes:
>
>> LISP people dismish PHP, Perl somewhat as TeX people dismish Word. But
>> if PHP and Word are by far more popular than LISP and Word is because
>> are rather fine for the tasks they were designed to do.
>
> It's possible that PHP and Word are popular for reasons other
> than "being fine for the tasks they were designed to do".
>
> And the "tasks they were designed to do" have a way of metamorphosing
> into "tasks they were never designed to do". e.g. writing a book,
> or serious technical documentation in Word, or writing a serious
> web app in PHP.
I'd say that the phrase "serious web app" had no meaning when most of
the web-centric programming languages and environments were crafted.
By the time such a creature came into existence, however, web
developers were already used to doing small things in Perl, PHP, and
ASP, and they applied those tools to the serious apps.
The same applies to Word. Most people got hooked on Word by writing a
letter or maybe an essay, and when it came time to write a manuscript
that's the only tool they had any proficiency with.
On Feb 18, 1:29 am, Alain Picard <············@memetrics.com> wrote:
> "Juan R." <··············@canonicalscience.com> writes:
> > LISP people dismish PHP, Perl somewhat as TeX people dismish Word. But
> > if PHP and Word are by far more popular than LISP and Word is because
> > are rather fine for the tasks they were designed to do.
>
> It's possible that PHP and Word are popular for reasons other
> than "being fine for the tasks they were designed to do".
Well, here i mean an overall meaning for the concept of design. In my
discussions with lispers and texers i think i detect a emphasis on the
'thecnical' part of the word design. For instance, they focus on how
many bits of precision TeX engine devotes to positioning of scripts on
math mode. That is a part of design. The design of a good friendly
environment for the underlying algorithms is also part of design, even
devoting time to choose adequate colors for icons in a graphical
environment is also design; it is "design for the user".
In my opinion LISP and TeX were not designed for the user and that may
be why both failed to become mainstream. I do not doubt of smartness
of many lispers and texers, but they are smart just in some
'technical' part of the design, and are really bad in other parts;
parts are so necessary as the purely 'technical'.
When i hear some Texer or Lispers claiming how smart, and fine, and
elegant, and powerful... TeX or LISP are i always find:
i) the same arrogance about competitors (e.g. Perl, Word, PHP..)
ii) the same focusing in some aspect of the overall concept of design,
ignoring others aspects can be so important
iii) the neglecting that no anyone need to use the most powerful tool.
I think that analogy with physics is good. No anyone need to study
general relativity and quantum field theory. That is because Newtonian
mechanics is still thought in school.
Seeing to people here claiming that rest of the world is stupid
because is unable to see the "elegance" and "utility" (both relative
concepts) of LISP is so unfounded as if tomorrow physicists claim
anyone who never studied general relativity is 'stupid' and that
anyone would be using general relativity for any task.
This arrogance and elitism becoming from a part of LISP comunity (and
TeX also) is of little help for LISP and probably the only cause of
the social status of LISP. You cannot design a new system as Arc
claiming its target are the "good programmers". "Good" and "bad" are
again relative concepts. Some recursive algorithm can be "elegant" or
"good" for a LISPER but "ugly" and "bad" (inefficient) for a
computational chemist.
I would be very happy if i could see a mainstream LISP-like system but
this is very unlikely in a community is unable to see errors or
limitations on its vision of the world. For instance, each time i have
said that prefix notation would be avoided, i am replied that it is
not LISP that may change that but the rest of the world may accept the
prefix notation. This statement about prefix is usually joined with
unproven claims that "prefix is better", that "people dislike prefix
because lack familiarity" and other well-know LISP myths.
> And the "tasks they were designed to do" have a way of metamorphosing
> into "tasks they were never designed to do". e.g. writing a book,
> or serious technical documentation in Word, or writing a serious
> web app in PHP.
True, but misuse of tools for tasks never were really designed for is
applicable elsewhere.
On Sun, 18 Feb 2007 14:52:12 +0100, Juan R.
<··············@canonicalscience.com> wrote:
>
> When i hear some Texer or Lispers claiming how smart, and fine, and
> elegant, and powerful... TeX or LISP are i always find:
>
> i) the same arrogance about competitors (e.g. Perl, Word, PHP..)
>
> ii) the same focusing in some aspect of the overall concept of design,
> ignoring others aspects can be so important
>
> iii) the neglecting that no anyone need to use the most powerful tool.
>
> I think that analogy with physics is good. No anyone need to study
> general relativity and quantum field theory. That is because Newtonian
> mechanics is still thought in school.
>
> Seeing to people here claiming that rest of the world is stupid
> because is unable to see the "elegance" and "utility" (both relative
> concepts) of LISP is so unfounded as if tomorrow physicists claim
> anyone who never studied general relativity is 'stupid' and that
> anyone would be using general relativity for any task.
>
> This arrogance and elitism becoming from a part of LISP comunity (and
> TeX also) is of little help for LISP and probably the only cause of
> the social status of LISP. You cannot design a new system as Arc
> claiming its target are the "good programmers". "Good" and "bad" are
> again relative concepts. Some recursive algorithm can be "elegant" or
> "good" for a LISPER but "ugly" and "bad" (inefficient) for a
> computational chemist.
>
> I would be very happy if i could see a mainstream LISP-like system but
> this is very unlikely in a community is unable to see errors or
> limitations on its vision of the world. For instance, each time i have
> said that prefix notation would be avoided, i am replied that it is
> not LISP that may change that but the rest of the world may accept the
> prefix notation. This statement about prefix is usually joined with
> unproven claims that "prefix is better", that "people dislike prefix
> because lack familiarity" and other well-know LISP myths.
>
>> And the "tasks they were designed to do" have a way of metamorphosing
>> into "tasks they were never designed to do". e.g. writing a book,
>> or serious technical documentation in Word, or writing a serious
>> web app in PHP.
>
> True, but misuse of tools for tasks never were really designed for is
> applicable elsewhere.
>
lol. This really is a big issue to you isn't it.
Well I use TeX and Lisp. I also use Word, Adobe Acrobat (PDF), C, C#,
PHP...
Nice thing about computers, you don't have to have one tool that fits all.
Neither Tex nor Lisp have failed. Lisp has existed for 50 years soon.
TeX for 20. and they are still used.
Lisp has about 30 000 professional users. TeX (and LaTeX) is used by about
about 1000 000.
They are niche products. TeX is used in technical publishing. It is not
suitable for
multimedia as it requires 72 dpi for good rendering.
You could equally well argue that WYSIWYG give suboptimal rendering on a
printer because
it must comply with screen resolution which is too course.
I don't expect any of the products will become mainstream or reach the
popularity
of BASIC or Word. And quite frankly I don't care.
Only a fool measures quality in terms of popularity.
--
Using Opera's revolutionary e-mail client: http://www.opera.com/mail/
On Feb 18, 4:52 pm, "John Thingstad" <··············@chello.no> wrote:
> I don't expect any of the products will become mainstream or reach the
> popularity
> of BASIC or Word. And quite frankly I don't care.
> Only a fool measures quality in terms of popularity.
Maybe, but who said here that popularity is an absolute synonymous for
quality?
That was really critized here is Tim X 'semi-fanatic' postings
claiming (in an absolute sense) that LISP was so powerful and elegant
and that "the rest of the world cannot see the advantages".
The problem with LISP (and TeX also) is not the rest of the world: the
problem is LISP comunity which is unable to adapt LISP to world needs.
Note i am not speaking about elimination of more powerful aspects of
LISP to embrace a more general public. I am speaking about eliminating
weakness.
"Juan R." <··············@canonicalscience.com> writes:
> The problem with LISP (and TeX also) is not the rest of the world: the
> problem is LISP comunity which is unable to adapt LISP to world needs.
Becoming a mainstream language is pure coincidence. There are some
tiny aspects that may change the chance a little bit, but mostly it's
just coincidence.
So why should anyone care to change Lisp to be more attractive? The
mainstream just tosses a coin from time to time and based on the
outcome chooses a new hype language.
--
Stefan.
On Feb 24, 5:49 pm, Stefan Nobis <······@gmx.de> wrote:
> "Juan R." <··············@canonicalscience.com> writes:
> > The problem with LISP (and TeX also) is not the rest of the world: the
> > problem is LISP comunity which is unable to adapt LISP to world needs.
>
> Becoming a mainstream language is pure coincidence. There are some
> tiny aspects that may change the chance a little bit, but mostly it's
> just coincidence.
>
> So why should anyone care to change Lisp to be more attractive? The
> mainstream just tosses a coin from time to time and based on the
> outcome chooses a new hype language.
>
Whereas i recognize some azar and marketing aspects on the whole, I
disagree with your analisis coincidence is the most important point.
If becoming mainstream is pure coincidence, then computing the time
LISP is in the market, it would be mainstream two or three times
(because probability for an outcome increases with observation time).
LISP was not and this suggest it is not just pure azar that select a
winner.
Also if mainstream is a pure question of azar, why so many attempts to
modify (to adapt) LISP? I see that atempt also in recent Arc
development.
"Juan R." <··············@canonicalscience.com> writes:
> If becoming mainstream is pure coincidence, then computing the time
> LISP is in the market, it would be mainstream two or three times
> (because probability for an outcome increases with observation
> time).
Wrong. This is not one single ongoing experiment. From time to time
there are opportunities when a new language is selected by the
mainstream. Each time a random selection is made independently, so the
chance of a long term player isn't raising.
> Also if mainstream is a pure question of azar, why so many attempts
> to modify (to adapt) LISP? I see that atempt also in recent Arc
> development.
Because of taste. And because most people don't recognise that
popularity of languages is purly coincidence.
--
Stefan.
Stefan Nobis wrote:
> "Juan R." <··············@canonicalscience.com> writes:
>
>
>>If becoming mainstream is pure coincidence, then computing the time
>>LISP is in the market, it would be mainstream two or three times
>>(because probability for an outcome increases with observation
>>time).
>
>
> Wrong. This is not one single ongoing experiment.
No, there are six, and they are paired. Sounds like quarks. Imperative -
declarative, static - dynamic, verbose - terse. Did I miss any? Maybe
minimalist - mudball. I would add infix - prefix, tho that does not
strike me as experimental, you do it or don't with a new language.
Other pairs?
hth,kt
--
Well, I've wrestled with reality for 35 years, Doctor, and
I'm happy to state I finally won out over it.
-- Elwood P. Dowd
In this world, you must be oh so smart or oh so pleasant.
-- Elwood's Mom
>>>>> "SN" == Stefan Nobis <······@gmx.de> writes:
SN> Because of taste. And because most people don't recognise that
SN> popularity of languages is purly coincidence.
Except that I don't think it is *purely* coincidence -- I just think
that the initial adoption is random, but after that it becomes much
more predictable.
For instance, the initial popularity of Java was, I think, largely due
to marketing and buzz, and the promise of write-once-run-anywhere
applets. The current popularity has a lot to do with a
chicken-and-egg pattern: management knows that there are lots of Java
programmers out there, and programmers know that if they put Java on
their resume and know it well enough to get through an interview they
will have a shot at a safe corporate job. This is completely
independent of the actual quality of Java, which I don't intend to
comment on here.
Charlton
--
Charlton Wilbur
·······@chromatico.net
On Feb 26, 12:57 pm, Charlton Wilbur <·······@chromatico.net> wrote:
> >>>>> "SN" == Stefan Nobis <······@gmx.de> writes:
>
> SN> Because of taste. And because most people don't recognise that
> SN> popularity of languages is purly coincidence.
>
> Except that I don't think it is *purely* coincidence -- I just think
> that the initial adoption is random, but after that it becomes much
> more predictable.
>
Let's just come out and say it. Lisp has not been adopted by the
masses because most in the masses are not intelligent enough to handle
Lisp programming. Only the curious and gifted will bother to even
explore the language. Java is about what most developers these days
can handle, barely. Lisp requires a certain clarity of thought and
strong knowledge of programming principles that eludes the great
unwashed programming legions.
If you think I'm not being serious, you're right -- I am.
On Feb 25, 9:46 pm, Stefan Nobis <······@gmx.de> wrote:
> "Juan R." <··············@canonicalscience.com> writes:
> > If becoming mainstream is pure coincidence, then computing the time
> > LISP is in the market, it would be mainstream two or three times
> > (because probability for an outcome increases with observation
> > time).
>
> Wrong. This is not one single ongoing experiment.
I was speaking about p(t) series, therefore I have no idea what do you
mean by "This is not one single ongoing experiment."
> From time to time
> there are opportunities when a new language is selected by the
> mainstream. Each time a random selection is made independently, so the
> chance of a long term player isn't raising.
If, as you say, choosing a language over time is pure azar, why do we
look zero LISP-peaks in the temporal series? Why much younger
languages present popularity peaks when would be much less probable?
Data does not support your assertions.
> > Also if mainstream is a pure question of azar, why so many attempts
> > to modify (to adapt) LISP? I see that atempt also in recent Arc
> > development.
>
> Because of taste. And because most people don't recognise that
> popularity of languages is purly coincidence.
And if again is pure coincidence, why traditional LISP survives,
whereas any other attempt to modify LISP is forgotten in the past? If
popularity is pure azar, then about a 50% of today used LISPs would be
traditional LISP and another 50% (aprox) would be alternative LISPs;
e.g. LISPs with ALGOL-like syntax.
As far as I know LISP community has always rejected alternative LISPs
because lacking power or elegance or both not because coins.
Again data does not support your assertions.
>From a personal point of view I like LISP before Java or C, and Scheme
before CL... I can assure you my preferences are not at azar and
current popularity of Java does not change my view -I really hate
Java-.
On Feb 24, 7:53 am, "Juan R." <··············@canonicalscience.com>
wrote:
>
> The problem with LISP (and TeX also) is not the rest of the world: the
> problem is LISP comunity which is unable to adapt LISP to world needs.
>
Damn. And here I was thinking it was the parenthesis. No wonder no
one
uses Lisp.
"Juan R." <··············@canonicalscience.com> writes:
> On Feb 18, 4:52 pm, "John Thingstad" <··············@chello.no> wrote:
>> I don't expect any of the products will become mainstream or reach the
>> popularity
>> of BASIC or Word. And quite frankly I don't care.
>> Only a fool measures quality in terms of popularity.
>
> Maybe, but who said here that popularity is an absolute synonymous for
> quality?
>
> That was really critized here is Tim X 'semi-fanatic' postings
> claiming (in an absolute sense) that LISP was so powerful and elegant
> and that "the rest of the world cannot see the advantages".
>
lol! What is your problem? Putting aside that you have totally misunderstood my
post and even ignoring how a single post could ever be interpreted as
'semi-fenatic' I really believe you need to come clean and admit what the real
problem is.
> The problem with LISP (and TeX also) is not the rest of the world: the
> problem is LISP comunity which is unable to adapt LISP to world needs.
>
Ah, I'm beginning to understand. In another thread, I corrected you for
claiming that PDF files were inaccessible to blind users and you insisted in
arguing the point. I also suggested that claiming TeX was poorly designed
because it doesn't suit web publishing was an unreasonable assertion since the
web didn't exist when TeX was designed. I also stated that as a blind user,
LaTeX was the most accessible authoring tool, especially for math notation,
available to blind users, which you also argued against. I'm beginning to think
its not a coincidence that you need to misrepresent my post in another thread
and claim I'm being 'semi-fenatic' based on a single post (which you totally
misread).
I'm now wondering who it really is that is full of arrogance and unable to
accept any opinion which differs from their own.
Tim
--
tcross (at) rapttech dot com dot au
On Mar 9, 7:44 am, Tim X <····@nospam.dev.null> wrote:
> Ah, I'm beginning to understand. In another thread, I corrected you for
> claiming that PDF files were inaccessible to blind users and you insisted in
> arguing the point.
I did not remember that discussion then. I reply to posts not to
people.
Now I remember that thread and who you are. I cited for you a bunch of
sources (including recommendations on accesibility by official sites )
contradicing your absolute claim PDF was _more_ accesible than HTML.
For instance
[BLOCKQUOTE [1]
Although Adobe is doing a better job of removing accessibility
barriers from their product, HTML is still the preferred web format
by the majority of users with disabilities.
]
But you believed that web designers would focus on Tim X personal
preferences instead on the mayority of users. And I can see you
continue to insist on this topic.
> I also suggested that claiming TeX was poorly designed
> because it doesn't suit web publishing was an unreasonable assertion since the
> web didn't exist when TeX was designed.
I argued that ***usage*** of TeX for the web was incorrect (of course,
I recognized had been not designed for the web). I also cited W3C
MathML FAQ where was explained why TeX had been rejected during the
design of the markup language. And you began to write nonsense about
that.
> I also stated that as a blind user,
> LaTeX was the most accessible authoring tool, especially for math notation,
> available to blind users, which you also argued against.
Idem.
> I'm beginning to think
> its not a coincidence that you need to misrepresent my post in another thread
> and claim I'm being 'semi-fenatic' based on a single post (which you totally
> misread).
>
> I'm now wondering who it really is that is full of arrogance and unable to
> accept any opinion which differs from their own.
I ***never*** said you would abandon Linux, CL, TeX or PDF.
However, you claimed:
[i] that Linux and CL were not more popular because "the world could
not see the advantages" (which is much as saying the rest of people is
'stupid')
[ii] web designers would prefer PDF files over HTML ones (ignoring
official recommendations on accesibility).
[iii] MathML was not more accesible than TeX/LaTeX.
[1] http://www.webaim.org/techniques/acrobat/
"Juan R." <··············@canonicalscience.com> writes:
> On Feb 18, 1:29 am, Alain Picard <············@memetrics.com> wrote:
>> "Juan R." <··············@canonicalscience.com> writes:
>> > LISP people dismish PHP, Perl somewhat as TeX people dismish Word. But
>> > if PHP and Word are by far more popular than LISP and Word is because
>> > are rather fine for the tasks they were designed to do.
>>
>> It's possible that PHP and Word are popular for reasons other
>> than "being fine for the tasks they were designed to do".
>
> Well, here i mean an overall meaning for the concept of design. In my
> discussions with lispers and texers i think i detect a emphasis on the
> 'thecnical' part of the word design. For instance, they focus on how
> many bits of precision TeX engine devotes to positioning of scripts on
> math mode. That is a part of design. The design of a good friendly
> environment for the underlying algorithms is also part of design, even
> devoting time to choose adequate colors for icons in a graphical
> environment is also design; it is "design for the user".
>
This is somewhat ironic given your criticisms of my earlier post.
Unfortunately, you saw my use of 'smart' and 'elegant' and rather than read
what I wrote, immediately jumped to the mistaken conclusion I was arguing that
CL and its users were somehow superior or elite and that the rest of the
community was stupid for not understanding this. In fact, I was arguing that
part of the issue with the failure of lisp and CL to evolve *might* be due to
too much concentration on theoretical issues and not enough on more pragmatic
practicle use of the language (substitute your use of 'technical' for my use of
theoretical). My suggestion was that we get bogged down on theoretical points
which may only be relevant in a small subset of problems and ignore practicle
benefits of changes for a wider range of more common problems.
Before anyone gets ready to fire back the normal attack and take me to task for
not understanding CL and its strengths, please also note that I personally am
not arguing for a change to the language - for my own personal use, I'm quite
happy with the status quo.
> In my opinion LISP and TeX were not designed for the user and that may
> be why both failed to become mainstream. I do not doubt of smartness
> of many lispers and texers, but they are smart just in some
> 'technical' part of the design, and are really bad in other parts;
> parts are so necessary as the purely 'technical'.
>
I disagree that CL was not designed for the user. In fact, I think thats
exactly who it was designed for. However, I think you need to evaluate who or
what something was designed for in the context of the period when it was
designed and what the knowledge and understanding of the designers was at that
time and the types of applications/problems being addressed. To argue that CL
is badly designed or that the standard is poorly specified because it doesn't
include standard libraries for HTTP for example is rediculous. At the time,
HTTP was barely on the horizon and despite how smart lispers are, they cannot
predict the future. Likewise, with prefix vs infix notation. At the time when
lisp was first implemented, this was the common paradigm wrt to
computers/programming. Things have evolved and our understanding and skills in
language, parser and compiler design have come a long way and
trends/tastes/expectations have changed.
It would be better to say that CL was not designed for the users of *today*.
There would still be plenty who would argue the point, but I think the
statement is more accurate to what I believe you are really saying.
> When i hear some Texer or Lispers claiming how smart, and fine, and
> elegant, and powerful... TeX or LISP are i always find:
>
> i) the same arrogance about competitors (e.g. Perl, Word, PHP..)
>
> ii) the same focusing in some aspect of the overall concept of design,
> ignoring others aspects can be so important
>
> iii) the neglecting that no anyone need to use the most powerful tool.
>
You are reading far too much into what is often being said and making
assumptions concerning the authors which may not be true. You can state that
you think language X is smart, fine, elegant and powerful, but that doesn't
mean by definition that all other languages are not. It is not a binary
proposition - I think CL is smart, fine, elegant and powerful, but I also think
this about Ruby and even Perl. I don't like PHP, Python or Java, but thats
about personal taste. Likewise, I would never argue that one language should be
promoted over all others at any cost.
> I think that analogy with physics is good. No anyone need to study
> general relativity and quantum field theory. That is because Newtonian
> mechanics is still thought in school.
>
> Seeing to people here claiming that rest of the world is stupid
> because is unable to see the "elegance" and "utility" (both relative
> concepts) of LISP is so unfounded as if tomorrow physicists claim
> anyone who never studied general relativity is 'stupid' and that
> anyone would be using general relativity for any task.
>
In quite a few years of participating in this group, I have rarely seen any
posts were people claim that everyone else is stupid if they don't use CL. I
think your injecting emotional value judgements where they seldom exist. I see
frequent posts asking why others don't see/understand the benefits, power or
even superiority of CL as a language and I do see posts with some fairly
arrogant attitudes, but I don't see arrogance you seem to ascribe to the CL
community regarding other languages. Just because someone prefers one langauge
over another doesn't automatically mean they are being arrogant. .
> This arrogance and elitism becoming from a part of LISP comunity (and
> TeX also) is of little help for LISP and probably the only cause of
> the social status of LISP. You cannot design a new system as Arc
> claiming its target are the "good programmers". "Good" and "bad" are
> again relative concepts. Some recursive algorithm can be "elegant" or
> "good" for a LISPER but "ugly" and "bad" (inefficient) for a
> computational chemist.
>
You have put forward this claim a few times and at first I sort of agreed.
However, the more I think about it, I actually don't agree that good/bad or
elegant/inelegant are as subjective as you claim. While it is true on one hand
that there is some relative aspects to what is good and what is bad, there are
also some quantitative aspects that can be applied to such measures. An
algorithm which has an exponential relationship to its input with respect to
speed or resource consumption is not as good as one that does the same thing,
but has a linear relationship. An algorithm which is expressed in 5 lines is
more elegant than an equivalent algorithm which takes 100 lines to express and
an algorithm which gives a correct result for all possible inputs is better
than one which only gives the correct result for only a subset of possible
inputs.
A chemist is likely to express an algorithm differently to how a programmer
would express it and that algorithm may give the chemist the results they want.
However, this doens't mean the algorithm is elegant or good just becuase it
meets the chemists needs. However, for the chemist, elegance or even efficiency
is probably less important to the main question of getting the answer. However,
this has nothing to do with elegance, good or bad. For the programmer, such
issues are likely to be more relevant because this is part of what being a
programmer is about. Likewise, if I paint my house, it is likely I won't do as
good a job as an experienced commercial painter who takes pride in what he
does.
I wold agree it is harder to make comparisons on elegance between different
languages and would argue you can express something which would be considered
elegant in any language and I would agree that some languages suit specific
problem domains better than others.
> I would be very happy if i could see a mainstream LISP-like system but
> this is very unlikely in a community is unable to see errors or
> limitations on its vision of the world. For instance, each time i have
> said that prefix notation would be avoided, i am replied that it is
> not LISP that may change that but the rest of the world may accept the
> prefix notation. This statement about prefix is usually joined with
> unproven claims that "prefix is better", that "people dislike prefix
> because lack familiarity" and other well-know LISP myths.
>
I find it interesting that on one had you can argue that concepts such as good,
bad, elegant etc are relative, but then also argue that the lisp community is
wrong because they don't agree with your view on prefix/infix. Surely, your
perspective on which is better is relative to your position? Your claim of
unproven arguements regarding the benefits of prefix notation could also be
applied to your arguements for changing to infix - where is the proof (as
opposed to relative or subjective belief) that infix is better?
Tim
--
tcross (at) rapttech dot com dot au
On Mar 9, 7:24 am, Tim X <····@nospam.dev.null> wrote:
> This is somewhat ironic given your criticisms of my earlier post.
> Unfortunately, you saw my use of 'smart' and 'elegant' and rather than read
> what I wrote, immediately jumped to the mistaken conclusion I was arguing that
> CL and its users were somehow superior or elite and that the rest of the
> community was stupid for not understanding this.
Yes, I got that conclusion from your posting. Next a selection of
statements you did in previous postings.
> to some extent, I suspect one significant reason we (the lisp user community)
> has problems getting increased acceptance/support from the IT community is
> because we have too many smart users with strong theoretical grounding.
Can be read as comunities outside LISP "have not much smart users with
strong theoretical grounding".
> It is possible part of the problem here is that lisp is so powerful and one of
> the few languages which is able to adapt to the complexities of the real world
> with such ease and elegance.
Can be read as other languages "are difficult and lack elegance."
> While I'd love to be using lisp at work, I'm skeptical we will ever see it as
> one of the maintstream development platforms. [...] I'm pleased I have lisp to
> code with and I'm pleased I have GNU Linux, but if the rest of the world cannot
> see the advantages, well, thats their loss and I'd rather keep things as they
> are than sacrifice power, elegance or reliability simply to see increased
> popularity.
Can be read like "the rest of the world is 'stupid' and cannot see the
advantages of LISP" and "popular languages are popular because they
sacrifice power, elegance or reliability".
> If the rest of the industry is to be convinced regarding the
> superiority of lisp, then someone had better come up with the goods.
Can be read like "LISP is superior, now the rest of industry (remember
poor folks are blinded and cannot see the advantages) needs to be
educated about that fact."
[END SAMPLES]
Of course, if you claim that posts were misread and you were not
saying that then end of discussion. But below and posterior posts you
appears to support that point again.
> > In my opinion LISP and TeX were not designed for the user and that may
> > be why both failed to become mainstream. I do not doubt of smartness
> > of many lispers and texers, but they are smart just in some
> > 'technical' part of the design, and are really bad in other parts;
> > parts are so necessary as the purely 'technical'.
>
> I disagree that CL was not designed for the user. In fact, I think thats
> exactly who it was designed for.
If was designed for users and is being not used... either desing is
incorrect or rest of people is 'stupid' and cannot the advantages of
CL. I know that LISP community likes to believe on latter explanation.
> However, I think you need to evaluate who or
> what something was designed for in the context of the period when it was
> designed and what the knowledge and understanding of the designers was at that
> time and the types of applications/problems being addressed. To argue that CL
> is badly designed or that the standard is poorly specified because it doesn't
> include standard libraries for HTTP for example is rediculous.
I wrote about "unfriendly" design not about "outdated". Do not mix!
> At the time,
> HTTP was barely on the horizon and despite how smart lispers are, they cannot
> predict the future.
Irony or serious?
> Likewise, with prefix vs infix notation. At the time when
> lisp was first implemented, this was the common paradigm wrt to
> computers/programming.
Then Fortran, which is older than LISP, was all-prefix? That is new
for me.
I see an irony here. LISP zealots like to claim that LISP has survived
in time because easy to adaptation to new paradigms. The irony is that
precisely LISP lack of adaptation is the cause LISP was popularly
rejected.
> Things have evolved and our understanding and skills in
> language, parser and compiler design have come a long way and
> trends/tastes/expectations have changed.
Sure that LISP designers actualised their knowledge (LISP compilers
are much more efficient now) since McCarthy, but they fail in
understanding humans still.
E.g. LISP community like to triviallize the reason why people reject
the prefix notation. LISPERS like to say that reason is familiarity,
but I know of none study proving that perception by human brain of
prefix and infix notations ***was*** equivalent (and therefore
preference of one over other based in educational roles as LISPERS
declare).
> > When i hear some Texer or Lispers claiming how smart, and fine, and
> > elegant, and powerful... TeX or LISP are i always find:
>
> > i) the same arrogance about competitors (e.g. Perl, Word, PHP..)
>
> > ii) the same focusing in some aspect of the overall concept of design,
> > ignoring others aspects can be so important
>
> > iii) the neglecting that no anyone need to use the most powerful tool.
>
> You are reading far too much into what is often being said and making
> assumptions concerning the authors which may not be true. You can state that
> you think language X is smart, fine, elegant and powerful, but that doesn't
> mean by definition that all other languages are not.
Read point i) which I did explicit. I am not worried by people who
think that language X is powerful or elegant but about well-known
arrogance on many texers and lispers.
> You have put forward this claim a few times and at first I sort of agreed.
> However, the more I think about it, I actually don't agree that good/bad or
> elegant/inelegant are as subjective as you claim.
This variability of your ideas does debate very difficult. Could you
limit your postings about stuff you will not change in next 60 days?
> While it is true on one hand
> that there is some relative aspects to what is good and what is bad, there are
> also some quantitative aspects that can be applied to such measures. An
> algorithm which has an exponential relationship to its input with respect to
> speed or resource consumption is not as good as one that does the same thing,
> but has a linear relationship.
As remarked you are lacking the vision of the whole.
If the linear algorithm needs less programmers-hours than optimized
algorithm whereas scaling of speed and resource comsumptions are
aceptable then the linear (simple) algorithm will be so good or better
than the optimized (contradicting your 'personal' definition of good).
GOOD = TECHNICALLY-GOOD + ECONOMICALLY-GOOD
> An algorithm which is expressed in 5 lines is
> more elegant than an equivalent algorithm which takes 100 lines to express and
> an algorithm which gives a correct result for all possible inputs is better
> than one which only gives the correct result for only a subset of possible
> inputs.
This is also relative. For example the 5-lines algorithm uses 7
different functions and the 100 lines algorithm uses only 1 function.
A theoretician working in unification would find the 100-lines
algorithm more elegant because based in a single function: was of the
TOE.
> A chemist is likely to express an algorithm differently to how a programmer
> would express it and that algorithm may give the chemist the results they want.
> However, this doens't mean the algorithm is elegant or good just becuase it
> meets the chemists needs.
Computational or informational chemists (programmers) have their own
definitions for "elegant" or "good". If they (many) dislike LISP is
not because "cannot see advantages" but because LISP has none from
their own requirements scale.
> However, for the chemist, elegance or even efficiency
> is probably less important to the main question of getting the answer.
This may be kidding. Precisely, quantum chemical codes are usually
considered to be highly optimized code when compared with analogous
inefficient LISP code. The skills of LISPERS to really optimize
algorithms for speed of memory are unknown to me. I never see an
really efficient algorithm being developed by a lisper. However, I see
often mathematicians publishing in Computers and Chemistry journal and
similar high-efficiency algorithms.
Look to the 1998 Nobel for chemistry (on computation). John Pople was
mathematician and devoted his life to development of most efficient
algorithms. The algorithms he developed for Hartree-Fock calculations
during the 70s were much faster than earlier programs by others.
About efficiencies and high performance, physicists also know a lot of
and have actively contributed to the development of high-performance
parallel computers. Do they use LISP? Why?
> > I would be very happy if i could see a mainstream LISP-like system but
> > this is very unlikely in a community is unable to see errors or
> > limitations on its vision of the world. For instance, each time i have
> > said that prefix notation would be avoided, i am replied that it is
> > not LISP that may change that but the rest of the world may accept the
> > prefix notation. This statement about prefix is usually joined with
> > unproven claims that "prefix is better", that "people dislike prefix
> > because lack familiarity" and other well-know LISP myths.
>
> I find it interesting that on one had you can argue that concepts such as good,
> bad, elegant etc are relative, but then also argue that the lisp community is
> wrong because they don't agree with your view on prefix/infix.
There is ***not*** conflict. Being relative mean that some people have
some idea and other people has the contrary one. If you ask people if
they prefer prefix or infix a 90% of people will say you they hate
LISP all-prefix. However, lispers like all-prefix (as stated in this
newsgroup many times).
I am saying is LISP community is wrong when they want become more
mainstream but are not noticing what is real cause of many decades
fiasco (so called social problems of LISP). The idea I often hear is
that LISP is correctly designed and the problem is in "the rest of the
world".
As said the myth in LISP community is that people dislike prefix
because familiarity issue. At least lispers as Paul Graham contradicts
that and as first step in a 'mainstream' Arc he want infix math built-
in.
I do not doubt a subset of people like the prefix notation. But I
reject lisp-gurus' (or dalai) belief people who dislike the all prefix
notation and other particularities of LISP are morons. The anti-social
and elitists attitude of part of LISP community is well documented.
"Juan R." <··············@canonicalscience.com> writes:
> On Feb 17, 2:25 pm, Pascal Bourguignon <····@informatimago.com> wrote:
>> "Juan R." <··············@canonicalscience.com> writes:
>> > A physicist using quantum gravity for falling apples would be
>> > considered a bad physicist. Classical newtonian theory _is_ enough
>> > there. It is not pragmatism, it is science. Same may be applied to
>> > LISP community to TeX or to any other community claiming smartness...
>>
>> Well, i'm no quantum physicists, but has any one tried to apply
>> quantum gravity to falling apples? Perhaps he could discover a way to
>> have them fall directly in my fruit basket at home? ;-)
>
> Irony apart, i do not know such one bad physicist doing that.
>
> The remark was on LISP (as in TeX) community tendency to promote LISP
> (or TeX) as the only approach to problems.
>
> LISP people dismish PHP, Perl somewhat as TeX people dismish Word. But
> if PHP and Word are by far more popular than LISP and Word is because
> are rather fine for the tasks they were designed to do.
>
> The criticism is constructive. LISP deserves more credit than usual
> but postings as that of Tim X trying to present people do not using
> LISP as a kind of stupids disliking "elegance" (a term of course
> matching Tim X favourite measure of it) may not help to LISP promotion
> (despite being a false argument).
>
I'm not sure I even understand exactly what you are saying. To make any
statement regarding what is or is not my favorite term after a single post is
rediculous and you have totally misrepresented (or misunderstood) what I was
arguing - in fact, you pretty much have it backwards. My post had absolutely
nothing to do with why people should or should not use CL or LISP. In fact, the
post was about debates wtihin c.l.l on lisp and CL and why these debates seldom
come to any real conclusion or progress further than descending into circular
arguement which is often based on theoretical rather than practicle issues. I
wasn't even making any claims, but rather presenting some observations for
debate.
Now your just trying to be both offensive and deliberately misrepresent what I
was posting. At no point did I mention other languages or claim that anyone not
using lisp was an idiot. What I said was that I liked CL and GNU Linux and I
believe they are great languages/platforms (even superior), but I also said I
don't care what anyone else uses. I also said that if others didn't agree, well
as far as I'm concerned thats their loss. I made no value judgement concerning
what other people use and explicitly made the point I have absolutely no
interest in trying to convert others etc. however, all of this is actually
quite irrelevant to the main point of what I was saying, which actually
concerned some thoughts I had regarding the types of debate in c.l.l compared
to debates in other languages. Unfortunately, you were so intent on trying to
attack me, you concentrated on my use of terms such as 'smart', and 'elegant',
which you took out of context and attempt to twist into something else. At no
point did you actually try to address the main thrust of my post. As others did
understand it, I don't believe it was because I didn't make this clear enough.
Possibly its a language barrier or possibly I just didn't
express myself clearly enough, but in the end its quite irrelevant. I do wonder
if its related to our earlier debate in another thread. If so, it is
unfortunate you were unable to separate the two and avoid what must have caused
an emotional issue for you. I have no problem with you taking me to task over
anything I post, but I would prefer a debate on the argument rather than
a pseudo dig based on judicious snipping designed to misrepresent my point of
view.
Tim
--
tcross (at) rapttech dot com dot au
On Mar 9, 6:02 am, Tim X <····@nospam.dev.null> wrote:
>
> > The criticism is constructive. LISP deserves more credit than usual
> > but postings as that of Tim X trying to present people do not using
> > LISP as a kind of stupids disliking "elegance" (a term of course
> > matching Tim X favourite measure of it) may not help to LISP promotion
> > (despite being a false argument).
>
> I'm not sure I even understand exactly what you are saying. To make any
> statement regarding what is or is not my favorite term after a single post is
> rediculous and you have totally misrepresented (or misunderstood) what I was
> arguing - in fact, you pretty much have it backwards. My post had absolutely
> nothing to do with why people should or should not use CL or LISP. In fact, the
> post was about debates wtihin c.l.l on lisp and CL and why these debates seldom
> come to any real conclusion or progress further than descending into circular
> arguement which is often based on theoretical rather than practicle issues. I
> wasn't even making any claims, but rather presenting some observations for
> debate.
To remark again, when you said:
> >> It is possible part of the problem here is that lisp is so powerful and one of
> >> the few languages which is able to adapt to the complexities of the real world
> >> with such ease and elegance.
My point was that maybe your evaluation of LISP is plaing wrong. Maybe
reason LISP is not more popular is because is not "so powerful" (as
you claimed) and is not adapting to the complexities of the real world
with ease and elegance (as you claimed also).
When you said:
> >> I'm pleased I have lisp to
> >> code with and I'm pleased I have GNU Linux, but if the rest of the world cannot
> >> see the advantages, well, thats their loss and I'd rather keep things as they
> >> are than sacrifice power, elegance or reliability simply to see increased
> >> popularity.
My point was that maybe the rest of the world is not so blinded as you
think and maybe is ***not*** "the rest of the world who "cannot see
the advantages", but both LISP and Linux communities are failing to
see disavantages.
"Juan R." <··············@canonicalscience.com> writes:
> On Feb 11, 9:19 am, Tim X <····@nospam.dev.null> wrote:
>> to some extent, I suspect one significant reason we (the lisp user community)
>> has problems getting increased acceptance/support from the IT community is
>> because we have too many smart users with strong theoretical grounding.
>
> Personally, I do not call smart one able to understand most advanced
> theoretical framework but one is able to use the correct framework for
> specific problems.
>
I did not say that smart meant only being able to understand theoretical
frameworks - notice the *and* in the sentence. However, since you want to link
the two I would only ask how do you know what is the best framework if you
don't understand those which are available? Surely understanding of the
theory underlying the different systems is an important component in making the
decision on which to use (I've never seen anyone select a tool for a job when
they don't understand that tool. People tend to choose to use what they
understand even if it isn't the best tool available).
>> I sometimes wonder if we do get caught up in the small (but
>> important) details and miss the big picture and whether we would be better off
>> adopting a more pragmatic "full speed ahead and damn the torpedoes" attitude
>> and what that would cost in the long run.
>
> A physicist using quantum gravity for falling apples would be
> considered a bad physicist. Classical newtonian theory _is_ enough
> there. It is not pragmatism, it is science. Same may be applied to
> LISP community to TeX or to any other community claiming smartness...
>
I think you completely missed my point here. I was refering to the the frequent
debates in this group regarding making changes or additions to the standard
language which people argue would make it more widely accepted as a tool. I'm
suggesting that it could be argued the reason there is little change in the
status quo for lisp is because we cannot get consensus and the reason we cannot
get consensus is that we get caught up on debating too many little things,
which theoretically may have a detramental impact on the power of the language
as a tool when this theoretical negative impact only affects a small subset of
the problems commonly addressed. . I'm asking if there is possibly a case for
arguing that doing something which theoretically makes a particular use of the
language to solve a specific type of problem more difficult or less elegant
could be justified if it also makes other things easier to do when those other
things represent the more common types of problems and those areas which will
be made more difficult or have a less elegant solution are rare. The pragmatism
I'm referring to relates to whether we want a language which at one extreme is
theoretically pure and at the other extreme a language which sacrifices some of
its purity in order to facilitate its use to solve more common and often more
trivial problems in order to broaden the languages acceptance. Note that I'm
not arguing for one over the other, but rather asking the question to see if
others have similar thoughts regarding the process (not the outcome).
My question is based on the observations of debates in this group compared to
other language groups, such as python and java. In this group, anybody who
raises the question of changes to the CL standard or proposes libraries for
addition into as a standard library often creates a debate that ends up in
debates around theoretical advantages/disadvantages. In other groups, the
debates end up focusing on more pragmatic points concerning the application in
real-world common problems. In these other groups, theoretical issues seem less
common and I often get the impression the arguments are based more on limited
practicle experience of using the language rather than broader theoretical
points.
Note also that I am not arguing for change to CL or believe anything needs
'fixing'. If anything, my points are really just a musing on the differences in
debate/arguement in this group compared to toher language groups and some
theorising as to why frequently repeated threads on what needs to change in CL
never reach any solid conclusion, but reoccur with such frequency.
>> It is possible part of the problem here is that lisp is so powerful and one of
>> the few languages which is able to adapt to the complexities of the real world
>> with such ease and elegance.
>
> Are not both relative concepts?
>
You can call them relative or you could call them qualitative or whatever tag
you want to assign. I can't see what your point is or what relevance your
question has to the point I was trying to make. Of course, this may have been
clearer if you hadn't actually cut out the actual meat of the paragraph. It
seems to me you are debating my choice of terms rather than the thrust of what
I was saying.
>> While I'd love to be using lisp at work, I'm skeptical we will ever see it as
>> one of the maintstream development platforms. However, i have a similar
>> attitude to this as to the development of GNU linux as a mainstream operating
>> system. While I like both a lot and think they should have wider acceptance
>> than they do, I don't really care if they don't. I'm pleased I have lisp to
>> code with and I'm pleased I have GNU Linux, but if the rest of the world cannot
>> see the advantages, well, thats their loss and I'd rather keep things as they
>> are than sacrifice power, elegance or reliability simply to see increased
>> popularity.
>
> This is the traditional but flawed attitude towards LISP. Advantages
> are relative also. I know scientists using Linux when they need some
> Linux advantage and using Windows when needing some Windows advantage
> and using Mac also. Why do you believe that professor X has three
> machines, one with XP, other with some Linux and a third one with a
> SGI SO? If Linux were the only one needed, then he would forgot other
> machines (specially the very expensive SGI WS).
>
Funny, my point was that I don't actually care if people want to use another
language, another platform or a pointed stick. What I was trying to get across
(and obviously failed) was that I really don't care about what others use. The
current situation with CL (and GNU/Linux) meets my needs and I have no great
desire to convert the whole world to using CL and GNU/Linux. I have no desire
to be an evangelist for either a language or a platform and am quite willing to
accept that others may not find them as useful as I do - they meet my needs and
really thats all I care about.
I was actually trying to address the common threads which pop up in this group
concerning what needs to be done to get CL to take over the world. My point is
that I think this is irrelevant. I don't understand why just because somone
finds something they really like they then seem to have this drive to convert
the rest of the world to using it. Its fine to tell people how wonderful you
think something is, but why do so many feel that it has to go yet another step
and convert everyone to their point of view?
>> If the rest of the industry is to be convinced regarding the
>> superiority of lisp, then someone had better come up with the goods.
>
> As remarked, there is not such one "superiority" in absolute terms.
I'm not the one arguing there is. I'm merely saying to those who ask the
question why CL, if its so great/superior, isn't more popular than Java,
Python, Ruby etc, that part of what they would need to show is more clearly
seen success stories in a similar vain to the argued successes of these other
more widely accepted languages.
>
>> All business cares about is that the application
>> solves the problem and does it today - it doesn't matter if its slow, requires
>> more processing power, storage or maintenance, it just needs to solve the
>> problem. Its efficiency, elegance or probable usable life is irrelevant udner
>> todays management paradigm - just as long as its here today and words to
>> address the problem now is all that matters.
>
> Again you focuse on relative points. Maybe you call elegant is to be
> considered an ugly solution from other perspective. How many times i
> heard that LISP recursive posibilities to computing factorials are
> elegant? How many times i said, from my perspective, it is a very ugly
> solution?
>
Are you kidding! I said the opposite. Are you so intent on arguing that you
cannot even read clearly? I mean, what in "Its efficiency, elegance or probable
usable life is irrelevant.." leads you to say that I'm focusing on relative
points - do you not understand the meaning of irrelevant?
>> Like other aspects of modern
>> society, form is often sacrificed for function - look at all the ugly houses
>> built today.
>
> And why would be not form sacrified? Because you consider so?
>
> I can live with people thinking form is more important. I can live
> with people thinking function is more important. I can also live with
> people thinking both are important. That I find rather disturbing is
> the tendency of some subset of LISP community to force others to
> accept their own views as the only one acceptable views. Maybe you
> call "ugly houses" are beatiful for others. Are you asked?
>
I can certainly accept that form, elegance etc are relative (beauty in the eye
of the beholder and all that). However, there is generally a level of majority
consensus whith such concepts. Although these can be culturally bound and there
will always be hotly debated edge cases, there does tend to be considerable
consensus on asthetics and elegance. There are plenty of examples of code which
the majority of people would look at and say "Wow, thats elegant" and code
which the majority will look at and say "Wow, thats inelegant". Likewise, there
are houses/buildings which the majority would look at and agree have a pleasing
and asthetic form and other houses/building which the majority would call ugly
or lacking in asthetics. I wold even agree that often new ways of doing things
are initially viewed as ugly or inelegant and that it often takes time for the
majority to learn to appreciate more subtle aspects of unfamiliar designs etc.
At no time have I asserted that my opinion is or should be the only correct one
and nor have I claimed I'm talking in absolutes. However, my experience, based
on observations, discussions with others, following debates etc leads me to
believe there is a high level of consensus out there that in the modern world,
asthetics, elegance and form is too often sacrificed in favor of obtaining
function and a lower economic cost. Just because a concept deals in relative
terms rather than absolute 'black and white' doesn't mean you cannot use it or
build arguments that reference it. It is these grey areas where debate arises -
its what makes things interesting.
In some ways, your response to my initial post is actually supporting much of
what I was arguing. You have focused on my use of terms and pretty much totally
ignored the basic thrust of what I was saying. This is very close to what I was
trying to express as my observation of arguements in c.l.l - threads seem to
often get bogged down on minor and less relevant points rather than the main
theme/point. Much of your response concentrated on my use of terms, such as
smart, elegant, etc. You have not addressed my main points concerning why the
same sort of threads are so frequently repeated and never actually move forward
to any real extent or my hypothesis on c.l.l readers generally possessing a
stronger theoretical grasp than is apparent in other language groups and that
this stronger theoretical perspective results in debates getting bogged down on
narrow theoretical points at the expense of broader, more pragmatic practicle
applications of the language.
Obviously, if I want you and others to get the main point, I have to be far
more careful about the terminology and phrasing I use. However, this in itself
says something about this group compared to other groups where debate tends to
address the main themes and ignore less relevant aspects of terminology and
language use. The problem with this is it means having to spend a lot more
effort in actually formulating what I'm trying to express - having to write in
a far more defensive manner and anticipate the many ways
I can be misread. While this is possibly a good thing on one level as it
will make expression more precise, it will tend to discourage people from
expressing ideas because of the extra time and effort required. At the same
time, it could be argued this would be a good thing as content quality would be
higher. I guess we need to find a middle ground or accept its the Internet and
live with huge variation in content quality!
Tim
--
tcross (at) rapttech dot com dot au
On Mar 9, 5:20 am, Tim X <····@nospam.dev.null> wrote:
> "Juan R." <··············@canonicalscience.com> writes:
>
> > On Feb 11, 9:19 am, Tim X <····@nospam.dev.null> wrote:
> >> to some extent, I suspect one significant reason we (the lisp user community)
> >> has problems getting increased acceptance/support from the IT community is
> >> because we have too many smart users with strong theoretical grounding.
> >
> > Personally, I do not call smart one able to understand most advanced
> > theoretical framework but one is able to use the correct framework for
> > specific problems.
> >
>
> I did not say that smart meant only being able to understand theoretical
> frameworks - notice the *and* in the sentence.
Cannot notice it because I find zero 'ands' in the sentence.
> However, since you want to link
> the two I would only ask how do you know what is the best framework if you
> don't understand those which are available?
I said "correct framework". Yes I agree, choosing implies knowledge of
options.
> Surely understanding of the
> theory underlying the different systems is an important component in making the
> decision on which to use (I've never seen anyone select a tool for a job when
> they don't understand that tool. People tend to choose to use what they
> understand even if it isn't the best tool available).
>
>
> >> I sometimes wonder if we do get caught up in the small (but
> >> important) details and miss the big picture and whether we would be better off
> >> adopting a more pragmatic "full speed ahead and damn the torpedoes" attitude
> >> and what that would cost in the long run.
> >
> > A physicist using quantum gravity for falling apples would be
> > considered a bad physicist. Classical newtonian theory _is_ enough
> > there. It is not pragmatism, it is science. Same may be applied to
> > LISP community to TeX or to any other community claiming smartness...
> >
>
> I think you completely missed my point here. I was refering to the the frequent
> debates in this group regarding making changes or additions to the standard
> language which people argue would make it more widely accepted as a tool. I'm
> suggesting that it could be argued the reason there is little change in the
> status quo for lisp is because we cannot get consensus and the reason we cannot
> get consensus is that we get caught up on debating too many little things,
> which theoretically may have a detramental impact on the power of the language
> as a tool when this theoretical negative impact only affects a small subset of
> the problems commonly addressed. . I'm asking if there is possibly a case for
> arguing that doing something which theoretically makes a particular use of the
> language to solve a specific type of problem more difficult or less elegant
> could be justified if it also makes other things easier to do when those other
> things represent the more common types of problems and those areas which will
> be made more difficult or have a less elegant solution are rare. The pragmatism
> I'm referring to relates to whether we want a language which at one extreme is
> theoretically pure and at the other extreme a language which sacrifices some of
> its purity in order to facilitate its use to solve more common and often more
> trivial problems in order to broaden the languages acceptance. Note that I'm
> not arguing for one over the other, but rather asking the question to see if
> others have similar thoughts regarding the process (not the outcome).
And my discourse continue to be the same. It is not pragmatism the use
of tools corresponding to the level of the problem and your
"theoretically pure" and "purity" are not absolute terms.
> My question is based on the observations of debates in this group compared to
> other language groups, such as python and java. In this group, anybody who
> raises the question of changes to the CL standard or proposes libraries for
> addition into as a standard library often creates a debate that ends up in
> debates around theoretical advantages/disadvantages. In other groups, the
> debates end up focusing on more pragmatic points concerning the application in
> real-world common problems. In these other groups, theoretical issues seem less
> common and I often get the impression the arguments are based more on limited
> practicle experience of using the language rather than broader theoretical
> points.
As said failure of LISP to become popular is because is not designed
for _usage_ as others more popular languages. Sometimes LISP community
appears to be designed for (a guy said in another context) "mental
masturbation".
> Note also that I am not arguing for change to CL or believe anything needs
> 'fixing'. If anything, my points are really just a musing on the differences in
> debate/arguement in this group compared to toher language groups and some
> theorising as to why frequently repeated threads on what needs to change in CL
> never reach any solid conclusion, but reoccur with such frequency.
>
>
> >> It is possible part of the problem here is that lisp is so powerful and one of
> >> the few languages which is able to adapt to the complexities of the real world
> >> with such ease and elegance.
> >
> > Are not both relative concepts?
> >
>
> You can call them relative or you could call them qualitative or whatever tag
> you want to assign. I can't see what your point is or what relevance your
> question has to the point I was trying to make. Of course, this may have been
> clearer if you hadn't actually cut out the actual meat of the paragraph. It
> seems to me you are debating my choice of terms rather than the thrust of what
> I was saying.
It is much simpler. I remembered you that "powerful", "ease", and
"elegance" are relative concepts, which introduce doubts on the basis
of your discourse.
Maybe reason LISP was not more used is not your ruminations about
groups sociology but LISP is not so powerful, is not ease, and is not
elegant as you claimed. No?
I know chemists claiming Fortran and C to be more powerful than LISP.
I know biologists saying that Python is easier than LISP and I know
theoreticians claiming their favorite academic language to be more
elegant than LISP (specially CL).
> >> While I'd love to be using lisp at work, I'm skeptical we will ever see it as
> >> one of the maintstream development platforms. However, i have a similar
> >> attitude to this as to the development of GNU linux as a mainstream operating
> >> system. While I like both a lot and think they should have wider acceptance
> >> than they do, I don't really care if they don't. I'm pleased I have lisp to
> >> code with and I'm pleased I have GNU Linux, but if the rest of the world cannot
> >> see the advantages, well, thats their loss and I'd rather keep things as they
> >> are than sacrifice power, elegance or reliability simply to see increased
> >> popularity.
> >
> > This is the traditional but flawed attitude towards LISP. Advantages
> > are relative also. I know scientists using Linux when they need some
> > Linux advantage and using Windows when needing some Windows advantage
> > and using Mac also. Why do you believe that professor X has three
> > machines, one with XP, other with some Linux and a third one with a
> > SGI SO? If Linux were the only one needed, then he would forgot other
> > machines (specially the very expensive SGI WS).
> >
>
> Funny, my point was that I don't actually care if people want to use another
> language, another platform or a pointed stick. What I was trying to get across
> (and obviously failed) was that I really don't care about what others use. The
> current situation with CL (and GNU/Linux) meets my needs and I have no great
> desire to convert the whole world to using CL and GNU/Linux. I have no desire
> to be an evangelist for either a language or a platform and am quite willing to
> accept that others may not find them as useful as I do - they meet my needs and
> really thats all I care about.
That was not my point. I directly critized your "but if the rest of
the world cannot see the advantages, well, thats their loss and I'd
rather keep things as they are than sacrifice power, elegance or
reliability simply to see increased popularity."
Which is (I remark again) the typical but wrong attitude about the
social issue of LISP. I will be more clear. LISP is not more popular
or used because the rest of the world is blinded and cannot see
advantages. Other languages are not more popular because sacrificing
power, elegance, or reliability.
LISP have failed to become popular is because its built-in definitions
for "power", "elegance", or "reliability" are not absolute and do not
apply outside of LISP community and kind of tasks are more popular in
LISP.
> I was actually trying to address the common threads which pop up in this group
> concerning what needs to be done to get CL to take over the world. My point is
> that I think this is irrelevant. I don't understand why just because somone
> finds something they really like they then seem to have this drive to convert
> the rest of the world to using it. Its fine to tell people how wonderful you
> think something is, but why do so many feel that it has to go yet another step
> and convert everyone to their point of view?
Being popular is not irrelevant and implies better development of a
tool and optimization of resources.
> >> If the rest of the industry is to be convinced regarding the
> >> superiority of lisp, then someone had better come up with the goods.
> >
> > As remarked, there is not such one "superiority" in absolute terms.
>
> I'm not the one arguing there is. I'm merely saying to those who ask the
> question why CL, if its so great/superior, isn't more popular than Java,
> Python, Ruby etc, that part of what they would need to show is more clearly
> seen success stories in a similar vain to the argued successes of these other
> more widely accepted languages.
>
> >
> >> All business cares about is that the application
> >> solves the problem and does it today - it doesn't matter if its slow, requires
> >> more processing power, storage or maintenance, it just needs to solve the
> >> problem. Its efficiency, elegance or probable usable life is irrelevant udner
> >> todays management paradigm - just as long as its here today and words to
> >> address the problem now is all that matters.
> >
> > Again you focuse on relative points. Maybe you call elegant is to be
> > considered an ugly solution from other perspective. How many times i
> > heard that LISP recursive posibilities to computing factorials are
> > elegant? How many times i said, from my perspective, it is a very ugly
> > solution?
> >
>
> Are you kidding! I said the opposite. Are you so intent on arguing that you
> cannot even read clearly? I mean, what in "Its efficiency, elegance or probable
> usable life is irrelevant.." leads you to say that I'm focusing on relative
> points - do you not understand the meaning of irrelevant?
I did not said if efficiency, elegance or probable usable life are
irrelevant (or are not) under today management paradigm. I critized
was your (apparent to me) emphasis on that LISP ***was*** efficient,
elegant or with large usable life, which I will emphasize again is a
relative (debatable) discourse.
You appear to try to convince LISP community that traditional group
emphasis on efficiency, elegance... of LISP is of no practical utility
to convince managers to use more LISP. I did not discuss about that. I
replied that your evaluation of LISP (as being powerful, elegant...)
is rather debatable. And I extended that by saiying that probably
reason other languages are more popular is because fit better neeeds.
Ok?
> >> Like other aspects of modern
> >> society, form is often sacrificed for function - look at all the ugly houses
> >> built today.
> >
> > And why would be not form sacrified? Because you consider so?
> >
> > I can live with people thinking form is more important. I can live
> > with people thinking function is more important. I can also live with
> > people thinking both are important. That I find rather disturbing is
> > the tendency of some subset of LISP community to force others to
> > accept their own views as the only one acceptable views. Maybe you
> > call "ugly houses" are beatiful for others. Are you asked?
> >
>
> I can certainly accept that form, elegance etc are relative (beauty in the eye
> of the beholder and all that). However, there is generally a level of majority
> consensus whith such concepts.
But "majority consensus" does not transform relative points in
absolute ones.
> Although these can be culturally bound and there
> will always be hotly debated edge cases, there does tend to be considerable
> consensus on asthetics and elegance. There are plenty of examples of code which
> the majority of people would look at and say "Wow, thats elegant" and code
> which the majority will look at and say "Wow, thats inelegant". Likewise, there
> are houses/buildings which the majority would look at and agree have a pleasing
> and asthetic form and other houses/building which the majority would call ugly
> or lacking in asthetics. I wold even agree that often new ways of doing things
> are initially viewed as ugly or inelegant and that it often takes time for the
> majority to learn to appreciate more subtle aspects of unfamiliar designs etc.
> At no time have I asserted that my opinion is or should be the only correct one
> and nor have I claimed I'm talking in absolutes.
You just wrote "look at all the ugly houses built today" and in no
part of your posts you emphasized that 'ugly' was a personal opinion.
> However, my experience, based
> on observations, discussions with others, following debates etc leads me to
> believe there is a high level of consensus out there that in the modern world,
> asthetics, elegance and form is too often sacrificed in favor of obtaining
> function and a lower economic cost. Just because a concept deals in relative
> terms rather than absolute 'black and white' doesn't mean you cannot use it or
> build arguments that reference it. It is these grey areas where debate arises -
> its what makes things interesting.
>
> In some ways, your response to my initial post is actually supporting much of
> what I was arguing.
I do not agree.
> You have focused on my use of terms and pretty much totally
> ignored the basic thrust of what I was saying.
You began from a description of LISP (like being powerful, elegant...)
and then moved to serie of statements about popularity.
I directly critized your description with the aim to emphasize in this
newsgroup that maybe LISP was not more popular because is ***not***
more powerful, elegant, or ease to use that competitors.
·······@gmail.com wrote:
> On Feb 6, 11:09 pm, Pascal Costanza <····@p-cos.net> wrote:
>> Things are currently going in a pretty interesting direction. Now that
>> Steve Jobs, the boss of a major IT company, has stated that Java is not
>> interesting anymore
>
> Major IT company. Hmm...
The fact that I haven't mentioned the name of Steve Job's company and
that everyone knows which company it is anyway makes it major in my
book. The important part here is the impact that such a statement can
have...
> Anyway, he said that a Java plug-in for a web browser on a cell phone
> isn't needed, because Java for websites isn't that interesting
> anymore. That's a /bit/ different from what you wrote above, isn't
> it? Maybe you should work as a spin doctor for Dubya... :)
Everybody can read for themselves what he said:
http://pogue.blogs.nytimes.com/2007/01/13/ultimate-iphone-faqs-list-part-2/
Pascal
--
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
Am 06.02.2007 23:09 Uhr schrieb "Pascal Costanza" unter <··@p-cos.net> in
···············@mid.individual.net:
> Ken Tilton wrote:
>>
>>
>> Bill Atkins wrote:
>>> This article on Lisp appeared today on IBM's DeveloperWorks (link via
>>> Richard Cook):
>>>
>>> http://www-128.ibm.com/developerworks/java/library/j-cb02067.html
>>>
>>> I suppose any publicity is good publicity, but the article is pretty
>>> disappointing. It disregards the most important features of Lisp to
>>> focus on exciting things like defining functions and using recursion.
>>
>> Lessee, Bruce Tate, author of "Beyond Java", climbs onto an IBM Java
>> developers' site and in an article entitled "The Beauty of Lisp" says
>> "This 48-year-old language comes with incredible power and flexibility
>> that the Java language can't begin to match." and concludes "But if you
>> dig a little bit, you'll find an incredibly powerful language with
>> higher abstractions that are as valid and productive today as when they
>> were created 50 years ago. Many more-modern languages borrow from Lisp,
>> and most still do not provide as much power. If Lisp had a fraction of
>> the marketing behind Java or .NET and similar mindshare across
>> universities, we might well all be writing it right now."
>>
>> And we deem this disappointing? Hmmm...
>
> Kenny is right. It's a good sign that such articles get posted, and it's
> a better idea to start from that point of view. (For example, you can
> link to that article, but mention links to more current resources...)
>
> Things are currently going in a pretty interesting direction. Now that
> Steve Jobs, the boss of a major IT company, has stated that Java is not
> interesting anymore,
Steve Jobs said something like that in the context of talking about a mobile
phone. Apple is still providing new Java versions on Mac OS X.
Though they are no longer developing the Java to Cocoa bridge.
> we can expect more players to jump on that
> bandwagon. The fact that an article connected to IBM, another major IT
> company, mentions (no wait, the whole article is about) Lisp is another
> good sign. Things are moving...
>
>
> Pascal
Rainer Joswig wrote:
> Am 06.02.2007 23:09 Uhr schrieb "Pascal Costanza" unter <··@p-cos.net> in
> ···············@mid.individual.net:
>
>> Things are currently going in a pretty interesting direction. Now that
>> Steve Jobs, the boss of a major IT company, has stated that Java is not
>> interesting anymore,
>
> Steve Jobs said something like that in the context of talking about a mobile
> phone. Apple is still providing new Java versions on Mac OS X.
> Though they are no longer developing the Java to Cocoa bridge.
Of course, it would be unreasonable to drop support for Java on OS X.
Otherwise, a lot of "legacy" apps would suddenly not work anymore.
This doesn't say anything about new apps, though.
Pascal
--
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
Pascal Costanza <··@p-cos.net> writes:
> Rainer Joswig wrote:
>> Am 06.02.2007 23:09 Uhr schrieb "Pascal Costanza" unter <··@p-cos.net> in
>> ···············@mid.individual.net:
>>
>>> Things are currently going in a pretty interesting direction. Now that
>>> Steve Jobs, the boss of a major IT company, has stated that Java is not
>>> interesting anymore,
>>
>> Steve Jobs said something like that in the context of talking about a mobile
>> phone. Apple is still providing new Java versions on Mac OS X.
>> Though they are no longer developing the Java to Cocoa bridge.
>
> Of course, it would be unreasonable to drop support for Java on OS X.
> Otherwise, a lot of "legacy" apps would suddenly not work anymore.
>
> This doesn't say anything about new apps, though.
>
Its great that there seems to be some growing "reality" awareness regarding
Java in the industry (it reminds me of the end of the AI trend in the late 80's
early 90's - after huge amounts of investment, little seemed to be delivered).
With java, after a huge amount of investment, there is growing concern
regarding how bloody frustrating maintaining production systems is. While Java
may appear nice for developers (especially because of the wealth of libraries
out there), sys admins hate it. However, given the amount of investment that
has been put in, I wouldn't expect to see it disappear too quickly. The fact
sun is now releasing it as GPL'd open source may even prolong its existence a
ibt.
There does seem to be some growing support for Lisp, but the resistance (based
on mainly FUD) amongst those controlling the purse strings is still very high. I
suspect we are more likely to see a trend towards something like ruby before
lisp gains any real traction and thats mainly because of the fact ruby doesn't
have 50 years of FUD to dispel and because of the positive press regarding
rails (backed up by some good success stories, such as basecamp).
Where I work, I did a simple but useful little web app in lisp and showed it as
an example of what we could do with lisp. I wasn't able to get any real
traction and had to deal with attitudes like "lisp is old", "lisp is for AI"
and "lets see you deal with a non-functional problem with lisp" etc etc.
Despite being able to address all these options and even after getting a couple
of the better developers to try it (and they liked it!), I still couldn't get
management to take the issue seriously. When I did almost exactly the same
thing with a Ruby and rails solution, the differences in attitude and response
was quite a surprise.
Of course, I still couldn't get any traction. Those who understood the issues
and who had the knowledge to appreciate the technical and productivity issues
were more supportive, but not prepared to put themselves on the line and
support me. Those who could make the decision didn't understand the basic
issues we are faced with and couldn't appreciate the benefits of either lisp or
ruby. More of the cliche about IT being full of two types of people - those who
don't manage what they understand and others who manage what they don't
understand.
God save us from pointy haired bosses and ignorant venture capitalists who
won't trust in the experts they are investing with!
Tim
--
tcross (at) rapttech dot com dot au
Ken Tilton wrote:
> And we deem this disappointing? Hmmm...
The article is not too bad, but the problem is that it has bugs. At the
bottom of the page it is possible to send comments and I've remarked the
inappropriate usage of the macro (and gave a while-macro example), the setf
and quoting error in listing 10, the unusual naming convention used in the
article (underscore instead of minus) and the non-Lisp like code indention
and formatting. The rest is ok :-)
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
On Feb 7, 8:31 pm, Frank Buss <····@frank-buss.de> wrote:
> Ken Tilton wrote:
> > And we deem this disappointing? Hmmm...
>
> The article is not too bad, but the problem is that it has bugs. At the
> bottom of the page it is possible to send comments and I've remarked the
> inappropriate usage of the macro (and gave a while-macro example), the setf
> and quoting error in listing 10, the unusual naming convention used in the
> article (underscore instead of minus) and the non-Lisp like code indention
> and formatting. The rest is ok :-)
>
> --
> Frank Buss, ····@frank-buss.dehttp://www.frank-buss.de,http://www.it4-systems.de
The article looked like an uninspired rush job. He just banged out
five hundred words, apparently without even using the language.
And frankly I'm not sure that pointing people towards an currently
unmaintained port of the language with broken code is the publicity
lisp needs.
Bill Atkins <················@not-a-real-domain.com> wrote:
+---------------
| >(times_two a)
| 8
|
| This is a pretty poor use of a macro, but it's certainly interesting
| that he was able to convince his Lisp implementation (GCL, according to
| the article) to produce that output.
+---------------
Yeah, especially since GCL *should* have blown up, the way (say) CMUCL
does, complaining about trying to multiply the *symbol* A by two:
cmu> (times_two a)
Error: Argument Y is not a NUMBER: A.
Backtrace:
0: (DEBUG:BACKTRACE 8 #<Synonym Stream to *TERMINAL-IO*>)
1: (MY-DEBUGGER-HOOK #<SIMPLE-TYPE-ERROR {5894FD8D}> #<unused-arg>)
2: (INVOKE-DEBUGGER #<SIMPLE-TYPE-ERROR {5894FD8D}>)
3: (ERROR SIMPLE-TYPE-ERROR :DATUM A :EXPECTED-TYPE ...)
4: (KERNEL:TWO-ARG-* 2 A)
5: (* 2 A)
6: (MACROEXPAND-1 (TIMES_TWO A) NIL)
7: (MACROEXPAND (TIMES_TWO A) NIL)
...
-Rob
-----
Rob Warnock <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
On Feb 7, 3:27 am, ····@rpw3.org (Rob Warnock) wrote:
> Yeah, especially since GCL *should* have blown up, the way (say) CMUCL
> does, complaining about trying to multiply the *symbol* A by two:
It gets worse,
(setf total '(lambda (a b) (+ a b)))
(apply total '(101 102))
is undefined behavior and will drop you into the debugger in SBCL,
clisp & lispworks.
It's bad enough only showing the most basic of lisp constructs
but getting something wrong is really not going to help.
sean
On 7 Feb, 11:13, "sross" <······@gmail.com> wrote:
> It gets worse,
>
> (setf total '(lambda (a b) (+ a b)))
> (apply total '(101 102))
and worse,
............ and (* 1 2 3 4) returns 12.
Jon G.
"sross" <······@gmail.com> writes:
> On Feb 7, 3:27 am, ····@rpw3.org (Rob Warnock) wrote:
>> Yeah, especially since GCL *should* have blown up, the way (say) CMUCL
>> does, complaining about trying to multiply the *symbol* A by two:
>
> It gets worse,
>
> (setf total '(lambda (a b) (+ a b)))
> (apply total '(101 102))
>
> is undefined behavior and will drop you into the debugger in SBCL,
> clisp & lispworks.
No. It's an error in all conforming Common Lisp implementations.
A list is not a function!
BUT it is valid LISP ; for example, emacs lisp accepts it with no
problem, since in emacs lisp lists that start with the symbol lambda
are functions.
#+common-lisp (functionp '(lambda (a b) (+ a b))) --> NIL
#+emacs (functionp '(lambda (a b) (+ a b))) --> t
> It's bad enough only showing the most basic of lisp constructs
> but getting something wrong is really not going to help.
It's only that the author didn't update his lisp knowledge since
before 1992.
--
__Pascal Bourguignon__ http://www.informatimago.com/
"You can tell the Lisp programmers. They have pockets full of punch
cards with close parentheses on them." --> http://tinyurl.com/8ubpf
On Feb 7, 11:36 am, Pascal Bourguignon <····@informatimago.com> wrote:
> No. It's an error in all conforming Common Lisp implementations.
> A list is not a function!
Yes, which is why I read it as undefined behavior (going on CLHS
1.4.4.3),
> BUT it is valid LISP ; for example, emacs lisp accepts it with no
> problem, since in emacs lisp lists that start with the symbol lambda
> are functions.
Fair enough, it is valid LISP and that would make me feel better, if
he
didn't direct people to Common Lisp implementations.
I'd say the confusion stems from the 'Learning Lisp' primer that he
mentions in the resources section, which uses exactly the same method
of function application (although that purports to be an introduction
to CL
as well).
Sean.
Had anyone thought about contacting developerworks and writing a
better article?
On Feb 7, 5:36 am, Pascal Bourguignon <····@informatimago.com> wrote:
> "sross" <······@gmail.com> writes:
> > On Feb 7, 3:27 am, ····@rpw3.org (Rob Warnock) wrote:
> >> Yeah, especially since GCL *should* have blown up, the way (say) CMUCL
> >> does, complaining about trying to multiply the *symbol* A by two:
>
> > It gets worse,
>
> > (setf total '(lambda (a b) (+ a b)))
> > (apply total '(101 102))
>
> > is undefined behavior and will drop you into the debugger in SBCL,
> > clisp & lispworks.
>
> No. It's an error in all conforming Common Lisp implementations.
> A list is not a function!
>
> BUT it is valid LISP ; for example, emacs lisp accepts it with no
> problem, since in emacs lisp lists that start with the symbol lambda
> are functions.
>
> #+common-lisp (functionp '(lambda (a b) (+ a b))) --> NIL
> #+emacs (functionp '(lambda (a b) (+ a b))) --> t
>
> > It's bad enough only showing the most basic of lisp constructs
> > but getting something wrong is really not going to help.
>
> It's only that the author didn't update his lisp knowledge since
> before 1992.
>
> --
> __Pascal Bourguignon__ http://www.informatimago.com/
>
> "You can tell the Lisp programmers. They have pockets full of punch
> cards with close parentheses on them." -->http://tinyurl.com/8ubpf
·············@gmail.com wrote:
> Had anyone thought about contacting developerworks and writing a
> better article?
That will be well-received, and when Anna Kournikova sends you an email
asking you to come spend a week with her you complain that she
misspelled Tahiti and the airline tickets she sent were not first-class
and write back asking if she knows anyone prettier you could stay with?
<sigh>
kenneth
--
Well, I've wrestled with reality for 35 years, Doctor, and
I'm happy to state I finally won out over it.
-- Elwood P. Dowd
In this world, you must be oh so smart or oh so pleasant.
-- Elwood's Mom
Ken Tilton wrote:
>
>
> ·············@gmail.com wrote:
>> Had anyone thought about contacting developerworks and writing a
>> better article?
>
> That will be well-received, and when Anna Kournikova sends you an email
> asking you to come spend a week with her you complain that she
> misspelled Tahiti and the airline tickets she sent were not first-class
> and write back asking if she knows anyone prettier you could stay with?
>
> <sigh>
Like maybe could she ask Maria Sharapova? (dreamy) sigh....
·············@gmail.com wrote:
> Had anyone thought about contacting developerworks and writing a
> better article?
Good idea. A good start would be to prove the statement
| This 48-year-old language comes with incredible power and flexibility that
| the Java language can't begin to match
to correct the statement
| Everything in Lisp, from data to the code making up your application, is a
| list.
and to correct the setf error.
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
Bill Atkins wrote:
> This article on Lisp appeared today on IBM's DeveloperWorks (link via
> Richard Cook):
>
> http://www-128.ibm.com/developerworks/java/library/j-cb02067.html
This looks a bit like my first try in Lisp, many years ago, when I wrote a
small tutorial for Lisp. I deleted it when I discovered Lisp again :-)
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
On Tue, 06 Feb 2007 15:49:54 -0500, Bill Atkins <················@not-a-real-domain.com> wrote:
> This article on Lisp appeared today on IBM's DeveloperWorks (link via
> Richard Cook):
>
> http://www-128.ibm.com/developerworks/java/library/j-cb02067.html
>
> I suppose any publicity is good publicity, but the article is pretty
> disappointing. It disregards the most important features of Lisp to
> focus on exciting things like defining functions and using recursion.
>
> Macros get two paragraphs and one bizarre code snippet:
>
>>(defmacro times_two (x) (* 2 x))
> TIMES_TWO
>
>> (setf a 4)
> 4
>
>> (times_two a)
> 8
>
> This is a pretty poor use of a macro, but it's certainly interesting
> that he was able to convince his Lisp implementation (GCL, according
> to the article) to produce that output.
Agreed. Something like a macro-ized version of WHILE, would be a better
example of how macros can be used to extend the language in arbitrary
ways -- even to the point of adding new features, which work fine as
integrated parts of the 'new' language, seamlessly fitting with the rest
of Lisp.
Let's not be ungrateful though, the article can be read in a very very
positive way.
Bill Atkins <················@not-a-real-domain.com> writes:
> This article on Lisp appeared today on IBM's DeveloperWorks (link via
> Richard Cook):
>
> http://www-128.ibm.com/developerworks/java/library/j-cb02067.html
>
> I suppose any publicity is good publicity, but the article is pretty
> disappointing. It disregards the most important features of Lisp to
> focus on exciting things like defining functions and using
> recursion.
>
> Macros get two paragraphs and one bizarre code snippet:
>
>>(defmacro times_two (x) (* 2 x))
> TIMES_TWO
>
>>(setf a 4)
> 4
>
>>(times_two a)
> 8
>
> This is a pretty poor use of a macro, but it's certainly interesting
> that he was able to convince his Lisp implementation (GCL, according
> to the article) to produce that output.
Hmmm, I just looked at the article and despite a mention of macros in
the first paragraph, this broken example seems to have been removed
along with any other mention of macros. Too bad they didn't replace it
with a reasonable macro example. Oh well. If anyone actually wants to
know why, "This 48-year-old language comes with incredible power and
flexibility that the Java language can't begin to match" there's a
good Lisp book I can recommend. ;-)
-Peter
Peter Seibel wrote:
> Hmmm, I just looked at the article and despite a mention of macros in
> the first paragraph, this broken example seems to have been removed
> along with any other mention of macros.
But there is still the broken listing 10 and the non-Lisp-like code
formatting in listing 7 and 8, and terrible indention in listing 9. But I
guess the article wouldn't have any examples any more, if they remove this
too :-)
--
Frank Buss, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de