What if it's really just sour grapes?
To people who know and use Lisp, it seems easy to learn. But what if
it's actually not easy at all for the average programmer to learn it?
Different minds, different learning styles, might find some particular
subject matter many times easier to learn than others. If two English
speakers, A and B, know no other languages than English, A might learn
Spanish twice as fast as B, and B might learn German twice as fast as
A. There might be differences in their mindsets, learning styles,
etc., which make it easier to learn one language than another. The
same phenomenon might make A learn Lisp 10 times faster than B, and B
learn something else 10 times faster than A.
What if only a small fraction of those who attempt to learn Lisp
actually learn it, and the others give up after finding it hard to
learn? Those who learn it might not understand how it could be
difficult, and might think those who don't learn it are just lazy.
One can learn Lisp just well enough to be able to write some simple
programs in it, without actually learning it enough to really
appreciate it or make good use of it. What if that's where the vast
majority of Lisp learners actually are? They could have sour grapes
about Lisp. They could have a faint hint that there is something
there beyond their grasp, but see it from a sour grapes point of view.
I.e., to them it might seem to be not worth their time, "because the
grapes are probably sour."
But from the point of view of those who have never even attempted to
learn Lisp, the sour grapes person might seem like a Lisp expert, from
having actually learned a small amount of Lisp and written some simple
programs in it.
What if, for every sour grapes Lisp person, there are 10 other people
who have formed their opinions of Lisp by listening to the sour grapes
person? And for each of those 10 others, 10 others who have formed
their opinions from listening to that 2nd hand sour grapes opinion?
If this turns out to be a real reason for Lisp's lack of popularity
among the masses, it might also help explain Java's popularity. What
if enough people actually learn Java well enough to make good use of
it, that the masses who don't know or use Java get a 2nd hand "sweet
grapes" opinion of it, and are thereby motivated to learn it?
--
(do((x(coerce "iukd9/.-<`[kl_b^b^ _Uc"
'list)(cdr x)))((not x))(princ (code-char
(- (char-code (car x)) -18 (length x)))))
To borrow an analogy used by Neil Stephenson in is extended essay "In
the Beginning there was the command line" compares a powerful dangerous
hardware tool with a simple store bought one. With the professional
tool you have the power to do difficult jobs that the simple tool could
not do, yet you need skill and ability to use it.
Most programmers are working on simple daily problems that have been
solved hundreds of times already. The appropriate thing is to use the
simplest tool that does the job.
Visual Basic, Java, Python are all succesful because they simplify down
to the level of power required to do a certain job. They are also not
ideal languages for solving difficult programming problems.
Justin
I don't think above average skill or intelligence is required to learn
and get Lisp. Prior experience with other languages can be an
impediment. So can discouragement from your peers. But if you put
the effort in anyway, the grapes taste sweeter when you get them.
--
http://www.david-steuber.com/
The UnBlog | Lisp on OS X topics for the most part
Click all the links you want. I'll make more!
A non-programming friend asked me to teach her programming recently, so
I got her to download lispworks and started her on lisp (after 3 days
she had digested recursive functions, which blows me away). One of her
friends, who is a cs graduate, warned her off lisp, saying it was
"horrible". When I asked her what she meant, she asked "what can you do
with it? it doesn't do anything, it's just maths" etc.
I think this is the reason most programmers don't take to common lisp.
It doesn't do very much out of the box. You have to be very motivated
to get it to do anything useful, like interacting with the rest of your
computer, or other computers out there in the world.
I know this was a stumbling block for me. Luckily I had absorbed enough
of the pro-lisp hype (thanks paul graham + c.l.l) to know that I wanted
to make it work. But for people who have already got guis running in
java, or a web app in ruby, it must seem like a lot of work.
From: Peter Seibel
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m2psqvolm9.fsf@gigamonkeys.com>
···············@gmail.com" <··············@gmail.com> writes:
> A non-programming friend asked me to teach her programming recently, so
> I got her to download lispworks and started her on lisp (after 3 days
> she had digested recursive functions, which blows me away). One of her
> friends, who is a cs graduate, warned her off lisp, saying it was
> "horrible". When I asked her what she meant, she asked "what can you do
> with it? it doesn't do anything, it's just maths" etc.
> I think this is the reason most programmers don't take to common lisp.
> It doesn't do very much out of the box. You have to be very motivated
> to get it to do anything useful, like interacting with the rest of your
> computer, or other computers out there in the world.
Just motivated enough to take a look at:
<http://www.gigamonkeys.com/book/>
which was designed to help folks like your CS grad friend see that
there's more to Lisp than they think.
-Peter
P.S. Sorry for the self promotion but that friend is *exactly* the
kind of person I wrote the book for.
--
Peter Seibel * ·····@gigamonkeys.com
Gigamonkeys Consulting * http://www.gigamonkeys.com/
Practical Common Lisp * http://www.gigamonkeys.com/book/
Peter Seibel <·····@gigamonkeys.com> wrote:
> ···············@gmail.com" <··············@gmail.com> writes:
>
> > A non-programming friend asked me to teach her programming recently, so
> > I got her to download lispworks and started her on lisp (after 3 days
> > she had digested recursive functions, which blows me away). One of her
> > friends, who is a cs graduate, warned her off lisp, saying it was
> > "horrible". When I asked her what she meant, she asked "what can you do
> > with it? it doesn't do anything, it's just maths" etc.
> > I think this is the reason most programmers don't take to common lisp.
> > It doesn't do very much out of the box. You have to be very motivated
> > to get it to do anything useful, like interacting with the rest of your
> > computer, or other computers out there in the world.
>
> Just motivated enough to take a look at:
> <http://www.gigamonkeys.com/book/>
> which was designed to help folks like your CS grad friend see that
> there's more to Lisp than they think.
I just finished reading PCL, and unfortunately it misses on the one
aspect that probably hangs up more people than any other -- lack of
discussion about GUI development. It rates a bare mention in the last
chapter.
Admittedly, it's a hard problem, but it will need to be tackled if
anyone wants lisp to take over the world. Your book is great, but it
doesn't accomplish this.
I still haven't made the slog through figuring out how to program the
GUI on my mac or do sockets, etc. Everything I've written in CL has
been something that can be self-contained in the REPL. It is *so* much
easier working in lisp than in any other language, that I use it now for
anything that's just me farting around if I want something more
complicated than a spreadsheet.
But in other languages figuring out how to do very simple GUIs or
packages is explained in any starting documentation aimed at your
platform. I think I'm going to learn objective-C in order to get the
mac GUI down before I even consider trying to do standard apps in lisp,
because I'm not ready to invest in lispworks, adn it looks like
otherwise, I end up either with a non-standard interface or in FFI-hell.
I'm definitely not ripping on your book here. I realize that it's hard
to solve the GUI problem. The lisp market just isn't big enough to
restrict yourself to one GUI model, and trying to cover all of them
would take up a whole book in itself. I'm just pointing out that PCL is
not a panacea for this. After reading through it, and hacking CL for a
bit, I'm still pretty much at square one on how to make normal looking
apps with it.
Michael
············@spambegone.null (Michael Sullivan) writes:
> I just finished reading PCL, and unfortunately it misses on the one
> aspect that probably hangs up more people than any other -- lack of
> discussion about GUI development. It rates a bare mention in the last
> chapter.
One problem is that there's even less standardization in GUI than in
network stuff. On one platform you often have the choice between half
a dozen different GUI.
MacOSX: Carbon, Cocoa, X (times the numerous X toolkits).
Unix: X (times the numerous X toolkits).
MS-Windows: ?, X (times the numerous X toolkits).
And this is only what's proposed as more or less "language
independant" GUI, once you select some languages such as Java, Lisp or
Smalltalk, you add some more choices of GUI.
So even if we restrict yourself to Lisp, the choices in GUI is so
large, what GUI would you choose to treat in a general book? I'd
propose garnet, since it can be used on most CL implemenations on most
systems (since X servers exist on most systems).
Anyways, more and more, the user interface will be the browser. You
don't need to program GUI anymore, just output some X[HT]ML.
--
__Pascal Bourguignon__ http://www.informatimago.com/
Nobody can fix the economy. Nobody can be trusted with their finger
on the button. Nobody's perfect. VOTE FOR NOBODY.
I would add that Lisp looks totally different, which probably makes
them think it is harder than it is. There is also another problem: some
people think that things created long time ago are old and shouldn't or
even can't be used (see the "What's so great about Lisp" thread for an
example).
To see the power of this language and to be able to use it you have to
have a lot of motivation and/or a strong will.
Personally I'm just starting to learn Common-Lisp but even at the
beginning of my Lisp path I can do things impossible or much-too-hard
for users of other languages.
I would love to use Lisp at work (partly because I tend to make less
mistakes while writing CL) but I can't -- we do all of the development
in PHP, which I find very limiting and inflexible (compared to CL; no
macros, poor object-orientation until PHP5, etc.). But all of the code
written so far uses PHP and nothing will change until someone decides:
Ok, it's time to rewrite everything from scratch. And this will happen
probably never...
Regards,
pfm
Piotr Filip Mieszkowski wrote:
> Ok, it's time to rewrite everything from scratch. And this will happen
> probably never...
Actually, rewriting everything from scratch is happening right now if
the application's scope is growing significantly. That rewrite is just
not labelled as such.
Another way to bring in lisp is to generate large parts of the
rewritten code. This is one place where the ability to read
s-expressions really pays off. Yes, one can define a specialized
language and write a parser, but you can be generating code before
folks using that approach can agree on syntax, and you'll be done
before they get anything out of lex/yacc/pile of code.
This is often where the xml weenies pop up, but they think that beating
lex/yacc is a big deal.
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3psiovFbkeqnU1@individual.net>
Piotr Filip Mieszkowski wrote:
> I would love to use Lisp at work (partly because I tend to make less
> mistakes while writing CL) but I can't -- we do all of the development
> in PHP, which I find very limiting and inflexible (compared to CL; no
> macros, poor object-orientation until PHP5, etc.). But all of the code
> written so far uses PHP and nothing will change until someone decides:
> Ok, it's time to rewrite everything from scratch. And this will happen
> probably never...
There are ways to sneak in other languages if you don't do it openly.
For example, once some new functionality is needed you could offer to
"prototype" it, without saying what you use for prototyping. Or you
could develop something in your spare time, and offer it later on to
include it in your project.
Google also for LinJ for some further inspiration. ;)
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
> Google also for LinJ for some further inspiration. ;)
Thanks a lot but I don't think I'm ready to write LinP or something
like that.
What I'm thinking about is a CL software managing information about our
repository of ready-to-use components. Maybe Emacs could do that for
me, but I'd like to try the standalone approach.
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3pv2ccFccuelU1@individual.net>
Piotr Filip Mieszkowski wrote:
>>Google also for LinJ for some further inspiration. ;)
>
>
> Thanks a lot but I don't think I'm ready to write LinP or something
> like that.
>
> What I'm thinking about is a CL software managing information about our
> repository of ready-to-use components. Maybe Emacs could do that for
> me, but I'd like to try the standalone approach.
Yes, this sounds like a reasonable project.
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
I kept thinking in this subject, and got an 'idea' that can be one
reason for 'why lisp is not popular with average programmers'.
I think that we tend to categorize things in an easy way. I mean, we
like to 'order' the universe in 'little boxes' to better handle it. In
a naive categorization, I think that people could label the programming
languages like this:
Java: multiplatform
C: speed+unix
C++: OO
PHP: web apps
and so on.
Then, how do you think that lisp would be label? I bet:
lisp: AI+math.
Here's your reason. Or maybe one of them.
By the way, I would like to rant a little more about this:
> When I asked her what she meant, she asked "what can
> you do with it? it doesn't do anything, it's just maths" etc.
What exactly do people think when they say '*just* math'? ¿just? Do
you think that *that* is poor? Math is (almost) everything! There's so
much beauty in math... well, stop ranting :-)
From: Ulrich Hobelmann
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3pvgnuFcjarjU1@individual.net>
LuisGLopez wrote:
> I kept thinking in this subject, and got an 'idea' that can be one
> reason for 'why lisp is not popular with average programmers'.
>
> I think that we tend to categorize things in an easy way. I mean, we
> like to 'order' the universe in 'little boxes' to better handle it. In
> a naive categorization, I think that people could label the programming
> languages like this:
>
> Java: multiplatform
> C: speed+unix
> C++: OO
> PHP: web apps
Never mind that Lisp is more multiplatform than Java (ok, but it has no
binary standard format), more OO than C++, and is arguably better than
PHP for web page generation (html macros rule!), and decently fast.
What Java and PHP have is a packaged standard environment for web apps
(Tomcat and LAMP), so hobby programmers do better at just learning it.
The conventional syntax seems to help.
--
Do or do not. There is no try.
Yoda
"LuisGLopez" <············@gmail.com> writes:
> lisp: AI+math.
But then, why wouldn't they want to make all the application software AI?
I'm rather fed up with normal dump programs, and the more so with
normal dumb GUI programs. I'd rather have MORE AI in all software.
>> When I asked her what she meant, she asked "what can
>> you do with it? it doesn't do anything, it's just maths" etc.
>
> What exactly do people think when they say '*just* math'? �just? Do
> you think that *that* is poor? Math is (almost) everything! There's so
> much beauty in math... well, stop ranting :-)
Yes, most people don't get it.
--
__Pascal Bourguignon__ http://www.informatimago.com/
The world will now reboot. don't bother saving your artefacts.
(By the way, I want to make clear that I don't adhere to the naive
categorization I suggested before; I just think that that's what
happens in people's mind.)
Pascal Bourguignon ha escrito:
> But then, why wouldn't they want to make all the application software AI?
>
> I'm rather fed up with normal dump programs, and the more so with
> normal dumb GUI programs. I'd rather have MORE AI in all software.
>
Great point. But I think that people think in AI in a more
'conventional' way. I mean, 'talking machines' (2001, a space odissey),
and so on. Of course that your interpretation of AI would be more
useful in the everyday use of computers, but maybe nobody cares :-/
On Wed, 28 Sep 2005 05:58:25 -0700, LuisGLopez wrote:
> Great point. But I think that people think in AI in a more
> 'conventional' way. I mean, 'talking machines' (2001, a space odissey),
> and so on. Of course that your interpretation of AI would be more useful
> in the everyday use of computers, but maybe nobody cares :-/
Well we do have to be careful that it doesn't run amok, and try to rule
the world. That's the human's job. :)
LuisGLopez wrote:
>>When I asked her what she meant, she asked "what can
>>you do with it? it doesn't do anything, it's just maths" etc.
>
>
> What exactly do people think when they say '*just* math'? �just? Do
> you think that *that* is poor? Math is (almost) everything! There's so
> much beauty in math... well, stop ranting :-)
What she meant was probably something like "I looked over the
language spec once, and there was no way to open a window,
blit a bitmap, put up a menu, catch mouse input, handle my
scanner/printer/modem/audio driver, establish interrupt
handlers, handle sockets and IP communications... you know,
actually DOING the stuff people want software to DO."
The fact is that there are ways to do these things, but if
you are looking at the hyperspec (or virtually anywhere a
programmer might look to learn the language initially)
there are no pointers to any such ways. So people come
away with the impression that they don't exist.
Bear
From: Duane Rettig
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <47jcsh9sx.fsf@franz.com>
Ray Dillinger <····@sonic.net> writes:
> LuisGLopez wrote:
>
>>>When I asked her what she meant, she asked "what can
>>>you do with it? it doesn't do anything, it's just maths" etc.
>> What exactly do people think when they say '*just* math'? �just? Do
>> you think that *that* is poor? Math is (almost) everything! There's so
>> much beauty in math... well, stop ranting :-)
>
> What she meant was probably something like "I looked over the
> language spec once, and there was no way to open a window,
> blit a bitmap, put up a menu, catch mouse input, handle my
> scanner/printer/modem/audio driver, establish interrupt
> handlers, handle sockets and IP communications... you know,
> actually DOING the stuff people want software to DO."
>
> The fact is that there are ways to do these things, but if
> you are looking at the hyperspec (or virtually anywhere a
> programmer might look to learn the language initially)
> there are no pointers to any such ways. So people come
> away with the impression that they don't exist.
Don't know about that. If they find an IDE (which of course
we are constantly trying to direct people toward :-)...:
http://www.franz.com/downloads/trial.lhtml
and they get the Windows version, fire it up and run the tutorial,
there are all kinds of good stuff that has little to do with *just*
math. No, the only reason they get the impression that it
doesn't exist is that they _assume_ it doesn't exist.
--
Duane Rettig ·····@franz.com Franz Inc. http://www.franz.com/
555 12th St., Suite 1450 http://www.555citycenter.com/
Oakland, Ca. 94607 Phone: (510) 452-2000; Fax: (510) 452-0182
Duane Rettig wrote:
> Ray Dillinger <····@sonic.net> writes:
>>The fact is that there are ways to do these things, but if
>>you are looking at the hyperspec (or virtually anywhere a
>>programmer might look to learn the language initially)
>>there are no pointers to any such ways. So people come
>>away with the impression that they don't exist.
>
>
> Don't know about that. If they find an IDE (which of course
> we are constantly trying to direct people toward :-)...:
>
> http://www.franz.com/downloads/trial.lhtml
>
> and they get the Windows version, fire it up and run the tutorial,
> there are all kinds of good stuff that has little to do with *just*
> math. No, the only reason they get the impression that it
> doesn't exist is that they _assume_ it doesn't exist.
Yah, but that's *if* and *if* and *if*. When I started
scoping out common lisp, I had CLTL2 and the hyperspec.
These are standard references, and there wasn't *any*
hint of any ability to handle UI or hardware in either
one. I downloaded CMUCL and used it for several months
(using the "standard refs" as language documentation so
as to avoid implementation-dependent features and
nonportable code) without discovering any. Hell, around
month 4 I think *I'd* have believed that I/O other than
the REPL didn't exist in Lisp.
It's still kinda iffy; if you don't want to be stuck with
implementation-dependent, unportable code, you're really
sucking air if you want to do anything except the REPL.
Bear
From: Edi Weitz
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <ur7b0bam3.fsf@agharta.de>
On Wed, 05 Oct 2005 08:48:08 GMT, Ray Dillinger <····@sonic.net> wrote:
> Yah, but that's *if* and *if* and *if*. When I started scoping out
> common lisp, I had CLTL2 and the hyperspec. These are standard
> references, and there wasn't *any* hint of any ability to handle UI
> or hardware in either one. I downloaded CMUCL and used it for
> several months (using the "standard refs" as language documentation
> so as to avoid implementation-dependent features and nonportable
> code) without discovering any. Hell, around month 4 I think *I'd*
> have believed that I/O other than the REPL didn't exist in Lisp.
So it took you four months to discover the chapters about files and
streams in the HyperSpec?
> It's still kinda iffy; if you don't want to be stuck with
> implementation-dependent, unportable code, you're really sucking air
> if you want to do anything except the REPL.
FWIW, John Foderaro wrote the B-tree implementation that supports
AllegroCache (which replaced BerkeleyDB and turned out to be better
for this specific purpose) in pure, portable[*] Common Lisp. It can't
be /that/ bad...
Cheers,
Edi.
[*] Except for process locks which you only need if your Lisp /has/
multi-processing capabilities. See details at the end of this
page:
<http://wagerlabs.com/uptick/2005/08/lisp-is-pain-in-rear.html>
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
From: Björn Lindberg
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <4343dc70$1@news.cadence.com>
Edi Weitz wrote:
> On Wed, 05 Oct 2005 08:48:08 GMT, Ray Dillinger <····@sonic.net> wrote:
>
>
>>Yah, but that's *if* and *if* and *if*. When I started scoping out
>>common lisp, I had CLTL2 and the hyperspec. These are standard
>>references, and there wasn't *any* hint of any ability to handle UI
>>or hardware in either one. I downloaded CMUCL and used it for
>>several months (using the "standard refs" as language documentation
>>so as to avoid implementation-dependent features and nonportable
>>code) without discovering any. Hell, around month 4 I think *I'd*
>>have believed that I/O other than the REPL didn't exist in Lisp.
>
>
> So it took you four months to discover the chapters about files and
> streams in the HyperSpec?
>
>
>>It's still kinda iffy; if you don't want to be stuck with
>>implementation-dependent, unportable code, you're really sucking air
>>if you want to do anything except the REPL.
>
>
> FWIW, John Foderaro wrote the B-tree implementation that supports
> AllegroCache (which replaced BerkeleyDB and turned out to be better
> for this specific purpose) in pure, portable[*] Common Lisp. It can't
> be /that/ bad...
Oh, but did he use the IF* macro?
Bj�rn
:-)
Bj�rn Lindberg <·····@runa.se> writes:
> Edi Weitz wrote:
>
> > FWIW, John Foderaro wrote the B-tree implementation that supports
> > AllegroCache (which replaced BerkeleyDB and turned out to be better
> > for this specific purpose) in pure, portable[*] Common Lisp. It can't
> > be /that/ bad...
>
> Oh, but did he use the IF* macro?
>
> Bj�rn
>
> :-)
Geez Bj�rn, what do you think he meant by portable* ?
:-)
--
/|_ .-----------------------.
,' .\ / | Free Mumia Abu-Jamal! |
,--' _,' | Abolish the racist |
/ / | death penalty! |
( -. | `-----------------------'
| ) |
(`-. '--.)
`. )----'
From: Edi Weitz
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <ufyrgqcl6.fsf@agharta.de>
On Wed, 05 Oct 2005 16:00:16 +0200, Bj�rn Lindberg <·····@runa.se> wrote:
> Oh, but did he use the IF* macro?
Yes, unfortunately. (Yuk!) But at least it can be defined portably
as well.
Cheers,
Edi.
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
From: Bulent Murtezaoglu
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <87achocoo3.fsf@p4.internal>
>>>>> "RD" == Ray Dillinger <····@sonic.net> writes:
[...]
RD> Yah, but that's *if* and *if* and *if*. When I started
RD> scoping out common lisp, I had CLTL2 and the hyperspec. These
RD> are standard references, and there wasn't *any* hint of any
RD> ability to handle UI or hardware in either one. [...]
I had the same horrible experience with C/gcc, K&R, and man pages. I
was convinced it'd take incense, incantations and sacrifice of small
animals to put up a UI and talk to hw. Those and spirits. That
last bit I'd gathered from the 'volatile' they mentioned.
I am thinking I missed something upthread?
cheers,
BM
Bulent Murtezaoglu wrote:
>>>>>>"RD" == Ray Dillinger <····@sonic.net> writes:
>
> [...]
> RD> Yah, but that's *if* and *if* and *if*. When I started
> RD> scoping out common lisp, I had CLTL2 and the hyperspec. These
> RD> are standard references, and there wasn't *any* hint of any
> RD> ability to handle UI or hardware in either one. [...]
>
> I had the same horrible experience with C/gcc, K&R, and man pages.
Get serious. C is the language the OS is written in, it can link
natively to OS code written to control hardware. And everybody
knows it. You're not left looking for ways to connect C to that
code; you're just looking for documentation of that code, secure
in the knowledge that it WILL use the same ABI as the C compiler
and WILL link natively to it.
Yes, the C language without libraries is as impoverished in its
ability to interface with the OS as Common Lisp. But no book
and no programming course teaches C without teaching how to link
libraries that control things. Lisp, by contrast, has an entire
standard that doesn't even mention that such libraries *MAY
EXIST!*
This is going to fill someone who wants to use it to write
windowed applications that get mouse input with great
anticipation.... right?
Furthermore, Libraries *are* part of the C standard, and even
libraries that aren't mentioned in C99 are widely distributed,
available for many different compilers and systems, and well
documented. Don't we *wish* the same were true of Lisp...
> I
> was convinced it'd take incense, incantations and sacrifice of small
> animals to put up a UI and talk to hw. Those and spirits. That
> last bit I'd gathered from the 'volatile' they mentioned.
>
> I am thinking I missed something upthread?
Probably just the fact that almost everybody who wants to
do such things in Lisp asks as a first question, "so how do
I link Lisp to C libraries..." and most of them run off in
terror and are never heard from again when someone tells them
that there's no portable way and it all depends on which Lisp
system they're using.
Bear
Ray Dillinger wrote:
> no book
> and no programming course teaches C without teaching how to link
> libraries that control things.
Can you point me to where this is described in, say, K&R?
All I can find about how to invoke the compiler/linker is the bit right
at the start that describes how to compile "hello world" on a UNIX
system - and it had better be one that has the ANSI C compiler
installed as 'cc', too. For any other setup it cops out with the
advice to "check with a local expert". I remember when I was first
learning C (on the Amiga) the compiler manual was immensely more useful
at this stage.
From: Christopher C. Stacy
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <u64sbgqa3.fsf@news.dtpq.com>
Ray Dillinger <····@sonic.net> writes:
> Furthermore, Libraries *are* part of the C standard, and even
> libraries that aren't mentioned in C99 are widely distributed,
> available for many different compilers and systems, and well
> documented. Don't we *wish* the same were true of Lisp...
1. Here are the C standard libraries:
* <assert.h> : Diagnostics
* <ctype.h> : Character Class Tests
* <errno.h> : Error Codes Reported by (Some) Library Functions
* <float.h> : Implementation-defined Floating-Point Limits
* <limits.h> : Implementation-defined Limits
* <locale.h> : Locale-specific Information
* <math.h> : Mathematical Functions
* <setjmp.h> : Non-local Jumps
* <signal.h> : Signals
* <stdarg.h> : Variable Argument Lists
* <stddef.h> : Definitions of General Use
* <stdio.h> : Input and Output
* <stdlib.h> : Utility functions
* <string.h> : String functions
* <time.h> : Time and Date functions
Seems to me that Common Lisp has all those kinds
of things built into the language.
2. A number of important Libraries for Lisp are widely distributed,
available for many different compilers and systems, and well
documented.
For example: Networking, Web Serving, SQL embedding and
database drivers, XML processing, crypto, etc.
3. I would like to see Lisp's situation improve.
Could you say something specific about what you think
the problems with the Lisp libraries are?
For example, which ones you went looking for but were unable
to find? How did you go looking?
How did you solve the problem in C?
> 3. I would like to see Lisp's situation improve.
> Could you say something specific about what you think
> the problems with the Lisp libraries are?
> For example, which ones you went looking for but were unable
> to find? How did you go looking?
> How did you solve the problem in C?
A full GUI. That's the missing piece that put me off for a long time.
If you're on a unix you're laughing, but with windows and osx (until
the recent bundling of X11) you had nothing like a portable way to do
this.
I learnt Java a few years ago because it had a fully portable GUI as
part of the spec. I realise now it was a waste of time, and if you
*need* portable code, you can write a wrapper, use gtk, ltk, random
library etc. But I think we need something that's clearly signposted
from every possible entrance into lisp. Something that just is *the*
gui, that you can point noobs too with confidence that they'll come
back with LIFE running in two hours. I know Cello is an attempt at
this, and all power to Kenny and co (not sure if there is a co) for the
effort. But along with an implementation, *the* gui needs dazzling
documentation, and it's own website where you can download it for any
lisp, and it'll just run out of the box.
When you're flicking through lisp books and their examples all use a
text interface, and then you look at a java book and after chapter 10
everything is done through a GUI, its an easy choice for a beginner.
Robbie Carlton wrote
"Something that just is *the* gui, that you can point noobs too with
confidence that they'll come back with LIFE running in two hours."
I totally agree. That's what I was looking for when I started playing
with lisp last year. I don't want to pay for a lisp environment until
I'm using it to make money, so that rules out corman, allegro and lisp
works which do have gui support (but three different versions of it?).
Although I agree this would be great to have, yet how do you provide
it? How do you provide a gui api that works on linux and windows
systems?
One solution would be to go the java route and provide the whole thing
as a cross platform library that requires a gui backend written for
each OS and GUI library.
Justin
If you're still looking, I wouldn't rule out the commercial lisps,
especially if you're programming for a hobby (and especially if you're
programming commercially (and especially if you're a student :)).
Lispworks trial comes with pretty much everything you'll need in terms
of a gui, as does Allegro by all accounts. I don't know about Corman
cos windows is gross :P
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3qkrb3Ffgc07U1@individual.net>
justinhj wrote:
> Robbie Carlton wrote
>
> "Something that just is *the* gui, that you can point noobs too with
> confidence that they'll come back with LIFE running in two hours."
It seems to me that LTK is the right thing here.
> I totally agree. That's what I was looking for when I started playing
> with lisp last year. I don't want to pay for a lisp environment until
> I'm using it to make money, so that rules out corman, allegro and lisp
> works which do have gui support (but three different versions of it?).
They all provide personal/free editions which you can use for
non-commercial purposes. As soon as you go commercial, you buy the license.
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
Pascal Costanza wrote:
> >
> > "Something that just is *the* gui, that you can point noobs too with
> > confidence that they'll come back with LIFE running in two hours."
>
> It seems to me that LTK is the right thing here.
I agree. LTK is simple to learn (although it would be nice if there
were more lisp docs and you didn't have to translate from the tcl/tk
docs) and simple to install.
Once they've whet their appetite, I don't think it's too hard to climb
up into the land of the more industrial strength guis (meaning no
disrespect to tk).
So now we need high profile tutorials (something for the next edition
of PCL, mr Seibel?), and to bundle it with the free distributions and
generally ram it down noobs throats whenever they come within 5 miles
of us.
"justinhj" <········@gmail.com> writes:
> One solution would be to go the java route and provide the whole thing
> as a cross platform library that requires a gui backend written for
> each OS and GUI library.
Why has no one mentioned CLIM yet?
--
http://www.david-steuber.com/
The UnBlog | Lisp on OS X topics for the most part
Click all the links you want. I'll make more!
From: Greg Menke
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m3k6gqlu1q.fsf@athena.pienet>
···············@gmail.com" <··············@gmail.com> writes:
> > 3. I would like to see Lisp's situation improve.
> > Could you say something specific about what you think
> > the problems with the Lisp libraries are?
> > For example, which ones you went looking for but were unable
> > to find? How did you go looking?
> > How did you solve the problem in C?
>
> A full GUI. That's the missing piece that put me off for a long time.
> If you're on a unix you're laughing, but with windows and osx (until
> the recent bundling of X11) you had nothing like a portable way to do
> this.
> I learnt Java a few years ago because it had a fully portable GUI as
> part of the spec. I realise now it was a waste of time, and if you
> *need* portable code, you can write a wrapper, use gtk, ltk, random
> library etc. But I think we need something that's clearly signposted
> from every possible entrance into lisp. Something that just is *the*
> gui, that you can point noobs too with confidence that they'll come
> back with LIFE running in two hours. I know Cello is an attempt at
> this, and all power to Kenny and co (not sure if there is a co) for the
> effort. But along with an implementation, *the* gui needs dazzling
> documentation, and it's own website where you can download it for any
> lisp, and it'll just run out of the box.
> When you're flicking through lisp books and their examples all use a
> text interface, and then you look at a java book and after chapter 10
> everything is done through a GUI, its an easy choice for a beginner.
Try Lispworks. Or Franz. Or Corman. They all have "full gui's" for
a vague definition of the term.
Lispworks gui code is portable across 3 architectores and 3 operating
systems.
Really though, gui support is pretty far down the list of "important
features", and its not as if this discussion hasn't happend at least
10's of times before in the last year or two. Does "signpost" somehow
NOT include using google at least once?
Gregm
Greg Menke wrote:
> Really though, gui support is pretty far down the list of "important
> features",
Not if you're a beggining programmer on a commercial os. I would say
it's at the top of the list for those guys
> and its not as if this discussion hasn't happend at least
> 10's of times before in the last year or two.
Yes, doesn't that suggest something to you. I wonder how often they
have this discussion in comp.lang.java.
Even languages like ruby and python, which don't have a gui in the spec
like java, still have canonical answers to the "where's the gui"
question.
> Does "signpost" somehow
> NOT include using google at least once?
Have you tried this search?
http://www.google.co.uk/search?q=lisp+gui
The only thing in the first 10 hits that comes close to what lisp needs
is cells-gtk, and that still requires a handful of additional
downloads, and if you're on os x you have to install x windows, which
makes it hard to deliver. Everything else is going to take a lot more
research, flase starts and frustration. Now you can keep going, and it
doesn't take you long to find things like ltk which are very simple for
a noob, or the lispwroks and allegro trials which are even simpler. But
compare it to this.
http://www.google.co.uk/search?q=python+gui
Now, I'm not saying this is the fault of the implementors (cells-gtk is
great, and lispworks gui is also great, don't know about the others, as
I stopped at those two), or that python has superior gui solutions to
lisp. (as far as I can see, lisps are better). But if you're a
stone-cold noob wandering bleary eyed into the world, and you want to
write games, or draw fractals, or just open a file-dialog, lisp is not
going to seem like an easy solution.
From: Greg Menke
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m3hdbubsgz.fsf@athena.pienet>
···············@gmail.com" <··············@gmail.com> writes:
> Greg Menke wrote:
>
> > Really though, gui support is pretty far down the list of "important
> > features",
>
> Not if you're a beggining programmer on a commercial os. I would say
> it's at the top of the list for those guys
Perhaps if all the programmer cares about is a couple forms w/ buttons-
on that basis nearly any language will do fine. The reason Lisp is so
nice is because it makes software easier to write- and that is pretty
much independent of the interface.
From a newbie perspective, I would view the relative simplicity of the
interface-free language as an advantage- less of a pile of stuff to wade
through.
A Lisp newbie will probably discover the open source Lisps and give them
a try. Once they start discovering what they do & don't do, they'll
probably then discover the commercial implementations. At which point,
they'll probably give them a try- as they tend to be more turnkey and
complete out of the box. The cost of a commercial Lisp is competitive
with whatever devstudio Microsoft is inflicting on the world, so the
only limitation on someone taking up Lisp is their desire to do so.
> > and its not as if this discussion hasn't happend at least
> > 10's of times before in the last year or two.
>
> Yes, doesn't that suggest something to you. I wonder how often they
> have this discussion in comp.lang.java.
> Even languages like ruby and python, which don't have a gui in the spec
> like java, still have canonical answers to the "where's the gui"
> question.
It suggests that people hear "Lisp is cool", don't do their homework,
and happen across this newsgroup and start asking questions that the
most trivial amount of legwork would answer.
You persist in comparing 1 implementation languages to a language with
at least half a dozen major implementations spread across quite a number
of architectures. How can a gui interface be canonical in this
situation?
> > Does "signpost" somehow
> > NOT include using google at least once?
>
> Have you tried this search?
> http://www.google.co.uk/search?q=lisp+gui
>
> The only thing in the first 10 hits that comes close to what lisp needs
> is cells-gtk, and that still requires a handful of additional
> downloads, and if you're on os x you have to install x windows, which
> makes it hard to deliver. Everything else is going to take a lot more
> research, flase starts and frustration. Now you can keep going, and it
> doesn't take you long to find things like ltk which are very simple for
> a noob, or the lispwroks and allegro trials which are even simpler. But
> compare it to this.
This points to the multiplicity of gui solutions available in Lisp. As
opposed to the single implementation languages which have basically one
each. The usual "meta-lisp" sites show up in the first page or two,
leading to the usual vendors and libraries. I fail to see why you think
people are unable to traverse a few of these to get a sense of how Lisp
does things.
>
> http://www.google.co.uk/search?q=python+gui
>
> Now, I'm not saying this is the fault of the implementors (cells-gtk is
> great, and lispworks gui is also great, don't know about the others, as
> I stopped at those two), or that python has superior gui solutions to
> lisp. (as far as I can see, lisps are better). But if you're a
> stone-cold noob wandering bleary eyed into the world, and you want to
> write games, or draw fractals, or just open a file-dialog, lisp is not
> going to seem like an easy solution.
If there are indeed people suffering from this problem its because
they're trying to do the same old stuff in Lisp that they were doing in
VB, Java, C# and all the others- focusing on the knobs & switches
instead of using the language.
Gregm
Greg Menke wrote:
> ···············@gmail.com" <··············@gmail.com> writes:
>
>
>>Greg Menke wrote:
>>
>>
>>>Really though, gui support is pretty far down the list of "important
>>>features",
>>
>>Not if you're a beggining programmer on a commercial os. I would say
>>it's at the top of the list for those guys
>
>
> Perhaps if all the programmer cares about is a couple forms w/ buttons-
> on that basis nearly any language will do fine. The reason Lisp is so
> nice is because it makes software easier to write- and that is pretty
> much independent of the interface.
If the program interacts with a user on anything with more of an
interface than three buttons and a one line LCD, the program probably
"needs" a GUI, in the sense that users will expect nothing less. I don't
know what environment you've been cloistered in, but in the world I
inhabit, command line interfaces just don't cut it for non-programmer
end users. Further, for many non-trivial programs with user interfaces,
the UI code is a non-trivial (indeed major) fraction of the program --
the ease of writing the software becomes very much dependent on the
interface.
> From a newbie perspective, I would view the relative simplicity of the
> interface-free language as an advantage- less of a pile of stuff to wade
> through.
I don't think this is true. What's more, I have a hard time even
believing that YOU think it's true. To start: Let's agree that by
'newbie' we mean someone who has programmed in other languages, but is
new to Lisp, since the fraction of contemporary newbies whose first
language is Lisp is vanishingly small.
Our newbie is someone who knows that even if he doesn't want to do GUI
stuff now, he wants a language with good support for GUI stuff, because
he'll likely want to do it later. If our newbie doesn't do GUI, it'll be
some other breakthrough in comp sci from the last five years, like
networking or threads. Learning a feature-free language in order to
avoid intellectual clutter at the outset is a clueless strategy.
>>Even languages like ruby and python, which don't have a gui in the spec
>>like java, still have canonical answers to the "where's the gui"
>>question.
...
>>Have you tried this search?
>>http://www.google.co.uk/search?q=lisp+gui
> It suggests that people hear "Lisp is cool", don't do their homework,
> and happen across this newsgroup and start asking questions that the
> most trivial amount of legwork would answer.
Robbie wins the argument decisively with that Google search. What you
apparently fail to grasp is that the first page of results from that
search *IS* the answer to their homework. When someone with a modicum of
experience programming looks at those results (an eight year old FAQ,
packages whose most recent versions are eleven and twelve years old, a
"working draft under construction" page about software which is
"currently in a prerelease state") what conclusions do you think they
will draw? You seem to think they're going to keep digging, rather than
come to the obvious ("I'll either have to lash up a GUI myself, do
without one, wait for the fairy or live with something from the
eighties") conclusion.
> You persist in comparing 1 implementation languages to a language with
> at least half a dozen major implementations spread across quite a number
> of architectures. How can a gui interface be canonical in this
> situation?
"Quite a number of architectures"? There are *FOUR* GUI architectures
with perceptible marketshare: Windows, UNIX/X, Apple and "web browser."
This has been true for more than a decade.
Java has an API that works on three of these, as does wxWidgets. And not
by accident, either: They were created to satisfy programmers who wanted
cross-platform GUIs, and number four has been evolving to compete in the
same niche. Your "How can a GUI interface be canonical?" question is
thus doubly flawed, for not only do you deny existence proofs, but you
suggest that Lisp has multiple good GUI interfaces to choose from. If
Lisp had one good GUI interface, it would be canonical right now.
You seem to want to include commercial vendors' GUI offerings, but
they're not Lisp GUIs in the sense that they run on multiple Common
Lisps. Even newbies (as defined above) know the difference between
portable/standard GUI frameworks and vendor lock-in. I'm not denigrating
proprietary products, but if you want to advocate them, you're no longer
advocating for Lisp (and all the goodness that a standard with multiple
implementations implies) but for a single-source solution which happens
to have Lisp as a substrate.
Greg Menke <············@toadmail.com> wrote:
> ···············@gmail.com" <··············@gmail.com> writes:
>
> > Greg Menke wrote:
> >
> > > Really though, gui support is pretty far down the list of "important
> > > features",
> >
> > Not if you're a beggining programmer on a commercial os. I would say
> > it's at the top of the list for those guys
>
> Perhaps if all the programmer cares about is a couple forms w/ buttons-
> on that basis nearly any language will do fine. The reason Lisp is so
> nice is because it makes software easier to write- and that is pretty
> much independent of the interface.
That is never *all* a programmer cares about. But for any given task,
it may be easier to put up with the shortcomings of python/java/whatever
than to deal with figuring out how to get a reasonable user-interface
from common lisp without much guidance. Yes, you can get the guidance
by springing for a commercial implementation, but either that, or the
many hours of farting around is a hurdle -- a hurdle that many other
languages do not share.
It's not a serious hurdle if you are convinced of the value of lisp
already, but if you aren't, it is.
> A Lisp newbie will probably discover the open source Lisps and give them
> a try. Once they start discovering what they do & don't do, they'll
> probably then discover the commercial implementations. At which point,
> they'll probably give them a try- as they tend to be more turnkey and
> complete out of the box. The cost of a commercial Lisp is competitive
> with whatever devstudio Microsoft is inflicting on the world, so the
> only limitation on someone taking up Lisp is their desire to do so.
They aren't competitive with Xcode, nor are they competitive with the
various toolkits bundled with python, ruby, etc.
This is not to say they aren't worth the money, or that I'm demanding
that somebody provide the missing piece of cheap IDE that lets newbies
program simple GUIs in lisp easily. But this *is* an actual hurdle.
> If there are indeed people suffering from this problem its because
> they're trying to do the same old stuff in Lisp that they were doing in
> VB, Java, C# and all the others- focusing on the knobs & switches
> instead of using the language.
The problem is that the knobs and switches are important also if you
want to actually deliver something.
It's an easy excuse to hang your hat on. If the goal is for people who
aren't serious programmers already doing deep tasks to not bother with
lisp, then this is a perfectly reasonable attitude. It doesn't look
actually *hard* to figure out how to program a GUI in lisp. But it's
definitely hard*er* than in other languages, and a lot of newbies are
going to look at that and go "no thanks" before they learn enough lisp
to grok what's better about it.
Michael
From: Christopher C. Stacy
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <ud5mipenw.fsf@news.dtpq.com>
Michael Sullivan writes:
> They aren't competitive with Xcode, nor are they competitive
> with the various toolkits bundled with python, ruby, etc.
Your complaint here seems to be that commercial lisp systems
(which give you nice cross-platform GUI libraries) are not
price competitive with the free ones, nor with the (non-portable,
non-free) system from Apple.
So, is it all about (lack of) money then?
> This is not to say they aren't worth the money, or that I'm demanding
> that somebody provide the missing piece of cheap IDE that lets newbies
> program simple GUIs in lisp easily. But this *is* an actual hurdle.
If they are newbies who are trying to learn the language,
why don't they just use the free ("personal" / "trial")
edition of the commercial system?
I'm talking ideal world here, but what I would like would be for the
various commercial lisps and the free ones to get together and agree to
a common way of doing foreign function interfaces, a way of doing gui,
graphics, sound, input and printing in a modern environment. All these
things would be OS independent. You would download one thing to make it
all work. Or rather, whichever lisp implementation you have something
like (modal-dialog "hi") would do the same thing everywhere.
What I'm asking for is for the hyperspec to be the core language, yet
there to be another layer on top of that which is the "interface to the
modern desktop" hyperspec.
I'm spoiled by the free Java SDK or Microsofts developer studio.
In lisp it seems there are a bunch of ways to do guis, some free, some
commercial, and whichever route you take you're unlikely to be able to
take your code and email it to a another randomly chosen lisp
programmer and have it work on his system.
I better hide now while I get told that this has all been done dozens
of time before or I should get my check book out ;-)
Justin
Christopher C. Stacy <······@news.dtpq.com> wrote:
> Michael Sullivan writes:
> > They aren't competitive with Xcode, nor are they competitive
> > with the various toolkits bundled with python, ruby, etc.
> Your complaint here seems to be that commercial lisp systems
> (which give you nice cross-platform GUI libraries) are not
> price competitive with the free ones, nor with the (non-portable,
> non-free) system from Apple.
> So, is it all about (lack of) money then?
I'm not complaining. I'm merely stating a truth. If one wants lisp to
take over the world, or failing that, to become as popular as, say
python, there need to be free CL implementations available that allow
newbies to the language to deal with simple GUIs and network programming
without a lot of hassle beyond learning the language itself and then
solving the actual specific problems.
That's not the situation with current free lisps, but it *is* with some
free/bundled implementation of every language that's an order of
magnitude more popular than lisp. And yes, being bundled with with some
popular OS counts as free.
Telling yourself or other people that this isn't an issue with the
current state of lisp is foolish, unless you really don't care about
attracting new developers. Right now, if you want a lisp environment
that does what many other languages do you must either go commercial or
do some research. It's not a good reason to reject lisp, if you already
have a good reason to try it. But for anyone who *doesn't* have a
better reason to try it than "hmm... a new language, wonder if that's
interesting?", it's probably enough reason.
Note -- I think these things will eventually happen. My point is that
energy expended on creating and standardizing (I mean informally,
something like CLRFIs -- not reopening ANSI) such tools is not
pointless.
Michael
From: Robert Uhl
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m364s9p63k.fsf@4dv.net>
······@news.dtpq.com (Christopher C. Stacy) writes:
>
> If they are newbies who are trying to learn the language, why don't
> they just use the free ("personal" / "trial") edition of the
> commercial system?
Because they don't wish to be locked into proprietary systems, perhaps?
--
Robert Uhl <http://public.xdi.org/=ruhl>
I think I've figured out why that FreeBSD box is oozing green ichor--I
think it may be due to having the NT PDC only a foot or two away.
--Lionel
From: Christopher C. Stacy
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <uslvdfbr3.fsf@news.dtpq.com>
Robert Uhl <·········@NOSPAMgmail.com> writes:
> ······@news.dtpq.com (Christopher C. Stacy) writes:
> >
> > If they are newbies who are trying to learn the language, why don't
> > they just use the free ("personal" / "trial") edition of the
> > commercial system?
>
> Because they don't wish to be locked into proprietary systems, perhaps?
Use CLIM.
From: Troels Henriksen
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <8764s7ppkl.fsf@sigkill.dk>
······@news.dtpq.com (Christopher C. Stacy) writes:
> Use CLIM.
As far as I know, McCLIM is the only free implementation of CLIM, and
isn't McCLIM a bit too buggy and undocumented to be generally useful?
--
Troels "Athas" Henriksen
···············@gmail.com" <··············@gmail.com> writes:
> Greg Menke wrote:
>
> > Really though, gui support is pretty far down the list of "important
> > features",
>
> Not if you're a beggining programmer on a commercial os. I would say
> it's at the top of the list for those guys
I don't think GUI programming is a suitable topic for a beginning
programmer.
> But if you're a stone-cold noob wandering bleary eyed into the
> world, and you want to write games, or draw fractals, or just open a
> file-dialog, lisp is not going to seem like an easy solution.
Games are also hardly a suitable starting point for a beginner. You
don't even need a GUI to draw fractals. A GUI might even get in the
way with all the unrelated to fractals boilerplate you have to write.
--
http://www.david-steuber.com/
The UnBlog | Lisp on OS X topics for the most part
Click all the links you want. I'll make more!
David Steuber wrote:
> I don't think GUI programming is a suitable topic for a beginning
> programmer.
this depends on the GUI library you are using. The advantage of GUI
programming is that the user sees something more than just numbers and text
and if you are using Java, it is very simple, see for example
http://www.frank-buss.de/java/freihand/index.html
The same with CLIM is longer and more difficult:
http://www.frank-buss.de/lisp/clim.html
But this is not the fault of Lisp, as you can see with CL-Canvas:
http://www.frank-buss.de/lisp/canvas.html
(and the drawing program exmple could be as short as the Java applet
example, when you design an applet like interface on top of CL-Canvas).
--
Frank Bu�, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
From: Wade Humeniuk
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <jMv1f.9332$Io.8132@clgrps13>
Frank Buss wrote:
> David Steuber wrote:
>
>
>>I don't think GUI programming is a suitable topic for a beginning
>>programmer.
>
>
> this depends on the GUI library you are using. The advantage of GUI
> programming is that the user sees something more than just numbers and text
> and if you are using Java, it is very simple, see for example
> http://www.frank-buss.de/java/freihand/index.html
>
And with CAPI it can be as simple as
(defun freihand ()
(let ((px nil) (py nil) (downp nil))
(flet ((press (port x y)
(declare (ignore port))
(setf downp t px x py y))
(motion (port x y)
(when downp
(gp:draw-line port px py x y)
(setf px x py y)))
(release (port x y)
(declare (ignore port x y))
(setf downp nil)))
(capi:contain
(make-instance 'capi:output-pane
:input-model
`(((:button-1 :press) ,#'press)
((:button-1 :release) ,#'release)
((:button-1 :motion) ,#'motion)))))))
Wade
From: Rainer Joswig
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <BF6C6789.19F82%joswig@lisp.de>
Am 07.10.2005 16:02 Uhr schrieb "Frank Buss" unter <··@frank-buss.de> in
·······························@40tude.net:
> David Steuber wrote:
>
>> I don't think GUI programming is a suitable topic for a beginning
>> programmer.
>
> this depends on the GUI library you are using. The advantage of GUI
> programming is that the user sees something more than just numbers and text
> and if you are using Java, it is very simple, see for example
> http://www.frank-buss.de/java/freihand/index.html
>
> The same with CLIM is longer and more difficult:
> http://www.frank-buss.de/lisp/clim.html
I guess half of that code is not needed in CLIM. You also
can make it conceptually simpler.
Rainer Joswig wrote:
>> The same with CLIM is longer and more difficult:
>> http://www.frank-buss.de/lisp/clim.html
>
> I guess half of that code is not needed in CLIM. You also
> can make it conceptually simpler.
This is possible. But I think it is hard to program in CLIM, because there
are not as much examples as in Java AWT or Swing, but if you can write it
better, I would be glad to update the source with your version.
--
Frank Bu�, ··@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
From: Edi Weitz
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <ubr22kev2.fsf@agharta.de>
On 06 Oct 2005 08:16:33 -0400, Greg Menke <············@toadmail.com> wrote:
> Lispworks gui code is portable across 3 architectores and 3
> operating systems.
I haven't tried all of them myself but I think it's rather 6 than 3:
Windows/x86
Linux/x86
OS X/PPC
OSF 1/DEC Alpha
HP-UX/PA-RISC
Solaris/Sparc
Cheers,
Edi.
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
Greg Menke wrote:
> Really though, gui support is pretty far down the list of "important
> features", and its not as if this discussion hasn't happend at least
> 10's of times before in the last year or two. Does "signpost" somehow
> NOT include using google at least once?
Excuse me... if it were really nowhere near the top of
the list of "important features", then why the *HELL*
would it keep coming up dozens of times in a year or
two??
I reiterate: it is no longer okay for a language standard
to fail to explain how to put up a standard GUI, or at the
very least link to the C libraries that do.
Bear
Ray Dillinger wrote:
> Greg Menke wrote:
>
> I reiterate: it is no longer okay for a language standard
> to fail to explain how to put up a standard GUI, or at the
> very least link to the C libraries that do.
WTF do you mean by "standard GUI" here? What Java does?
Or are you talking about some other language standard which lets you
write one program (completely within the standard,) and are able to do
everything from device drivers to GUI output to direct screen access to
OS kernel tweaks to networking code and have it work transparently, on,
say Mac OS X, Linux, and Windows?
The C++ standard, for instance, which no one seems to worry about
(i.e., you don't see trolls in C++ forums complaining "The C++ standard
doesn't support GUI development..."), certainly does not provide
facilities to do anything remotely close to that. In fact, you have to
code for the platform you want to deliver on, and portability is
nonexistent.
··············@hotmail.com wrote:
> Ray Dillinger wrote:
>>Greg Menke wrote:
>>I reiterate: it is no longer okay for a language standard
>>to fail to explain how to put up a standard GUI, or at the
>>very least link to the C libraries that do.
> The C++ standard, for instance, which no one seems to worry about
> (i.e., you don't see trolls in C++ forums complaining "The C++ standard
> doesn't support GUI development..."), certainly does not provide
> facilities to do anything remotely close to that. In fact, you have to
> code for the platform you want to deliver on, and portability is
> nonexistent.
That is true, but it is also irrelevant. What solves their
problem does not solve our problem.
They get that privelege because the fundamental infrastructure
of the OS is developed *FOR* them, in a format guaranteed to
be linkable to their code. With C and things that share its
ABI, the GUI isn't part of the language because the GUI
facilities provided by the OS are guaranteed to be linkable.
When you're talking about a language that doesn't use that ABI,
it's incumbent on you to explain how to do basic crap that C and
C++ get for free because the OS provides it.
Unless I can suck a DLL or SO file into my lisp image and, using
knowledge of its ABI, find ways to invoke its routines and
register callbacks etc with them in formats it understands,
the infrastructure developed for the OS is not usable from
Lisp.
Bear
Ray Dillinger wrote:
> ··············@hotmail.com wrote:
> > The C++ standard, for instance, which no one seems to worry about
> > (i.e., you don't see trolls in C++ forums complaining "The C++ standard
> > doesn't support GUI development..."), certainly does not provide
> > facilities to do anything remotely close to that. In fact, you have to
> > code for the platform you want to deliver on, and portability is
> > nonexistent.
>
> That is true, but it is also irrelevant. What solves their
> problem does not solve our problem.
>
> They get that privelege because the fundamental infrastructure
> of the OS is developed *FOR* them, in a format guaranteed to
> be linkable to their code. With C and things that share its
> ABI, the GUI isn't part of the language because the GUI
> facilities provided by the OS are guaranteed to be linkable.
What privelege? What infrastructure? Have you actually tried writing a
GUI-based application using C or even C++? The linker doesn't help *at
all.* The real effort is learning a GUI toolkit (which standard GUI is
that again?)
Every GUI environment ranges from lousy to much worse when addressed
from C. Your C compiler's compliance with the ABI gets you exactly
nothing on the screen. It's knowing which calls to make, whether to the
low-level OS interface, or a higher level framework, to make your
interface come to life.
Now, if you were talking about VB or Tk/Tcl, I'd believe you. But you
keep talking as though the damn linker does any significant work for
you at all in C, compared to the huge task of actually learning a GUI
API and programming to it, which seems to me much less of an effort in
Lisp than in any other general-purpose language, especially when you
compare commercial GUI frameworks.
>
> When you're talking about a language that doesn't use that ABI,
> it's incumbent on you to explain how to do basic crap that C and
> C++ get for free because the OS provides it.
What OS provides significantly helpful GUI facilities? Windows with
MFC?
>
> Unless I can suck a DLL or SO file into my lisp image and, using
> knowledge of its ABI, find ways to invoke its routines and
> register callbacks etc with them in formats it understands,
> the infrastructure developed for the OS is not usable from
> Lisp.
="Learn how to use the FFI of your implementation, for crying out loud."
··············@hotmail.com wrote:
> Ray Dillinger wrote:
>
>>··············@hotmail.com wrote:
>>
>>>The C++ standard, for instance, which no one seems to worry about
>>>(i.e., you don't see trolls in C++ forums complaining "The C++ standard
>>>doesn't support GUI development..."), certainly does not provide
>>>facilities to do anything remotely close to that. In fact, you have to
>>>code for the platform you want to deliver on, and portability is
>>>nonexistent.
>>
>
>>Unless I can suck a DLL or SO file into my lisp image and, using
>>knowledge of its ABI, find ways to invoke its routines and
>>register callbacks etc with them in formats it understands,
>>the infrastructure developed for the OS is not usable from
>>Lisp.
>
>
> ="Learn how to use the FFI of your implementation, for crying out loud."
>
I'm a complete n00b to Lisp, and I have to say that I agree with Ray's
argument. He's completely right! 100% What n00bs like me want to see is
that it has GUIs, network libraries, and all the goodies that we get
with stuff like Python.
But praise the Lord, what do we see when we try Lisp? Abandoned
projects, half-implemented APIs, incompatabilities galore. Take UFFI ...
please. Not only is it incompatable with CLISP, it has been forked to
hello-c.
Many of the GUIs wont work on Windows. There's Ltk - which is for very
lightweight work only. The only light at the end of the tunnel is wxCL,
which is a full-featured GUI - full praise goes to Surendra K. Singhi in
his efforts. I am aware that Lispworks and Allegro have GUIs - but
people like me shy away from commercial stuff. We can't distribute our
work.
The best that Lispers can come out with is "Learn how to use the FFI".
Seriously, I'm not trolling, I'm just saying it like it is. There's just
too much unwarranted complexity in it; too much tail-chasing; too much
brain damage just to accomplish something simple. You know, considering
that Lisp is one of the world's oldest programming languages, you'd
think that it would have these problems licked by now.
From: Christopher C. Stacy
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <umzllcdac.fsf@news.dtpq.com>
Write your program in Python, then, please,
and come back and show us how much easier it was.
From: Robert Uhl
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m3oe61nhum.fsf@4dv.net>
······@news.dtpq.com (Christopher C. Stacy) writes:
>
> Write your program in Python, then, please, and come back and show us
> how much easier it was.
I've gotten much further with my app in python and pygtk than I have
with Lisp and who-knows-what. As in, I actually got to the point of
displaying a nice little system, all the planets orbiting the stars and
moons orbiting the planets and so forth.
Meanwhile in Lisp-land, I'm still looking for something which a) is
stable; b) is free (libre as well as gratis); c) complete; d)
well-documented and e) current. Not saying that it's the Lisp
community's job to provide me with tools--far from it. But it would be
nice if it did:-)
A newbie evaluation languages sees one language with lots and lots of
support and another without; certainly he can't reasonably demand that
other folks give him what he wants, but when one group does so and
another doesn't, he can reasonably choose to go with the former.
--
Robert Uhl <http://public.xdi.org/=ruhl>
Truth hurts. Maybe not as much as jumping on a bicycle with a seat
missing, but it hurts. --Drebin, Naked Gun 2 1/2
Robert Uhl wrote:
> A newbie evaluation languages sees one language with lots and lots of
> support and another without; certainly he can't reasonably demand that
> other folks give him what he wants, but when one group does so and
> another doesn't, he can reasonably choose to go with the former.
And perhaps he should. Next he'll be demanding that we remove lambda and
reduce in favour of named functions and loops because it's 'clearer'. :P
Did python get all this support overnight? no.. users of python wrote
these libraries because they needed them. As have lisp users. The goals
of the two communites differ (python wants to be a language that is easy
for n00bs .. lisp want to be a language that is easy for experienced
software developers to solve hard problems with), so is it so surprising
the the approaches to library development differ as well?
I've personally played with LTK, cells-gtk and McCLIM under lisp, and
found all of them to be up to task. Sure, there may not be "how to write
a hello world" tutorials lying around, but Lisp source is almost always
more readable than a tutorial, and i prefer examples to documentation
anyway. YMMV, of course.
--
Drew Crampsie
drewc at tech dot coop
"... the most advanced use of lisp in the field of bass lure sales"
-- Xach on #lisp
Robert Uhl wrote:
> A newbie evaluation languages sees one language with lots and lots of
> support and another without; certainly he can't reasonably demand that
> other folks give him what he wants, but when one group does so and
> another doesn't, he can reasonably choose to go with the former.
EXACTLY!
People who have a spark of interest in Lisp (or any other language)
don't set about to hate it, they set about to like it. They hear about
all the cool stuff it does better than other languages, and are keen to
try it out. they see good things, they see bad. It's not about baiting
Lispers, or anything like that.
One of the bad things they see with Lisp in particular is the
fragmentation, where trying to get working libraries for their platform
and implementation are toothgrindingly difficult. They eventually ask
themselves "what's the bloody point", and go back to doing whatever it
was they were doing before they arrived.
Take Ruby, for example. The syntax looked like it would solve the Python
whitespace problems. But I found that the libraries were less mature
than the Python ones, plus the Fox toolkit had compatability problems
with ... yada yada yada. So I decided that Ruby wasn't for me, and that
I'd stick to Python. There wasn't any ego involved. My point wasn't to
"prove" that people who use Ruby are "idiots"; I just tried it, and
found out it wasn't to my taste.
Mark Carter wrote:
> Robert Uhl wrote:
>
>> A newbie evaluation languages sees one language with lots and lots of
>> support and another without; certainly he can't reasonably demand that
>> other folks give him what he wants, but when one group does so and
>> another doesn't, he can reasonably choose to go with the former.
>
>
> EXACTLY!
[snip]
> One of the bad things they see with Lisp in particular is the
> fragmentation,
Fragmentation? In Common Lisp? Sir, i fear you are mistaken. While there
are multiple implementations of Common Lisp (and this is a good thing),
the "fragmentation" of which you speak can simply not exist in in Common
Lisp ... there is an ANSI standard! If i write my code according to the
standard, it will run on _any_ conforming implementation, and to be
called "Common Lisp", it must conform.
Now, there are of course the things the standard does not cover
(threads, sockets). And yes, the implementations differ on these. But,
there are compatibility libraries (ACL-COMPAT comes to mind) that you
can use rather than your implementation's primitives, and have your code
portable across implementations.
Different implementations have different strengths/weaknesses.. i
personally like having the choice. I would never want to use SBCL where
memory is tight, but i prefer it over, say, clisp when performance is at
stake.
Python users seem to prefer to be told what is good/bad. This is also a
choice. A lazy one, but who am i to judge :)
Also, Python seems horribly "fragmented" as well (if the definition of
"fragmented" is "multiple slightly incompatible implementations"). Can a
take a Jython program that calls out to Java and run it on stackless?
will a CPython program that links to my library (i wrote the
high-performance stuff in C of course, as we are supposed to in python)
work in Iron Python. Hell, will the python program i just wrote in a
modern python run on my 5 year old python installation?.
And when i notice the discrepancies, where do i turn to find the
'correct' behaviour? Without a spec, there really is no 'correct'
behaviour, is there?
> where trying to get working libraries for their platform
> and implementation are toothgrindingly difficult. They eventually ask
> themselves "what's the bloody point", and go back to doing whatever it
> was they were doing before they arrived.
I've said it before and i'll say it again. If one has trouble with
(asdf-install:install 'acl-compat), then perhaps a career change is in
order.
> Take Ruby, for example. The syntax looked like it would solve the Python
> whitespace problems. But I found that the libraries were less mature
> than the Python ones, plus the Fox toolkit had compatability problems
> with ... yada yada yada. So I decided that Ruby wasn't for me, and that
> I'd stick to Python. There wasn't any ego involved. My point wasn't to
> "prove" that people who use Ruby are "idiots"; I just tried it, and
> found out it wasn't to my taste.
ok, you've found a community where the ideals match yours, the level of
'power' in the langauge is enough for you, plus has all the libraries
you ever wanted. Why the hell are you bugging us lispers? :P
Is the answer because, regardless of the amazing amount of libraries,
python is just not up to task? could those libraries only exist because
the language itself is lacking in some way?
Don't worry about offending us lispers, we've heard your style of
argument over and over again.. and yet, people are still coming to lisp
from python, our collection of libraries grows, and we are all fairly
content with the situation as it stands.
This is not an ego thing, its simply that this group is bored with the
same old claptrap. Those of us who like the lisp langauge will address
weaknesses as we discover them, and our libraries will get better. Those
who come looking for a better 'language' and then complain about the
'libraries' will go back to wherever they came, fully content with their
delusions :)
Just for example, when i started developing in Lisp, one of the big
problems (for me) was a lack of good webhosting companies supporting
common lisp. So, I started one. Now i get 2-3 new lisp hosting customers
a month, and lisp no longer lacks friendly hosting companies.
I could have just said "I didn't find a good hosting company, so i'm
going back to Perl". That would have been my loss. Libraries (and
available hosting companies) does not a language make.
--
Drew Crampsie
drewc at tech dot coop
"... the most advanced use of lisp in the field of bass lure sales"
-- Xach on #lisp
drewc wrote:
> ok, you've found a community where the ideals match yours, the level of
> 'power' in the langauge is enough for you, plus has all the libraries
> you ever wanted. Why the hell are you bugging us lispers? :P
I was interested in learning Lisp. It does seem like a powerful
language. I'm just reporting what I see when I dip into Lisp, and I'm
fairly sure it's what others will see, too.
> Is the answer because, regardless of the amazing amount of libraries,
> python is just not up to task? could those libraries only exist because
> the language itself is lacking in some way?
Put it this way. If I want SMTP client support in my script, Python has
it out of the box. People say "that's great, I can do SMTP out of the
box". They don't say "Python is so crap that it has to provide SMTP as a
separate module".
The whole library thing is a lot easier in Python, and indeed the other
big scripting languages, than it is in Lisp. In Python, the whole thing
seems packaged together into a coherent whole, whereas in Lisp, it seems
more like an exercise in trying to put square pegs in round holes.
> I could have just said "I didn't find a good hosting company, so i'm
> going back to Perl". That would have been my loss. Libraries (and
> available hosting companies) does not a language make.
I think we're back to Ray's point that people expect libraries. They're
going to be impressed when they see lots of stuff available right out of
the box, or readily obtainable on the internet. They're not going to be
impressed by "libraries does not a language make".
Lisp has had decades head start over the currently popular scripting
languages. You'd think that it would have the whole
library/compatability situation sorted by now.
drewc wrote:
> Mark Carter wrote:
>> Lisp has had decades head start over the currently popular scripting
>> languages. You'd think that it would have the whole
>> library/compatability situation sorted by now.
>
> ANSI Common Lisp and Python are about the same age (early 90's), and
> Python has a significantly larger number of users. It's like going to an
> indie rock show and complaining that there isn't 30,000 people, t-shirt
> vendors and fast food. If everybody waits until something is popular to
> get involved, it will never get popular.
This wins the award for most misleading (yet technically accurate) post
this week. The standardization effort culminating in the ANSI seal of
approval began in 1981, when there were already several vibrant, active
and long lived dialect-based Lisp communities. How many users did Python
have then? As CL was an amalgam of earlier Lisps, it was relatively easy
(usually... sometimes less so) to port pre-CL Lisp packages to CL. How
much Python software was ported from ABC (Python's predecessor)?
Here's an excerpt from a PowerPointyhead presentation* by Guido Van Rossum:
1995: "Python? What's that?"
1997: "But nobody else uses Python!"
1999: "Where can I hire Pythoneers?"
It seems that at about the time CL was finally affirmed, Python started
life with approximately one user. CL hasn't been updated since, Python
didn't really start growing until the late 1990s and, if one does an
honest comparison, one might say that Python's popularity occurred in
the blink of an eye, Lisp time-wise.
N.B. - I'm not a Python coder. I was already using Perl when Python
began to get popular, and never saw reason to switch. The above was
gleaned from a few quick searches and could be wrong.
* - http://www.python.org/doc/essays/ppt/os99addr/os99addr.PPT
Cameron MacKinnon wrote:
> drewc wrote:
>
>> Mark Carter wrote:
>
>
>>> Lisp has had decades head start over the currently popular scripting
>>> languages. You'd think that it would have the whole
>>> library/compatability situation sorted by now.
>
> >
>
>> ANSI Common Lisp and Python are about the same age (early 90's), and
>> Python has a significantly larger number of users. It's like going to
>> an indie rock show and complaining that there isn't 30,000 people,
>> t-shirt vendors and fast food. If everybody waits until something is
>> popular to get involved, it will never get popular.
>
>
> This wins the award for most misleading (yet technically accurate) post
> this week.
Agreed, and i'm glad someone called me on it :). I'll hang the award on
my wall here.
In my own way, the idea i was getting at is that perhaps popularity is
not a good goal for a programming language. Why is it that a language
that has so many years of development behind it is so easily eclipsed by
the 'next big thing', be it Java, Python, or what have you.
While this may not apply to python, the designers of Java specifically
set out to create a language for the 'average' programmer, meaning
popularity, or the desire to have it, was a motivation when designing
the language. AFAICT (and keep in mind that i am a lisp user here), the
result is a mediocre language (i feel this way about python as well),
and all it really has going for it is that it's widely used (and
therefore has more libraries and support, etc.. catch-22).
OTOH, c.l.l is filled with people coming from python and/or java,
searching for something better, while you probably (i have no evidence
to back this up) don't see too many common lisp users changing to 'a
lesser language' :P.
Perhaps Programming Languages are like art or music, where what is
popular is there simply because it's accessible or 'easy' (or marketed
heavily by men in suits), and the 'good' stuff lies on the fringes.
And maybe it's easier to listen to pop music (just turn on the radio)
than to seek out those rare, hard to find Charles Mingus records. Does
that make the Top 40 hits 'better' than Mingus? To a trained ear, there
is likely no doubt. And the rewards of that hard work.... priceless.
Argument by analogy, i admit. A load of bullshit? more than possible.
Food for thought? almost certainly :).
drewc
> The standardization effort culminating in the ANSI seal of
> approval began in 1981, when there were already several vibrant, active
> and long lived dialect-based Lisp communities. How many users did Python
> have then? As CL was an amalgam of earlier Lisps, it was relatively easy
> (usually... sometimes less so) to port pre-CL Lisp packages to CL. How
> much Python software was ported from ABC (Python's predecessor)?
>
> Here's an excerpt from a PowerPointyhead presentation* by Guido Van Rossum:
>
> 1995: "Python? What's that?"
>
> 1997: "But nobody else uses Python!"
>
> 1999: "Where can I hire Pythoneers?"
>
>
> It seems that at about the time CL was finally affirmed, Python started
> life with approximately one user. CL hasn't been updated since, Python
> didn't really start growing until the late 1990s and, if one does an
> honest comparison, one might say that Python's popularity occurred in
> the blink of an eye, Lisp time-wise.
>
> N.B. - I'm not a Python coder. I was already using Perl when Python
> began to get popular, and never saw reason to switch. The above was
> gleaned from a few quick searches and could be wrong.
>
>
> * - http://www.python.org/doc/essays/ppt/os99addr/os99addr.PPT
--
Drew Crampsie
drewc at tech dot coop
"... the most advanced use of lisp in the field of bass lure sales"
-- Xach on #lisp
drewc wrote:
> OTOH, c.l.l is filled with people coming from python and/or java,
> searching for something better, while you probably (i have no evidence
> to back this up) don't see too many common lisp users changing to 'a
> lesser language' :P.
What is this Python and Java everyone talks about?
There are two programming languages: Lisp and fancily syntaxed
macroexpansions.
Tayssir
Tayssir John Gabbour wrote:
> There are two programming languages: Lisp and fancily syntaxed
> macroexpansions.
Good point. We should really refer to 'McCarthy Completeness' when
discussing the relative power of programming languages, this Turing
stuff is getting us nowhere.
I mean, paper tapes? pffft. Although, FWIW, there is a lot of paper
packaged in some amazing libraries.
--
Drew Crampsie
drewc at tech dot coop
"... the most advanced use of lisp in the field of bass lure sales"
-- Xach on #lisp
drewc <·····@rift.com> writes:
> Argument by analogy, i admit. A load of bullshit? more than
> possible. Food for thought? almost certainly :).
Um, are you telling us to eat shit?
--
http://www.david-steuber.com/
The UnBlog | Lisp on OS X topics for the most part
Click all the links you want. I'll make more!
David Steuber wrote:
> drewc <·····@rift.com> writes:
>
>
>>Argument by analogy, i admit. A load of bullshit? more than
>>possible. Food for thought? almost certainly :).
>
>
> Um, are you telling us to eat shit?
>
Millions of flies can't be wrong.
--
Drew Crampsie
drewc at tech dot coop
"... the most advanced use of lisp in the field of bass lure sales"
-- Xach on #lisp
From: Matthias Buelow
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3qrcnkFgh1n9U1@news.dfncis.de>
drewc <·····@rift.com> wrote:
>And the message is sitting in my inbox. This was not hard at all.
>MEL-BASE is a very complete library for email.
Does it speak TLS, SMTP-AUTH, or ESMTP at least? Many of those
free Lisp libraries that are floating around are something that
someone apparently has hacked together for a particular application
and then bundled up as a standalone thing, but are pretty much
useless in general, because they lack a lot of functionality or are
otherwise defective (like reading files completely into memory or
things like that). Although I agree that "mel-base" might be enough
functionality for something like a WWW content server mailing
a response out directly over smtp.
mkb.
Matthias Buelow wrote:
> drewc <·····@rift.com> wrote:
>
>
>>And the message is sitting in my inbox. This was not hard at all.
>>MEL-BASE is a very complete library for email.
>
>
> Does it speak TLS, SMTP-AUTH, or ESMTP at least?
Do you expect me to read the manual for you?
> Many of those
> free Lisp libraries that are floating around are something that
> someone apparently has hacked together for a particular application
> and then bundled up as a standalone thing, but are pretty much
> useless in general, because they lack a lot of functionality or are
> otherwise defective (like reading files completely into memory or
> things like that).
This is a lisp specific problem? CPAN anyone?
> Although I agree that "mel-base" might be enough
> functionality for something like a WWW content server mailing
> a response out directly over smtp.
Or writing a CLIM based mail reader/composer..., or a pop3 server, or a
spam filter ...
drewc
>
> mkb.
--
Drew Crampsie
drewc at tech dot coop
"... the most advanced use of lisp in the field of bass lure sales"
-- Xach on #lisp
From: Matthias Buelow
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3qsq6bFgco44U1@news.dfncis.de>
drewc <·····@rift.com> wrote:
>> Does it speak TLS, SMTP-AUTH, or ESMTP at least?
>Do you expect me to read the manual for you?
Actually, I have looked at the source before posting, and couldn't
find it. But I might have overlooked something, of course.
>Or writing a CLIM based mail reader/composer..., or a pop3 server, or a
>spam filter ...
A mail client that is intended to mail out via smtp but doesn't
implement tls (or ssl) and smtp-auth is pretty useless these days.
mkb.
From: Christopher C. Stacy
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <u7jcmh4b7.fsf@news.dtpq.com>
Matthias Buelow <···@incubus.de> writes:
> drewc <·····@rift.com> wrote:
>
> >> Does it speak TLS, SMTP-AUTH, or ESMTP at least?
> >Do you expect me to read the manual for you?
>
> Actually, I have looked at the source before posting, and couldn't
> find it. But I might have overlooked something, of course.
>
> >Or writing a CLIM based mail reader/composer..., or a pop3 server, or a
> >spam filter ...
>
> A mail client that is intended to mail out via smtp but doesn't
> implement tls (or ssl) and smtp-auth is pretty useless these days.
A really good SMTP client library would include those, but clearly
your characterization of "pretty useless" is a gross overstatement.
The proof is that people are using this library, which you say
does not have it.
In server environments, most email is unauthenticated; the
client and the server are part of one system (although often
on more than one physical box). They are using IP-based
authentication on their own private network.
So, in fact, this library is extremely useful,
both in theory, and by proof of existance.
Once again, you come along and troll, suggesting that you
can't get your work done with Lisp. Quite boring and lame.
Go to therapy. Get some drugs. Leave us the fuck alone here.
From: Matthias Buelow
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3qth1hFgm5lvU1@news.dfncis.de>
Christopher C. Stacy <······@news.dtpq.com> wrote:
>Once again, you come along and troll, suggesting that you
>can't get your work done with Lisp. Quite boring and lame.
Nonsense, I've never stated that, despite having quite some time
ago given up trying to get work done with Common Lisp, because the
status quo is (imho) not such as to provide a useful development
environment. I guess in your troll-paranoid dazzlement, you have
just mixed up the arguments from a number of people who you label
as "trolls", and simply attribute to all of them what one of them
might've (or could've) said. Apart from that, I'm always interested
in discussing languages and would of course see Lisp develop.
However, instead of development, what we see (at least on this
newsgroup from a number of people) is fundamentalism; like in some
kind of orthodox religion, the word-by-word veracity and supremacy
of the scripture is considered holy and undebatable and more important
than considering the usefulness or harmfullness of its application
to individuals, and anyone who wants to discuss it, is stamped a
heretic and given a virtual stoning. I've read similar discussions
7, 8 years ago on this newsgroup, and the only difference to now
seems to be that the psychopath Naggum is apparently gone for good
now, which, admittedly, is quite an advancement to the general tone
already.
mkb.
From: Christopher C. Stacy
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <ur7auw47d.fsf@news.dtpq.com>
Matthias Buelow <···@incubus.de> writes:
> Christopher C. Stacy <······@news.dtpq.com> wrote:
>
> >Once again, you come along and troll, suggesting that you
> >can't get your work done with Lisp. Quite boring and lame.
>
> Nonsense, I've never stated that,
The part you have clipped above is your suggestion that Lisp
isn't good for getting things done, with a bogus example.
Now you admit that you weren't even trying to use Lisp,
just hunting around for some excuse to dissuade other
people who would like to learn and use Lisp.
> despite having quite some time
> ago given up trying to get work done with Common Lisp,
Now you're being honest.
> Apart from that, I'm always interested in discussing languages
> and would of course see Lisp develop.
You would like to come here and waste people's time, spread
misinformation, and dissuade newbies from learning things
from people who want to help them.
Go far away and die.
From: Matthias Buelow
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3qu0c2Ffnnl5U1@news.dfncis.de>
Christopher C. Stacy <······@news.dtpq.com> wrote:
>The part you have clipped above is your suggestion that Lisp
>isn't good for getting things done, with a bogus example.
No, you're hallucinating. Mr. Carter explained in his article, that
with the P-language, he gets SMTP support "out of box", because it
is supplied with its libraries. Then "Drewc" answered, in a rather
condescending way, that this is the same with Common Lisp, and gave
the example of mel-base, installable via asdf. And when I pointed
out, then, that the cited CL example is lacking important functionality
(in contrast to the P-language library, which supports TLS, SMTP-AUTH,
etc.), and hence is not really comparable, I get ultimately get
abuse like the following:
>Go far away and die.
Of course that is something that one must be able to deal with,
when reading c.l.l.
From: Christopher C. Stacy
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <uirw6w0g8.fsf@news.dtpq.com>
Matthias Buelow <···@incubus.de> writes:
[typical misleading sack of crap]
Die faster, please.
······@news.dtpq.com (Christopher C. Stacy) writes:
> Matthias Buelow <···@incubus.de> writes:
> [typical misleading sack of crap]
>
> Die faster, please.
Which is to say, just come here rejoin the dead language!
--
"By filing this bug report you have challenged the honor of my
family. Prepare to die!"
Matthias Buelow <···@incubus.de> writes:
> Christopher C. Stacy <······@news.dtpq.com> wrote:
>
> >The part you have clipped above is your suggestion that Lisp
> >isn't good for getting things done, with a bogus example.
>
> No, you're hallucinating. Mr. Carter explained in his article, that
> with the P-language, he gets SMTP support "out of box", because it
> is supplied with its libraries. Then "Drewc" answered, in a rather
> condescending way, that this is the same with Common Lisp, and gave
> the example of mel-base, installable via asdf. And when I pointed
> out, then, that the cited CL example is lacking important functionality
> (in contrast to the P-language library, which supports TLS, SMTP-AUTH,
> etc.), and hence is not really comparable, I get ultimately get
> abuse like the following:
So add the missing functionality already. Contribute. Seriously, the
CL ecosystem needs contributors more than it needs casual downloaders.
Best,
Thomas
--
Thomas Lindgren
"It's becoming popular? It must be in decline." -- Isaiah Berlin
Matthias Buelow wrote:
> Christopher C. Stacy <······@news.dtpq.com> wrote:
>
>
>>The part you have clipped above is your suggestion that Lisp
>>isn't good for getting things done, with a bogus example.
>
>
> No, you're hallucinating. Mr. Carter explained in his article, that
> with the P-language, he gets SMTP support "out of box", because it
> is supplied with its libraries. Then "Drewc" answered, in a rather
> condescending way, that this is the same with Common Lisp, and gave
> the example of mel-base, installable via asdf. And when I pointed
> out, then, that the cited CL example is lacking important functionality
> (in contrast to the P-language library, which supports TLS, SMTP-AUTH,
> etc.), and hence is not really comparable,
You are right. I had previously looked at CL-SMTP, which actually works
with a server that doesn't require authentication, but doesn't work when
the server requires authentication. I wasn't aware of MEL-BASE, but I
installed it, and couldn't see, offhand, that it provided
authentication. It is something that I may investigate more deeply. I
didn't want to bring this up before, as there seemed to be enough blood
on the carpet as it is. There does seem to be a contingent of fractious
people on this newsgroup ...
>>Go far away and die.
From: drewc
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <434B0FF8.5020002@rift.com>
Mark Carter wrote:
> You are right. I had previously looked at CL-SMTP, which actually works
> with a server that doesn't require authentication, but doesn't work when
> the server requires authentication. I wasn't aware of MEL-BASE, but I
> installed it, and couldn't see, offhand, that it provided
> authentication.
If you are using slime, (or have read the documentation) you'll notice
that the make-smtp-relay-folder function has keyword args for username
and password. I'm not sure if ssl/tls is supported (and from a quick
grep of the source code, it doesn't seem so), but besides that, mel-base
seems to be very complete.
If you need ssl, do your best to implement it. I'm sure there will be
lots of people willing to help, and the end result would probably be
used by many!
> It is something that I may investigate more deeply. I
> didn't want to bring this up before, as there seemed to be enough blood
> on the carpet as it is. There does seem to be a contingent of fractious
> people on this newsgroup ...
I hope didn't come off as overly 'fractious', but i get a little peeved
when people just expect libraries to work, for free, when we are
obviously dealing with a non-mainstream language here. I'm reminded of
the linux nay-sayers from 10 years ago or so, who's mantra was something
along the lines of "There are no applications for linux, so why should i
develop linux applications".
Some people stuck it out, contributed, and got linux and the Free
Software applications to the point where they are today. It could never
have happened without the help of many programmers donating their time.
People are so spoiled by it all that they've come to expect high quality
software to be given to them. It's important to realize that software
does not write itself.
--
Drew Crampsie
drewc at tech dot coop
"... the most advanced use of lisp in the field of bass lure sales"
-- Xach on #lisp
Matthias Buelow <···@incubus.de> writes:
> Christopher C. Stacy <······@news.dtpq.com> wrote:
>
> >Once again, you come along and troll, suggesting that you
> >can't get your work done with Lisp. Quite boring and lame.
>
> Nonsense, I've never stated that, despite having quite some time
> ago given up trying to get work done with Common Lisp, because the
> status quo is (imho) not such as to provide a useful development
> environment. I guess in your troll-paranoid dazzlement, you have
> just mixed up the arguments from a number of people who you label
> as "trolls", and simply attribute to all of them what one of them
> might've (or could've) said. Apart from that, I'm always interested
> in discussing languages and would of course see Lisp develop.
> However, instead of development, what we see (at least on this
> newsgroup from a number of people) is fundamentalism; like in some
> kind of orthodox religion, the word-by-word veracity and supremacy
> of the scripture is considered holy and undebatable and more important
> than considering the usefulness or harmfullness of its application
> to individuals, and anyone who wants to discuss it, is stamped a
> heretic and given a virtual stoning. I've read similar discussions
> 7, 8 years ago on this newsgroup, and the only difference to now
> seems to be that the psychopath Naggum is apparently gone for good
> now, which, admittedly, is quite an advancement to the general tone
> already.
Things are moving forward. The pace may be slower than a lot of
people like. Certainly with all the buzz, it would be nice to make it
easier for the newbies to find what they want in less time without
having to ask the same questions over and over. (Any ideas on how to
do that?)
Keep in mind that there are not that many people who are actually
working on the free Lisp implementations. So far as I know, everyone
who is is doing it in their spare time with no outside funding. I
would like to hear if I am wrong in this. I am aware that Clozure
uses OpenMCL professionally, so that can count as a funded free Lisp
perhaps.
Free software in general is about scratching an immediate itch. If
you need an SMTP library to talk to your local MTA, you don't need
many of the bells and whistles that SMTP supports because the MTA will
do that for you. I'm sure using the SMTP library Drew talked about is
a heck of a lot simpler than shelling out to mail. I am not aware of
Perl's SMTP client being any more useful. When you send mail to the
outside world, you need to start from an MTA with an MX or A record
anyway. Most MTA's won't talk to you otherwise as a defense against
spam.
SLIME represents a considerable improvement in what was available in
development environments just a couple years ago. I would credit the
existence of SLIME as the key factor in me actually getting down and
coding in Lisp rather than simply talking about it.
Currently it does take a bit more dedication to hack in Lisp than in
Perl or Python. Perhaps this is a bad thing. OTOH, there is a widely
held belief that VB has lowered the bar too much for people to get
into hacking. Some assembly is required. Then again, if you want the
convenience of VB, you have to pay Microsoft $$$ for it. Franz and
Lispworks provide gratis trials of their products. You could even
spring the money for a professional version (just like you would do
for Dev Studio .NET We Have You Now). Free software has never been as
polished as the proprietary stuff.
Lisp is clearly not for everyone. Those who really work with it do
get stuff done though. So don't blame them when people complain that
you can't do anything in Lisp and they push back.
If you t figure out how to build and install a free software package
on your own, you probably have no business using it.
--- Andrew Choi
http://www.sixthhappiness.ca/blog/2004/09-12/index.html#5
--
http://www.david-steuber.com/
The UnBlog | Lisp on OS X topics for the most part
Click all the links you want. I'll make more!
David Steuber wrote:
> Matthias Buelow <···@incubus.de> writes:
> Free software in general is about scratching an immediate itch. If
> you need an SMTP library to talk to your local MTA, you don't need
> many of the bells and whistles that SMTP supports because the MTA will
> do that for you. I'm sure using the SMTP library Drew talked about is
> a heck of a lot simpler than shelling out to mail. I am not aware of
> Perl's SMTP client being any more useful. When you send mail to the
> outside world, you need to start from an MTA with an MX or A record
> anyway. Most MTA's won't talk to you otherwise as a defense against
> spam.
I've had a twiddle about with telnet, and to my delight, I managed to
get my yahoo mail to accept an email from me, with authentication. Now I
know a bit more about how the protocol works, I'm thinking of tweaking
CL-SMTP to support authentication.
Mark Carter wrote:
> I've had a twiddle about with telnet, and to my delight, I managed to
> get my yahoo mail to accept an email from me, with authentication. Now I
> know a bit more about how the protocol works, I'm thinking of tweaking
> CL-SMTP to support authentication.
That's the spirit! (although mel-base supports it out-of-the-box).
--
Drew Crampsie
drewc at tech dot coop
"... the most advanced use of lisp in the field of bass lure sales"
-- Xach on #lisp
From: Christian Lynbech
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <87achgkqld.fsf@chateau.defun.dk>
>>>>> "Matthias" == Matthias Buelow <···@incubus.de> writes:
Matthias> ... quite some time ago given up trying to get work done
Matthias> with Common Lisp, because the status quo is (imho) not such
Matthias> as to provide a useful development environment.
As one who find current lisp development environments lightyears ahead
of the competition, I would be curious to hear a little more about
what is lacking vis-a-vis pointers to development that you do find
useful?
------------------------+-----------------------------------------------------
Christian Lynbech | christian ··@ defun #\. dk
------------------------+-----------------------------------------------------
Hit the philistines three times over the head with the Elisp reference manual.
- ·······@hal.com (Michael A. Petonic)
From: Matthias Buelow
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3r27o1Fh6b67U1@news.dfncis.de>
Christian Lynbech <·········@defun.dk> wrote:
>As one who find current lisp development environments lightyears ahead
>of the competition, I would be curious to hear a little more about
>what is lacking vis-a-vis pointers to development that you do find
>useful?
Check Google Groups, please. This is not meant to be impolite but
I'm sure any argument would kick up a heated (and unnecessary)
discussion.
mkb.
Mark Carter <··@privacy.net> writes:
> Robert Uhl wrote:
>
> > A newbie evaluation languages sees one language with lots and lots of
> > support and another without; certainly he can't reasonably demand that
> > other folks give him what he wants, but when one group does so and
> > another doesn't, he can reasonably choose to go with the former.
>
> EXACTLY!
>
> People who have a spark of interest in Lisp (or any other language)
> don't set about to hate it, they set about to like it. They hear about
> all the cool stuff it does better than other languages, and are keen
> to try it out. they see good things, they see bad. It's not about
> baiting Lispers, or anything like that.
>
> One of the bad things they see with Lisp in particular is the
> fragmentation, where trying to get working libraries for their
> platform and implementation are toothgrindingly difficult. They
> eventually ask themselves "what's the bloody point", and go back to
> doing whatever it was they were doing before they arrived.
Experienced lispers here repeatedly tell you that this is not how they
see it though. So who is more likely to be wrong: the experienced
lisper or the newbie? Perhaps you ought to adjust your reality or
stick to some language that you like.
Björn
Björn Lindberg wrote:
> Mark Carter <··@privacy.net> writes:
>
> >
> > One of the bad things they see with Lisp in particular is the
> > fragmentation, where trying to get working libraries for their
> > platform and implementation are toothgrindingly difficult. They
> > eventually ask themselves "what's the bloody point", and go back to
> > doing whatever it was they were doing before they arrived.
>
> Experienced lispers here repeatedly tell you that this is not how they
> see it though. So who is more likely to be wrong: the experienced
> lisper or the newbie?
Whos is more likely to be wrong about the experience of coming to lisp
as a newbie today? I think it's the experienced lisper.
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3qvrh5Fgv77dU1@individual.net>
··············@gmail.com wrote:
> Bj�rn Lindberg wrote:
>
>>Mark Carter <··@privacy.net> writes:
>>
>>
>>>One of the bad things they see with Lisp in particular is the
>>>fragmentation, where trying to get working libraries for their
>>>platform and implementation are toothgrindingly difficult. They
>>>eventually ask themselves "what's the bloody point", and go back to
>>>doing whatever it was they were doing before they arrived.
>>
>>Experienced lispers here repeatedly tell you that this is not how they
>>see it though. So who is more likely to be wrong: the experienced
>>lisper or the newbie?
>
> Whos is more likely to be wrong about the experience of coming to lisp
> as a newbie today? I think it's the experienced lisper.
Common Lisp is not designed for newbies. Yes, it's hard to learn and
sometimes not straightforward to use. You have to put some effort into
learning the language and the infrastructure. The reward comes much
later than in other languages, but the chances are high that the reward
is much higher. Of course, noone can guarantee this either. It's
everyone's own decision how far one goes, how much one invests into
learning it. Noone promised you that it will be easy.
There are enough languages out there that promise you to be simple and
straightforward to use. IMHO, they just push the complexity somewhere
else, which will hurt you later on (or they just provide programming by
numbers). Don't blame Lispers for the false promises that you have been
indoctrinated with. Programming is hard.
If you think you have been misled into thinking that Lisp is simple and
straightforward to use, show us the URL, book, or whatever, that makes
that claim.
Pascal
"Only the creatively intelligent can prosper in the Lisp world." -
Richard Gabriel
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
A language benefits from more users, and one of the goals of any
general purpose language should be that it wants users of all
abilities. For that reason I think it's a big mistake to tell users
that it's hard to learn lisp, and that they will have to mess around
and work hard just to get basic things working.
Peter Siebel's lisp box is exactly the kind of thing new users need, so
they can get started on messing around with lisp with a one download,
zero set up system. I use emacs/slime/clisp and asdf but it was weeks
into my learning lisp experience that I found all that stuff.
http://www.gigamonkeys.com/book/lispbox/
We need more initiatives like this, and tutorials and walkthoughs like
this one...
http://www.lisperati.com/casting.html
I don't think it's easy to become an expert lisp programmer, but I do
think it's easy to learn enough to have fun and write useful programs.
On Mon, 10 Oct 2005 13:03:12 -0700, justinhj wrote:
> A language benefits from more users, and one of the goals of any general
> purpose language should be that it wants users of all abilities. For
> that reason I think it's a big mistake to tell users that it's hard to
> learn lisp, and that they will have to mess around and work hard just to
> get basic things working.
Sounds like what some Unixers say.
Well I'm a windows user but what's your point?
Gnu/Linux has got to a point where large numbers of less technical folk
can get by using it. Perhaps that's what you mean?
On Tue, 11 Oct 2005 05:53:11 -0700, justinhj wrote:
> Well I'm a windows user but what's your point?
I was pointing out the " it's hard to learn lisp, and that they will have
to mess around and work hard just to get basic things working" aspect.
This whole thing kind of reminds me of the battle between the CLIers and
the GUIers.
There's something people need to keep in mind in this discussion. Newbie
and expert is a snapshot of a continuum. Complexity as an aspect of
learning can be handled through progressive disclosure. Kind of like
learning how to ride a bike with training wheels. Once you outgrow the
wheels, you don't throw away the bike. You take the wheels off and
continue on.
From: Peter Seibel
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m2zmph110u.fsf@gigamonkeys.com>
Pascal Costanza <··@p-cos.net> writes:
> Common Lisp is not designed for newbies.
That bit is true ...
> Yes, it's hard to learn and sometimes not straightforward to
> use.
... but I disagree that it's hard to learn. I don't think it's any
harder to learn the basics of Common Lisp than any other language (and
easier than many because of it's many regularities) as long as one is
willing to open one's mind to new ways of thinking about things. In
fact I wrote a whole book based on this premise.
Now, it is true that once you've learned the basics of Common Lisp
there's still a lot *more* to learn while with some other languages
you've hit the end of the road and now have to spend the rest of your
life learning how to mangle your problems so they fit within the
straitjacket of the language. But as long as you approach the material
in the right order and have some guidence about what to save for later
it's not so bad.
Similarly, to the extent that it's sometimes not straightforward to
use that's simply because it gives you more degrees of freedom than
most other languages and therfore requires better taste and judgement
to use well.
> You have to put some effort into learning the language and the
> infrastructure. The reward comes much later than in other languages,
I disagree with that too. The rewards start right away; they just
don't *stop* as soon.
> but the chances are high that the reward is much higher. Of course,
> noone can guarantee this either. It's everyone's own decision how
> far one goes, how much one invests into learning it. Noone promised
> you that it will be easy.
>
> If you think you have been misled into thinking that Lisp is simple
> and straightforward to use, show us the URL, book, or whatever, that
> makes that claim.
<http://www.gigamonkeys.com/book/> ;-)
-Peter
--
Peter Seibel * ·····@gigamonkeys.com
Gigamonkeys Consulting * http://www.gigamonkeys.com/
Practical Common Lisp * http://www.gigamonkeys.com/book/
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3r1kq4Fh3ks0U1@individual.net>
Peter Seibel wrote:
> Pascal Costanza <··@p-cos.net> writes:
>
>>Common Lisp is not designed for newbies.
>
> That bit is true ...
>
>>Yes, it's hard to learn and sometimes not straightforward to
>>use.
>
> ... but I disagree that it's hard to learn. I don't think it's any
> harder to learn the basics of Common Lisp than any other language (and
> easier than many because of it's many regularities) as long as one is
> willing to open one's mind to new ways of thinking about things. In
> fact I wrote a whole book based on this premise.
It seems to me that I need to clarify my statement. (I am responding to
you while I could have as well responded to Arthur or Justin - that's
just random, and not because you're an author of a good book... ;)
There is a pattern that I think one can recognize with many programming
languages: They start out simple in the beginning but become more and
more complex over time. The idea of making them simple in the beginning
is always motivated by ideas like "making them easier to learn for
newbies", "capturing only the important stuff that is needed 80% of the
time", "making it easier to write simple programs, like scripts or
queries", etc.
Take Java as an example (that's the one I happen to know best): When it
was first published, it had a very simple object model, only slightly
more complicated than Smalltalk, promoted a very specific deployment
scenario (applets, does anyone remember? ;), and worked quite well right
out of the box. It also had the fortunate advantage that it was released
at a time when it's crappy performance characteristics didn't really
matter anymore because computers have started to become fast enough to
compensate for the lack of efficiency - and it also didn't show that
much in the toy examples that one could write with Java back then. They
also made sure that Java provided very early rewards by providing
example code that you could compile and run right out of the box.
Most importantly, though, for the discussion at hand, the language was
relatively small, relatively easy to grasp and quick to learn, at least
in comparison to the mainstream languages of that time, and there was
practically no way opportunity to shoot yourself in the foot with
anything. In short: It was designed specifically for newbies.
However, Java's simplicity changed considerably over time. The
separation of objects and primitive data types should have already been
a warning sign (it was inherited from C++ where it had some
justification because of efficiency concerns which didn't really make
any sense in Java). However, it became worse over time. In JDK 1.1 they
added inner classes, but with the restriction that you can only close
over final variables. Inner classes are somewhat useful, but they could
have been more useful by closing over anything. (They had a full
implementation at Sun, but this was voted down because of worries over
decreased efficiency for variables closed over by inner classes.)
Then they had a relatively neat design for generic types, however they
were required not to change the JVM specification for generic types, so
they had to make some compromises. Yet, generic types were voted down
because they were deemed to complicated. It was only because of pressure
created by the development of C# that they reconsidered, however, in the
meantime they had enough opportunities to really fuck up the generic
types. (Remember, all in the name of making programs safer so that
average programmers cannot do much harm.)
Now that we arrived at JDK 5.x, Java has finally become a really complex
mess. You really have to be an expert to program in Java, yet you don't
get the same rewards of being an expert as in other languages. For
example, being an expert in C++ buys you control over really low-level
details of a machine while having a relatively high-level language
available at the same time. In Java, all you get is Java.
If you want to know what I mean by complexity, for example take a look
at the specification for integrating generic types into AspectJ 5 at
http://www.eclipse.org/aspectj/doc/next/adk15notebook/generics-inAspectJ5.html
- this is what you get when a language doesn't provide macros or some
other reasonably powerful reflective facilities.
I really think there is a pattern here. You can see similar developments
in other languages that start out simple/simplistic but ultimately
become much more complicated than if they had been more comprehensive
from the very beginning. Currently, we see something similar going on
with Ruby on Rails: At the moment, it seems to be much simpler than
other approaches, but my prediction is that it will become at least
comparably complex in a few years.
There is a reason why that's the case: Ultimately, we want to build
complex systems, and the complexity has to go _somewhere_. If a language
doesn't provide means to directly express a certain level of complexity,
but for example tries to force everything in a single paradigm, you are
ultimately forced to push the complexity into libraries. Or the language
will be extended in ways that are not compatible with the original
paradigm, and this will lead to integration problems at the boundaries
between the various layers.
Lisp is very different in this regard. Lisp was never designed to be a
simple language to be easy to learn for newbies or to program simple
applications in it. It was designed (among other things) to express a
theory of computations, to be able to write a metacircular interpreter.
Lisp's syntax was primarily developed for the internal representation of
a "full" language that never materialized. The metacircular interpreter
gives us an extremely high degree of extendibility, and the syntax a
straightforward access to that extendibility (indirectly via macros and,
to a certain degree, reflection).
Yes, it's true that you can use Common Lisp to write simple programs
that never touch that dimension. That's because Common Lisp comes with a
lot of extensions already built in. But the extendibility that is
available in the language is also reflected even in such simple
programs. This becomes apparent when you try to teach the language, or
write a book about it: There are lots of examples where you can explain
concepts only in terms of other concepts that you can only explain later.
That's why I stand by my claim that Lisp is harder to learn than other
languages - because it is mostly concerned with extendibility that you
can only really take advantage of as an expert Lisp programmer and that
other languages don't even touch.
Finally, to make this really clear: I think a language that is designed
for complex tasks from the ground up is the Right Thing (tm), and that
dumbing a language down so that it becomes easier to learn, teach or
write books about in order to become immensely rich is the wrong way to
go. What's rather needed are better didactics, but that's hard to come
up with for a discipline that is roughly only 50 years old, which is
still extremely young. There is a lot of work to do in that area, but
it's necessary. It's not likely that systems will become less complex,
but rather to the contrary...
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
Pascal Costanza wrote:
> Yes, it's true that you can use Common Lisp to write simple programs
> that never touch that dimension. That's because Common Lisp comes with a
> lot of extensions already built in. But the extendibility that is
> available in the language is also reflected even in such simple
> programs. This becomes apparent when you try to teach the language, or
> write a book about it: There are lots of examples where you can explain
> concepts only in terms of other concepts that you can only explain later.
>
> That's why I stand by my claim that Lisp is harder to learn than other
> languages - because it is mostly concerned with extendibility that you
> can only really take advantage of as an expert Lisp programmer and that
> other languages don't even touch.
My uneasy feeling about this comes from my belief that Lisp's
expandability is more understandable, not less.
But... mainstream languages act as filters, filtering out those who
expect more from computing.
The abstractions of normal languages don't make much sense. Lisp has
blobs of code which can be evaluated -- that kinda makes sense to me.
Those blobs can also be input to other blobs.
The other languages have these syntaxes -- why are they the way they
are? Should I be suspicious that they're sometimes so awkward? Why is
code itself the computing object I can't easily manipulate with code?
I think Lisp implies a different education model. Instead of someone
being TRAINED, where you're stamped with tool-using ability, Lisp
allows EDUCATION, which is about people helped to grow into knowledge.
Directed by internal interests.
Just like schools. Some exist to foster creativity, and give children
the ability to explore, interactively. Others are to stamp children
with knowledge for a job. Filtering them for their proper societal
roles.
Tayssir
From: Greg Menke
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m3fyr8jku0.fsf@athena.pienet>
"Tayssir John Gabbour" <···········@yahoo.com> writes:
> Pascal Costanza wrote:
>
> I think Lisp implies a different education model. Instead of someone
> being TRAINED, where you're stamped with tool-using ability, Lisp
> allows EDUCATION, which is about people helped to grow into knowledge.
> Directed by internal interests.
>
> Just like schools. Some exist to foster creativity, and give children
> the ability to explore, interactively. Others are to stamp children
> with knowledge for a job. Filtering them for their proper societal
> roles.
Which is the programming language of the Morlock, and of the Eloi?
Gregm
Greg Menke <············@toadmail.com> writes:
> Which is the programming language of the Morlock, and of the Eloi?
I don't get this question. The Eloi were simply cattle for the
Morlock.
--
http://www.david-steuber.com/
The UnBlog | Lisp on OS X topics for the most part
Click all the links you want. I'll make more!
David Steuber wrote:
> Greg Menke <············@toadmail.com> writes:
> > Which is the programming language of the Morlock, and of the Eloi?
>
> I don't get this question. The Eloi were simply cattle for the
> Morlock
Greg may be referring to Neal Stephenson's "In the Beginning was the
Command Line":
http://artlung.com/smorgasborg/C_R_Y_P_T_O_N_O_M_I_C_O_N.shtml
which has an extended analogy involving Eloi and Morlocks which is
somewhat less
stark than Wells'.
--
Randall Randall <·······@randallsquared.com>
"Randall Randall" <·······@randallsquared.com> writes:
> David Steuber wrote:
> > Greg Menke <············@toadmail.com> writes:
> > > Which is the programming language of the Morlock, and of the Eloi?
> >
> > I don't get this question. The Eloi were simply cattle for the
> > Morlock
>
> Greg may be referring to Neal Stephenson's "In the Beginning was the
> Command Line":
> http://artlung.com/smorgasborg/C_R_Y_P_T_O_N_O_M_I_C_O_N.shtml
>
> which has an extended analogy involving Eloi and Morlocks which is
> somewhat less
> stark than Wells'.
After reading the article, I would say that some dialect of Lisp is
for the Morlocks and the chum, I mean Eloi, go for VB (not that they
understand such things as pushing buttons).
--
http://www.david-steuber.com/
The UnBlog | Lisp on OS X topics for the most part
Click all the links you want. I'll make more!
One of the reasons Java proliferated, I beleive, was that from day one
you had a two downloads to make... the jdk and the help files. The help
files completely documented the system (like the cl hyperspec does of
course), plus you had a bunch of examples that did useful stuff simply,
especially gui stuff.
Plus you could make applets that more or less ran everywhere whether
you sent the source or the class files.
If lisp was in that position now I'm sure it could grow its user base
much more quickly.
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3r1s2bFh69auU1@individual.net>
justinhj wrote:
> One of the reasons Java proliferated, I beleive, was that from day one
> you had a two downloads to make... the jdk and the help files. The help
> files completely documented the system (like the cl hyperspec does of
> course), plus you had a bunch of examples that did useful stuff simply,
> especially gui stuff.
>
> Plus you could make applets that more or less ran everywhere whether
> you sent the source or the class files.
>
> If lisp was in that position now I'm sure it could grow its user base
> much more quickly.
It's important to note that these are secondary characteristics, and
don't tell you anything about the language per se!
In Richard Gabriel's book "Patterns of Software", he describes a theory
about what makes languages popular. (see
http://www.dreamsongs.com/NewFiles/PatternsOfSoftware.pdf in the Section
"The End of History and the Last Programming Language" - page 122ff)
"There are four parts to the theory:
* Languages are accepted and evolve by a social process, not a techincal
or technological one.
* Successful languages must have modest or minimal computer resource
requirements.
* Successful languages must have a simple performance model.
* Successful languages must not require users have "mathematical
sophistication."
He continues to state that his theory "is that a number of factors
enable a language to flourish:
* The language must be available on a wide variety of hardware.
* It helps to have local wizards or gurus for the language.
* It must be a minimally acceptable language.
* It must be similar to existing popular languages."
He then analyzes a number of languages popular at the time when the book
was written (1996) and makes some predictions, and the model seems to
work well (including the predictions).
I think that the bullets "minimal computer resource requirements" and
"wide variety of hardware" are not as valid anymore, but apart from that
the model still seems to hold.
Again, it is important to note that _all_ of these criteria are
secondary, non-technical criteria. There is no talk about
expressiveness, well-suitedness for specific tasks, productivity,
adaptibility, and so on.
My overall impression of the Lisp community is that Lispers strongly
prefer to focus on such technical issues rather than the social issues.
On the one hand, that probably explains well why "Lisp is not popular
with average programmers" (see subject line), but on the other hand, the
technical qualities of a language are what will eventually get your work
done, so they are _indeed_ more important.
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
Yes, so my point is, if a language is better in that it is more
expressive, more powerful and more able to deal with whatever you throw
it, then lets make it more popular by giving people the great
introduction to it that java gave to me.
I've been using lisp regularly for nearly a year now and it's the first
thing I go to if I want to knock out a quick tool or just do some
calculations. But I haven't been able to draw a single pixel or a hello
world gui window despite many hours messing around with asdf and
various downloads.
Last night is case in point. I decided to install cl-pdf and have a
play with that. The asdf install failed, finding bad characters in some
of the files. I've got to report a bug about that, but I'll probably be
told I'm using the wrong OS again.
From: Ulrich Hobelmann
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3r20a5Fgl4v5U1@individual.net>
justinhj wrote:
> One of the reasons Java proliferated, I beleive, was that from day one
> you had a two downloads to make... the jdk and the help files. The help
> files completely documented the system (like the cl hyperspec does of
> course), plus you had a bunch of examples that did useful stuff simply,
> especially gui stuff.
I think there were a couple of reasons, all very cheap:
* Java was OO. Other languages were, too, but Java was "simple"
* Java could do Internet ;)
* Java could do shiny point-and-grunt interfaces (applets)
* Java was build-once-run-$anywhere (for small values of $anywhere)
This blinded people into accepting it, despite major childhood problems
of the language.
--
State, the new religion from the friendly guys who brought you fascism.
From: Marcus Breiing
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <o6stezxtdgklx@breiing.com>
* Pascal Costanza
> That's why I stand by my claim that Lisp is harder to learn than other
> languages - because it is mostly concerned with extendibility that you
> can only really take advantage of as an expert Lisp programmer
So what you're claiming isn't that it's hard to get to a point with CL
that you could just as well reach with Python or C#, but that it _is_
hard to get to the point where CL starts to actually be more powerful
than those languages?
If that's your claim, I'd tend to agree. In fact, I don't know if -
given the current state of the CL "ecology" - it's worth learning and
using CL unless you plan to make substantial use of the kind of
abstraction afforded by nontrivial macrology or MOPology.
If you look at writing nontrivial macros, it becomes clear that you
need a good grasp of a lot of the "insides" of how the language works
if you don't want to shoot yourself in the foot all the time.
Multiple evaluation, evaluation order, scope of bindings, name
capture, (nil-)block capture. I probably forgot another ten things to
keep in mind when writing a macro.
Put in another way: One of the things that make a language easy to use
is a set of powerful orthogonal features. CL has a lots of those, but
so do other languages. However, when entering the metalinguistic level
(which is what makes CL powerful) in a sense you're now wearing the
implementor's hat. Those powerful orthogonal features become
something you have to provide (or, at least, preserve), instead of
just something you take advantage of.
So... yes, I agree it's true that it's hard to learn CL up to the
level of its greatest advantage, instead of only up to a level where
you could just as well be using Python, Perl, Java or C# and profit
from much better infrastructure.
Marcus
Marcus Breiing <······@2005w40.mail.breiing.com> wrote:
> * Pascal Costanza
>
> > That's why I stand by my claim that Lisp is harder to learn than other
> > languages - because it is mostly concerned with extendibility that you
> > can only really take advantage of as an expert Lisp programmer
>
> So what you're claiming isn't that it's hard to get to a point with CL
> that you could just as well reach with Python or C#, but that it _is_
> hard to get to the point where CL starts to actually be more powerful
> than those languages?
>
> If that's your claim, I'd tend to agree. In fact, I don't know if -
> given the current state of the CL "ecology" - it's worth learning and
> using CL unless you plan to make substantial use of the kind of
> abstraction afforded by nontrivial macrology or MOPology.
I actually disagree, or sort of disagree.
I disagree in theory, but agree in practice. There's nothing inherent
in the language that makes it harder to learn for normal purposes. And
in fact, I think if you're going to do a *lot* of programming once
you've reinvented the necessary wheels, I think it's worth learning CL
even if you never need to use nontrivial macrology or MOPology.
I find it much easier to program in CL. I don't think I've ever written
anything I couldn't have accomplished in C or some other language, but
it's just been more fun, less time consuming and less frustrating.
CL is the language of "Why shouldn't I be able to do that?" All my life
as a computer user and programmer I've thought that about everything I
encountered. There's always a further abstraction I want to make that
whatever language or application or framework I was using couldn't
handle, and it would be *far* too much work to make it handle. Learning
CL I had the joyous experience of asking that question and having the
answer be "Oh! I can!" more times than I could count. And many times
that it didn't work the way I wanted, it turns out there's a way to
*make* it work, that doesn't involve extending the compiler internals.
In my experience, the benfits of this are felt long before you enter the
realm of programming constructs that can't be duplicated in other
languages without massive greenspunning.
They are felt the first day you write something that uses bignums
effortlessly. The first time you write a program that is made much
simpler by garbage collection and run time typing, but actually requires
semi-reasonable performance.
You hit the wall when you run into a project that C/Java/whatever would
have a complete up to date library for and CL just doesn't. So if you
want the benefits of CL, you're stuck researching a low-level problem
that you'd rather not bother with.
I am very confident that if CL had the quantity of easy to find, up to
date libraries that one sees for the most popular languages, that it
would *far* easier for newbies to learn than the most popular languages.
At least for the kind of newbies that are likely to ever get anything
out of it.
Which is a good reason that every lisper who is unhappy with the number
of users should do some significant work on at least one good free
open-source extension.
Michael
Pascal Costanza <··@p-cos.net> wrote an interesting account
of the life cycle of languages, focusing on the accumulation
of complications, using JAVA as an example.
Then he repeated the controversial bit:
> Lisp was never designed to be a simple language to be easy
> to learn for newbies or to program simple applications in
> it.
True. Lisp was designed by experts for their own personal use.
> There are lots of examples where you can explain
> concepts only in terms of other concepts that you can only explain later.
>
> That's why I stand by my claim that Lisp is harder to learn than other
> languages - because it is mostly concerned with extendibility that you
> can only really take advantage of as an expert Lisp programmer and that
> other languages don't even touch.
I'm unconvinced by this. I would be more persuaded by a
tracing of a causal chain from a concept through to it
causing trouble for a beginner. I think this would be a
difficult argument to make because the argument would not
work if it used a computer science concept that would cause
a beginner grief whatever programming language they were
learning
Let me suggest a causal chain that goes the other way.
Lisp's greatest claim to fame is as the first practical
programmable programming language. Experts use Lisp for
meta-programming. This whole approach is hugely
controversial. You are working in a team and reading a
colleague's code. He has made use of defmacro, adding new
constructs to the language. What are the semantics of his
constructs? If he has named them using the jargon of the
application area, if they do `the right thing' by the
conventions of the application area, the semantics may work
out all right, but will you even get that far? How do you
parse a language containing constructs that you haven't seen
before?
Lisp pushes a vigorous vision of how this is supposed to
work. It uses a fully parenthesised prefix notation. The
idea in other languages is to have key-words or reserved
words that direct the parsing. In other languages adding
new reserved words stops your colleagues from reading your
code because they cannot even parse it. In Lisp the
reserved words do not direct the parse. The parse is made
explicit with the parentheses. So you can add new "reserved
words" without making your code un-parsable by others.
Now let us shift focus to the beginner. He faces a problem.
How do you parse a language containing constructs that you
haven't seen before? Unlike the expert, the cause of his
problem is not that the constructs are newly minted. The
cause of the beginner's problem is that he is just starting
out on learning the language, so all the constructs are new
/to him/. Nevertheless it is essentially the same problem.
Indeed, a beginner may recognise all too well what the
parentheses are there for. They are training wheels on the
syntax. Instead of seeing "if form1 form2 form3" and racking
his brain for the rules about when an if has an else clause,
the beginner is spoon fed "(if form1 form2) form3" or
"(if form1 form2 form3)". He may feel patronized by being
given a toy language and demand to learn a proper one, in
which the reserved words guide the parse and there is a
grammar to learn.
The beginner may have a hard time grasping that the
parentheses are not training wheels and are not for him. The
point that they are there to help industrial teams exploit
meta-programming probably goes right over his head.
My claim is that the "by experts, for experts" nature of
Lisp accidently bestows a great boon on the beginner.
One can make the same claim about other aspects of the
syntax. Experts realise that writing `m.a(b)' instead of
`(m a b)' doesn't buy you anything. So they left it out of
Lisp. That is they left it out because they didn't want to
be bothered with it themselves, and they were designing the
language for their own use. But it doesn't help anybody! So
again the beginner gets a free ride. By using a tool intended
for experts, the beginner misses out on the spinach and
rhubarb of dumbed down languages, and that makes the
beginner's life more pleasant.
The same thing happens with arithmetic. The bignums and the
rationals are there because experts want to write algebra
systems. They are not there to make arithmetic in the
language work in school book fashion for the sake of
children learning the language. Nevertheless having the
arithmetic do the right thing is a substantial advantage
for any child looking for a first programming language.
I think that there is an unacknowledged emotional
undercurrent here. You don't let your child play with power
tools, electric drills, circular saws, etc. Why not?
Children are weaker than adults and would benefit more from
the power assistance. Indeed children's enthusiasm is often
dimmed by the time it takes to get worthwhile things done,
and access to power tools would help with this. So why not?
You could say that it is just obvious and get annoyed with
the stupid question. That is a mistake. There is a real
reason why not. Power tools really are dangerous. Digging
for the real reason is empowering. You are empowered to see
the limitations of metaphor.
When we ask "should beginners get power tools intended for
experts?" we naturally tend to "No!", fearing accidents and
trips to the hospital. But there is no danger of severed
limbs in tapping away at the computer keyboard in whatever
language. If there are drawbacks in giving a beginner Common
Lisp as a first programming language, those drawbacks need
to be made explicit and compared against the advantages.
Alan Crowe
Edinburgh
Scotland
From: Greg Menke
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m38xx0oyqb.fsf@athena.pienet>
Alan Crowe <····@cawtech.freeserve.co.uk> writes:
> Pascal Costanza <··@p-cos.net> wrote an interesting account
> of the life cycle of languages, focusing on the accumulation
> of complications, using JAVA as an example.
>
> Lisp's greatest claim to fame is as the first practical
> programmable programming language. Experts use Lisp for
> meta-programming. This whole approach is hugely
> controversial. You are working in a team and reading a
> colleague's code. He has made use of defmacro, adding new
> constructs to the language. What are the semantics of his
> constructs? If he has named them using the jargon of the
> application area, if they do `the right thing' by the
> conventions of the application area, the semantics may work
> out all right, but will you even get that far? How do you
> parse a language containing constructs that you haven't seen
> before?
>
> Lisp pushes a vigorous vision of how this is supposed to
> work. It uses a fully parenthesised prefix notation. The
> idea in other languages is to have key-words or reserved
> words that direct the parsing. In other languages adding
> new reserved words stops your colleagues from reading your
> code because they cannot even parse it. In Lisp the
> reserved words do not direct the parse. The parse is made
> explicit with the parentheses. So you can add new "reserved
> words" without making your code un-parsable by others.
I just experienced this very thing- we had a vendor in doing a training
class for their product, which is a development environment that
translates C into vhdl and ultimately into fpga's. The advantage of it
is you can take general purpose C code & literally turn it into
hardware. Conventional C code adapts fairly well, but the nasty part of the
product is the extremely complex & fussy preprocessor additions they had
to make so various subtlties of setting up I/O, clock domains and other
hardware issues. They approached the problem by adding keywords to C
and using a custom preprocessor to pick them off and set up the hardware
constructs accordingly. The problem is that sort of thing needs a lot
of fiddly configuration, so the syntax of these additions was
complicated and arbitrary, involving bunches of C-like keywords in a
vaguely C-function prototype format.
Most of the people in the class are C programmers, some C++- and a few
hardware weenies. When the instructor started into these language
additions, you could see everyone start to turn off.
From working with Lisp I found I could easily see why this sort thing
sucked- perhaps Lisp's simple parsing rules throw the hidden complexity
of other languages into sharp relief.
Regards,
Greg
I hope this doesn't come across as too flippant. The reason Lisp is
not more popular with average programmers is that it is not a popular,
mainstream language.
I'll use myself as a case example. I'm sure I'm not too much of an
outlier.
The first computer I got to play with had a Z-80 processor and 64KB of
RAM. It did not have any support for graphics. Storage was on 12"
floppy disks that had a 160KB capacity. The first programming
language I was exposed to on this machine was BASIC. BASIC with line
numbers. I did not write very sophisticated software.
My senior year in high school, the school got TRS-80 machines. They
were cheaper than the Apple. They used a very similar version of
BASIC so I could do some fun hacks on those. My most famouse hack was
an emulator for the TRS-DOS prompt. It didn't actually do anything
other than make you think you were at the real prompt. You could type
in a program, list it, and a few other things. But when you typed
RUN, the program would respond with "RUN WHAT?". At that point, LIST
would also stop working. Moving on...
My family got a Mac 512K. This machine also had a copy of Aztec C.
This was my first real exposure to C. It was 1985 and the machine had
no hard drive. Compiling a C program was a whole new experience for
me. First I needed the floppy that had a mini-unix like environment
and the Z editor. After I typed in some code from the K&R book, I had
to save the file and switch to the disk that had the compiler. Then
there was assembling and linking. Quite a shocking transition from
BASIC, let me tell you.
I didn't get very far with C. I had never even heard of Lisp. I
really doubt Common Lisp would have run on that machine. Of course
that's a moot point as I've just said I never even heard of it.
I had something of a hiatus from computers for a while, although I did
have a course in Fortran 77 and a course in Pascal. F77 was on some
machine called a PRIME. The terminals were dumb and there were 23 of
them on the machine. There was one printer. Waiting for results was
less than exciting. The Pascal used IBM PCs. I had never seen such
machines before. They used 5 1/4" floppy disks. There was some
program called Turbo Pascal for compiling and running code. I don't
know why, but I hated Pascal. It had weird rules I guess.
Fast forward a few more years to the 80386 PC with 80387 FP
coprocessor. 8MB of RAM and Windows 3.0! Now there was a computer.
I took a second shot at C and moved on quickly to C++ with Borland's
C++ 2.0. Borland had a nice IDE that took care of building C and C++
programs. I was finally able to do some non-trivial things. I also
wrote my first fractal program on that machine.
Lest ye think I am straying from the point, let me get to it now. By
this time I had formed a solid notion of what programming was. I had
still not heard of Lisp. I did once see a version of Logo on the
Amiga, but as far as I could tell that was just a toy language for
controling this turtle that drew lines. C++ was The Way. And so it
stayed for some time.
I grew up around little computers. They ran little programs and small
programming languages. I knew that there were big mainframes and
super computers out there, but I knew nothing about them. The micro
was all I knew and it was beginning to become an important machine.
Lisp was never in this world. When I finally did hear about Lisp in
the rather late 1990's, it was just too different. I was used to C++
and Lisp systems were being described to me like old BASIC where I
lived in an interpreter.
Going from C++ to Lisp means crossing the chasm.
--
http://www.david-steuber.com/
The UnBlog | Lisp on OS X topics for the most part
Click all the links you want. I'll make more!
On Tue, 11 Oct 2005 13:17:23 -0400, David Steuber wrote:
> I hope this doesn't come across as too flippant. The reason Lisp is
> not more popular with average programmers is that it is not a popular,
> mainstream language.
>
> I'll use myself as a case example. I'm sure I'm not too much of an
> outlier.
I think, looking back on things, I was very lucky.
My first computer was a Sinclair ZX81 (Z80, 3.5MHz, 1KB), when I was 9
years old. I spent a few years playing with BASIC on this and various
other Sinclair computers. Then, when I was 12 years old, my older brother
got an Amstrad 1512 (Intel 8086, 8MHz, 512KB), and he let me use it. At
the same time, I was reading a ton of popular-science type books on AI, so
I got to see "Lisp" mentioned a lot. I used BASIC on the Amstrad for only
a short time before I discovered a shareware Lisp named "PC-LISP". So
Lisp was only my second language, and I learned it young.
Since then everything else I've learnt has seemed like a poor subset of
Lisp with strange syntax.
Cheers,
Bill.
David Steuber <·····@david-steuber.com> writes:
> I didn't get very far with C. I had never even heard of Lisp. I
> really doubt Common Lisp would have run on that machine.
Not quite, but already in 1988, when successfully using Macintosh
Common Lisp on a 8Mhz Macintosh SE with 2,5MB RAM, I considered Lisp
to be usable as a mainstream programming language.
But I had real eye-opener already in 1985 or 1986 (I think): After
having programmed quite a lot in simula, fortran and pascal, I heard
about Prolog and had access to the famous DEC-10 Prolog on the
university DEC-10 system. It was extremely fun to work with, and made
me understand that programming languages could come in many very
different flavours (a year or two later, I actually also used Prolog
for a quite simple and mainstream programming task).
I guess I was just lucky :)
--
(espen)
From: Arthur Lemmens
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <opsyf4qvrik6vmsw@news.xs4all.nl>
Pascal Costanza wrote:
> Common Lisp is [...] hard to learn
You've been saying this for a while now, but I don't think
there's any evidence for such a blanket statement.
In fact, I think there are some good reasons (like a simple
syntax, dynamic typing, an interactive REPL, keyword arguments,
rational numbers, or even DEFSTRUCT) why it may be easier for a
programming newbie to get started with Common Lisp than with
languages like Java or C.
Maybe you can qualify this statement the next time? Something
like "It's hard to learn /all of/ Common Lisp" or "It may
take some time to learn Common Lisp features like macros or
CLOS or the condition system, but you can be pretty productive
in Common Lisp even if you don't grok all of it."
> "Only the creatively intelligent can prosper in the Lisp world."
> - Richard Gabriel
I suppose the creatively intelligent will prosper in lots of
places. But that doesn't mean that there's no place in the
Lisp world for anybody else.
Arthur Lemmens
On Mon, 10 Oct 2005 22:05:09 +0200, Arthur Lemmens wrote:
> Maybe you can qualify this statement the next time? Something like
> "It's hard to learn /all of/ Common Lisp" or "It may take some time to
> learn Common Lisp features like macros or CLOS or the condition system,
> but you can be pretty productive in Common Lisp even if you don't grok
> all of it."
How about starting with "newbie". Is that a newbie with prior programming
experience? (things to unlearn, or already know) Or is that newbie
"recently introduced to a computer" (no preconceptions to fight).
BR wrote:
> On Mon, 10 Oct 2005 22:05:09 +0200, Arthur Lemmens wrote:
>
>
>>Maybe you can qualify this statement the next time? Something like
>>"It's hard to learn /all of/ Common Lisp" or "It may take some time to
>>learn Common Lisp features like macros or CLOS or the condition system,
>>but you can be pretty productive in Common Lisp even if you don't grok
>>all of it."
>
>
> How about starting with "newbie". Is that a newbie with prior programming
> experience? (things to unlearn, or already know) Or is that newbie
> "recently introduced to a computer" (no preconceptions to fight).
i suspect that for the latter lisp should pose no more problems than any
other programming language, probably is even easier. for the former, it
probably depends on how easy it is for him to adjust to a very different
formalism
hs
From: Christian Lynbech
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <8764s4kpo0.fsf@chateau.defun.dk>
>>>>> "Arthur" == Arthur Lemmens <········@xs4all.nl> writes:
Arthur> Pascal Costanza wrote:
>> Common Lisp is [...] hard to learn
Arthur> You've been saying this for a while now, but I don't think
Arthur> there's any evidence for such a blanket statement.
I have myself been of the persuasion that the difficulties of learning
Lisp is mostly in the head of the initiate and less inherent in the
language as such, but other people (I think it was Tim Bradshaw) was
more in agreement with Pascal.
I guess it mostly boils down how well you are able to insulate
yourself against the sharp corners of Lisp, which it certainly
has. Things like the reader, macros or the MOP can still make my head
spin. In principle a newbie need not enter such dark passages, but
does it hold in reality?
Heck, even object oriented programming would be a stretch to most
people new to it, but it may be quite a lot easier to do a lot of java
programming without really understanding the subtleties of OO.
Now, of all this plays some part in why newbies find Lisp hard but I
sincerely believe that the single biggest obstacle people find with
lisp is its unorthodox syntax; unfortunately (for them at least) that
same syntax is deeply connected to why Lisp is such an incredible
sophisticated language.
That things are hard has not stopped wannabe Linux hackers, MUD
addicts or chess players from soldiering on towards enlightment. Even
if Linux was also by some definitions hard to use 10 years, people
have clinged on and improved it to the point where less determined
people also feels at home. Whether this will happen for Lisp, we will
see. I am not holding my breath, but tears are not filling my eyes
either.
------------------------+-----------------------------------------------------
Christian Lynbech | christian ··@ defun #\. dk
------------------------+-----------------------------------------------------
Hit the philistines three times over the head with the Elisp reference manual.
- ·······@hal.com (Michael A. Petonic)
Pascal Costanza wrote:
> Common Lisp is not designed for newbies. Yes, it's hard to learn and
> sometimes not straightforward to use. You have to put some effort into
> learning the language and the infrastructure. The reward comes much
> later than in other languages, but the chances are high that the reward
> is much higher. Of course, noone can guarantee this either. It's
> everyone's own decision how far one goes, how much one invests into
> learning it. Noone promised you that it will be easy.
>
> There are enough languages out there that promise you to be simple and
> straightforward to use. IMHO, they just push the complexity somewhere
> else, which will hurt you later on (or they just provide programming by
> numbers). Don't blame Lispers for the false promises that you have been
> indoctrinated with. Programming is hard.
>
> If you think you have been misled into thinking that Lisp is simple and
> straightforward to use, show us the URL, book, or whatever, that makes
> that claim.
The problem with this argument is that it's bundling two different
kinds of difficult into one idea.
You don't get many newbies coming to this list and saying "Lisp is too
conceptually difficult" or "Lisp is too strange for me to understand",
as they wouldn't be hear if they felt like that. So the fact that lisp
the language is not easy to learn (which in itself is a debatable
point) is neither here nor there. Obviously you can't change this fact
without changing the language.
But what this thread is about (imho) is the difficulty in getting third
party libraries working/getting a good working environment/delivery and
various problems which are external to the core language.
To say that people who can't install and compile all of the
dependencies for a gui library on their platform is a kind of
narrow-minded and macho attitude. Not everyone who wants to program is
also interested in the minutiae of unix, the c language or even the ffi
of their lisp implementation (which in my experience is much more like
programming in c than in lisp).
Not trying to attack anyone here, but I think that the attitude of
"there's no problem here" is not constructive. If there was no problem,
why would these threads baloon in the way they do all the time.
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3r2kqlFhg9p2U1@individual.net>
··············@gmail.com wrote:
> Pascal Costanza wrote:
>
>
>>Common Lisp is not designed for newbies. Yes, it's hard to learn and
>>sometimes not straightforward to use. You have to put some effort into
>>learning the language and the infrastructure. The reward comes much
>>later than in other languages, but the chances are high that the reward
>>is much higher. Of course, noone can guarantee this either. It's
>>everyone's own decision how far one goes, how much one invests into
>>learning it. Noone promised you that it will be easy.
>>
>>There are enough languages out there that promise you to be simple and
>>straightforward to use. IMHO, they just push the complexity somewhere
>>else, which will hurt you later on (or they just provide programming by
>>numbers). Don't blame Lispers for the false promises that you have been
>>indoctrinated with. Programming is hard.
>>
>>If you think you have been misled into thinking that Lisp is simple and
>>straightforward to use, show us the URL, book, or whatever, that makes
>>that claim.
>
> The problem with this argument is that it's bundling two different
> kinds of difficult into one idea.
> You don't get many newbies coming to this list and saying "Lisp is too
> conceptually difficult" or "Lisp is too strange for me to understand",
> as they wouldn't be hear if they felt like that. So the fact that lisp
> the language is not easy to learn (which in itself is a debatable
> point) is neither here nor there. Obviously you can't change this fact
> without changing the language.
>
> But what this thread is about (imho) is the difficulty in getting third
> party libraries working/getting a good working environment/delivery and
> various problems which are external to the core language.
No, I think these things are related. Among other things, Common Lisp
has an image-based runtime enviroment which differs in important
respects from most other compiled languages. This makes it somewhat
harder to make CL connect to standard (think: C) libraries. This also
leads to a somewhat unusual way to incorporate libraries (either based
on system definitions or on saving prepared images).
Of course there is also the unrelated issue that the amount of people
working on CL infrastructure is smalller than that for other languages.
This leads to the fact that you basically have two options: Either you
invest more time (into open-source projects) or you invest more money
(into commercial CL environments). This seems to be hard to accept for
some, but people have to realize that these things just don't change
over night.
> Not trying to attack anyone here, but I think that the attitude of
> "there's no problem here" is not constructive. If there was no problem,
> why would these threads baloon in the way they do all the time.
Yes, there are problems, but it is also not constructive to make them
appear larger than they are.
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3r2l3aFhig1aU1@individual.net>
··············@gmail.com wrote:
> But what this thread is about (imho) is the difficulty in getting third
> party libraries working/getting a good working environment/delivery and
> various problems which are external to the core language.
This seems to be related: http://www.downes.ca/cgi-bin/page.cgi?post=31620
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
lol.
I just went through the rails setup process twice (once on os x at
home, and once on xp at work), and to think, when I have installation
problems I always envy people running linux because it seems everything
works first time on it.
But this is exactly the sort of thing that can be offputting, and being
able to persevere through those unix incantations is not the same as
being a good lisp programmer. It's just that the current set of lisp
programmers are the intersection of people who are naturally drawn to
lisp and those that can deal with the external problems.
sorry, google.groups broken reply button. that last post was in reply
to
··············@gmail.com wrote:
> But what this thread is about (imho) is the difficulty in getting third
> party libraries working/getting a good working environment/delivery and
> various problems which are external to the core language.
This seems to be related:
http://www.downes.ca/cgi-bin/page.cgi?post=31620
pascal
···············@gmail.com" <··············@gmail.com> writes:
> lol.
> I just went through the rails setup process twice (once on os x at
> home, and once on xp at work), and to think, when I have installation
> problems I always envy people running linux because it seems everything
> works first time on it.
>
> But this is exactly the sort of thing that can be offputting, and being
> able to persevere through those unix incantations is not the same as
> being a good lisp programmer. It's just that the current set of lisp
> programmers are the intersection of people who are naturally drawn to
> lisp and those that can deal with the external problems.
In a way, Lisp image based process, Smalltalk, Java both try to
isolate the programmer user from such external minutiae. Live in your
lisp image and be happy forever after. Try to seek external
libraries, FFI, etc, and be thrown to hell.
Perhaps what would be needed is MORE isolation. Of course, for this
to work, we'd have to re-implement everything in lisp and we don't
have the hands to do it. :-(
--
__Pascal Bourguignon__ http://www.informatimago.com/
Until real software engineering is developed, the next best practice
is to develop with a dynamic system that has extreme late binding in
all aspects. The first system to really do this in an important way
is Lisp. -- Alan Kay
Pascal Bourguignon <····@mouse-potato.com> writes:
> In a way, Lisp image based process, Smalltalk, Java both try to
> isolate the programmer user from such external minutiae. Live in your
> lisp image and be happy forever after. Try to seek external
> libraries, FFI, etc, and be thrown to hell.
>
> Perhaps what would be needed is MORE isolation. Of course, for this
> to work, we'd have to re-implement everything in lisp and we don't
> have the hands to do it. :-(
That sounds valid for CLISP, but not every Lisp tries to isolate you.
You can for the most part happily ignore Unix and live in the Lisp
world only, but SBCL and CMUCL give you Alien and SAPs and signal
handlers, and bindings to things like fcntl, pipe, and dup. Classic
MCL similarly lets you either ignore the outside world, or directly
use the Mac Toolkit. All three let you have a Lispy variation of very
low-level programming for the system you're on. When you need to
address that low level, it's wonderful to be able to do it in Lisp.
--
/|_ .-----------------------.
,' .\ / | Free Mumia Abu-Jamal! |
,--' _,' | Abolish the racist |
/ / | death penalty! |
( -. | `-----------------------'
| ) |
(`-. '--.)
`. )----'
···@conquest.OCF.Berkeley.EDU (Thomas F. Burdick) writes:
> Pascal Bourguignon <····@mouse-potato.com> writes:
> ···············@gmail.com" <··············@gmail.com> writes:
>
> > lol.
> > I just went through the rails setup process twice (once on os x at
> > home, and once on xp at work), and to think, when I have installation
> > problems I always envy people running linux because it seems everything
> > works first time on it.
> >
> > But this is exactly the sort of thing that can be offputting, and being
> > able to persevere through those unix incantations is not the same as
> > being a good lisp programmer. It's just that the current set of lisp
> > programmers are the intersection of people who are naturally drawn to
> > lisp and those that can deal with the external problems.
> >
>> In a way, Lisp image based process, Smalltalk, Java both try to
>> isolate the programmer user from such external minutiae. Live in your
>> lisp image and be happy forever after. Try to seek external
>> libraries, FFI, etc, and be thrown to hell.
>>
>> Perhaps what would be needed is MORE isolation. Of course, for this
>> to work, we'd have to re-implement everything in lisp and we don't
>> have the hands to do it. :-(
>
> That sounds valid for CLISP, but not every Lisp tries to isolate you.
Really, the number of misconceptions around clisp never stops to amaze
me. clisp has one of the best FFI around (the best IMO), and you can
write modules linked into clisp in any language, including C. And it
works (or worked) on different platforms like MacOS, Amiga and
MS-Windows in addition to unix. Therefore it's one of the less
isolated implementation.
> You can for the most part happily ignore Unix and live in the Lisp
> world only, but SBCL and CMUCL give you Alien and SAPs and signal
> handlers, and bindings to things like fcntl, pipe, and dup. Classic
> MCL similarly lets you either ignore the outside world, or directly
> use the Mac Toolkit. All three let you have a Lispy variation of very
> low-level programming for the system you're on. When you need to
> address that low level, it's wonderful to be able to do it in Lisp.
But my point, in reponse to Robbie, was exactly that this "modular"
interfacing is a factor of the problem. Yes, we can interface with
external resources. But this means a multiplication of dependencies
and interface nodes, which increases the integration difficulties.
Newbie users complain about it. If they want to do lisp, why do they
have to fetch C library X, or C++ library Y, before being able to hack
lisp and display a pixel in a window? Well, Smalltalk has an answer:
you download a Smalltalk image such as Squeak and you have everything
standalone. Scheme has a similar answer too: you download DrScheme
and you've got everything integrated too. When you donwload a Lisp
image, you still have to integrate a lot of tools and libraries (be
them CL, emacs lisp or external via FFI) before you can do "anything".
Perhaps newbies would be happy with "distributions" of our favorite
CL implementations: big images preloaded with a wide range of
libraries and tools, ready to use (in particular, including hemlock or
climacs, to avoid them newbies to have to learn emacs ;-) After all,
Smalltalk implementations include their own browser/editor in their images.
--
"I have challenged the entire quality assurance team to a Bat-Leth
contest. They will not concern us again."
Pascal Bourguignon wrote:
> But my point, in reponse to Robbie, was exactly that this "modular"
> interfacing is a factor of the problem. Yes, we can interface with
> external resources. But this means a multiplication of dependencies
> and interface nodes, which increases the integration difficulties.
> Newbie users complain about it. If they want to do lisp, why do they
> have to fetch C library X, or C++ library Y, before being able to hack
> lisp and display a pixel in a window? Well, Smalltalk has an answer:
> you download a Smalltalk image such as Squeak and you have everything
> standalone. Scheme has a similar answer too: you download DrScheme
> and you've got everything integrated too. When you donwload a Lisp
> image, you still have to integrate a lot of tools and libraries (be
> them CL, emacs lisp or external via FFI) before you can do "anything".
>
> Perhaps newbies would be happy with "distributions" of our favorite
> CL implementations: big images preloaded with a wide range of
> libraries and tools, ready to use (in particular, including hemlock or
> climacs, to avoid them newbies to have to learn emacs ;-) After all,
> Smalltalk implementations include their own browser/editor in their images.
yes yes yes. This is what I'm talking about (although I don't think
they should be deprived of emacs :). I think that people drawn to
hacking in lisp are not necessarily also drawn to hacking the ffi/unix,
and we're excluding bright and creative people by making that a
prerequisite to getting anything done.
Pascal Bourguignon <····@mouse-potato.com> wrote:
+---------------
| ···@conquest.OCF.Berkeley.EDU (Thomas F. Burdick) writes:
| > You can for the most part happily ignore Unix and live in the Lisp
| > world only, but SBCL and CMUCL give you Alien and SAPs and signal
| > handlers, and bindings to things like fcntl, pipe, and dup. Classic
| > MCL similarly lets you either ignore the outside world, or directly
| > use the Mac Toolkit. All three let you have a Lispy variation of very
| > low-level programming for the system you're on. When you need to
| > address that low level, it's wonderful to be able to do it in Lisp.
|
| But my point, in reponse to Robbie, was exactly that this "modular"
| interfacing is a factor of the problem. Yes, we can interface with
| external resources. But this means a multiplication of dependencies
| and interface nodes, which increases the integration difficulties.
| Newbie users complain about it. If they want to do lisp, why do they
| have to fetch C library X, or C++ library Y, before being able to hack
| lisp and display a pixel in a window?
+---------------
You don't. CLISP, CMUCL, and SBCL all come with CLX (though possibly
in the "extra" or "src" tarballs), and there are several examples in
the CLX sources [e.g., in ".../cmucl/src/clx/demo/", in the CMUCL case)
of small GUI programs which display "Hello, world!" (or some other message)
in a window [the HELLO-WORLD function in "hello.lisp"] or demonstrate
pop-up menus [the POP-UP function in "menu.lisp"]. Note that these all
include event handling, such as exposures and "mouse-overs".
What's that, you say? CLX is *ugg-leee*?!? Well, yes, but that
wasn't the issue -- being able to put a pixel in a window was.
And with no C/C++ libraries to fetch, either. [Not even Xlib!]
-Rob
-----
Rob Warnock <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
Pascal Bourguignon <····@mouse-potato.com> writes:
> ···@conquest.OCF.Berkeley.EDU (Thomas F. Burdick) writes:
>
> > Pascal Bourguignon <····@mouse-potato.com> writes:
> >
> >> Perhaps what would be needed is MORE isolation. Of course, for this
> >> to work, we'd have to re-implement everything in lisp and we don't
> >> have the hands to do it. :-(
> >
> > That sounds valid for CLISP, but not every Lisp tries to isolate you.
>
> Really, the number of misconceptions around clisp never stops to amaze
> me. clisp has one of the best FFI around (the best IMO),
I admit I haven't looked at the new FFI much -- and it is pretty brand
new. However ...
> and you can
> write modules linked into clisp in any language, including C. And it
> works (or worked) on different platforms like MacOS, Amiga and
> MS-Windows in addition to unix. Therefore it's one of the less
> isolated implementation.
.. of course you *can* interface with the system, but linking C
modules in is not pleasant.
> > You can for the most part happily ignore Unix and live in the Lisp
> > world only, but SBCL and CMUCL give you Alien and SAPs and signal
> > handlers, and bindings to things like fcntl, pipe, and dup. Classic
> > MCL similarly lets you either ignore the outside world, or directly
> > use the Mac Toolkit. All three let you have a Lispy variation of very
> > low-level programming for the system you're on. When you need to
> > address that low level, it's wonderful to be able to do it in Lisp.
In Unix terms, I'm talking SAPs, the ability to mmap and make
reasonable use of the resulting memory, reason about alien types,
throw FDs around, etc. At least classically, CLISP helps insulate you
from the system you're on. That's hardly all bad.
--
/|_ .-----------------------.
,' .\ / | Free Mumia Abu-Jamal! |
,--' _,' | Abolish the racist |
/ / | death penalty! |
( -. | `-----------------------'
| ) |
(`-. '--.)
`. )----'
···············@gmail.com" <··············@gmail.com> writes:
> Björn Lindberg wrote:
> > Mark Carter <··@privacy.net> writes:
> >
> > >
> > > One of the bad things they see with Lisp in particular is the
> > > fragmentation, where trying to get working libraries for their
> > > platform and implementation are toothgrindingly difficult. They
> > > eventually ask themselves "what's the bloody point", and go back to
> > > doing whatever it was they were doing before they arrived.
> >
> > Experienced lispers here repeatedly tell you that this is not how they
> > see it though. So who is more likely to be wrong: the experienced
> > lisper or the newbie?
>
> Whos is more likely to be wrong about the experience of coming to lisp
> as a newbie today? I think it's the experienced lisper.
Why do certain newbies keep trying to make this the experienced
lisper's problem? I think the newbies want freebies, but the
experienced people are busy getting real work done in their favourite
language.
From my perspective, I used to be a newbie too, but I never whined on
a newsgroup about it. This is not a nursery. I suggest that you deal
with your own problems, be it by moving to another language or
confront learning Lisp on its current terms.
Oh, and I agree with Pascal that Common Lisp is not optimized for
beginners. This is a good thing because you are a beginner once but an
expert forever more. In the newbie-directed language[*] the expert is
constantly punished in the name of beginners.
[*] Python is over there. --->
Björn
Björn Lindberg wrote:
> Oh, and I agree with Pascal that Common Lisp is not optimized for
> beginners. This is a good thing because you are a beginner once but an
> expert forever more. In the newbie-directed language[*] the expert is
> constantly punished in the name of beginners.
First of all, I want to comment on Pascals posting: I do very much agree
with the description of the Java history - being myself someone who
was very active with Java in the early days and also a bit disappointed
where the development did lead. The changes made to the language seemed
to add more complexity than power, and what initally was a nice not to
large language, albeit not omnipotent, now has become quite a behemoth...
Back to the topic: I do think that things, you can do as a newbie in a
"beginners" language are not really much more difficult to do in Lisp.
Simple functions etc. do not require expert knowledge and so Lisp *can*
be a language suitable for a beginner. However, Common Lisp does not
pretend that it is possible to learn the language in toto within a few
weeks and that is a good thing, because doing so, many important
features might have been sacrificed. So noone will "get" the whole of
Common Lisp, until dealing with the expert features.
>
> [*] Python is over there. --->
>
Well, sadly Python seems to be a good example of exactly what Pascal did
describe: it started as a language crafted to make programming as simple
as possible. And I think, Python is still the most "newbie-friendly"
language around. But I have to say "still", because the development of
Python does start to worry me. While there were lots of great
improvements between 1.52 and 2.4, adding new features as well as
cleaning up some mistakes made in the initial language definition,
recently "high level" features started creeping into the language. And
if I as someone who has done a lot of Python programming do not "get"
the idea behind some of the features after reading their description
twice, then the chance is great, they will be lost on the newbie.
Python is risking to loose its main trait, and I doubt that the power
gained that way will justify its means...
So I think that Common Lisp strikes a better balance here, like in the
famous cite:
“Make everything as simple as possible, but not simpler.” A. Einstein
Peter
--
Ltk, the easy lisp gui http://www.peter-herth.de/ltk/
From: Robert Uhl
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m3ll136lty.fsf@4dv.net>
Robert Uhl <·········@NOSPAMgmail.com> writes:
>
> A newbie evaluation languages sees one language with lots and lots of
> support and another without; certainly he can't reasonably demand that
> other folks give him what he wants, but when one group does so and
> another doesn't, he can reasonably choose to go with the former.
s/evaluation/evaluating/g
--
Robert Uhl <http://public.xdi.org/=ruhl>
More Slightly Less Common Latin Phrases:
Recedite, plebes! Gero rem imperialem!
Stand aside plebians! I am on imperial business.
From: Edi Weitz
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <u4q7tf7si.fsf@agharta.de>
On Fri, 07 Oct 2005 20:12:36 +0100, Mark Carter <··@privacy.net> wrote:
> I am aware that Lispworks and Allegro have GUIs - but people like me
> shy away from commercial stuff. We can't distribute our work.
Nonsense. Of course you can distribute your work if you use
commercial Lisps.
Actually, at least once per month we have someone whining that they
can't distribute their work with the "free" Lisps because those can't
create "stand-alone" executables.
So?
Cheers,
Edi.
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
Edi Weitz wrote:
> On Fri, 07 Oct 2005 20:12:36 +0100, Mark Carter <··@privacy.net> wrote:
>
>
>>I am aware that Lispworks and Allegro have GUIs - but people like me
>>shy away from commercial stuff. We can't distribute our work.
>
>
> Nonsense.
No, not nonsense. I'm of course not debating that I retain copyright of
my own code. I'm referrring to the fact I can't create "stand-alone"
executables with them.
It's true that Python has essentially the same problems in this regard.
But I'm thinking that people use Python mostly for scripting work,
whereas for something like Lisp they might be looking for application
development.
> Actually, at least once per month we have someone whining that they
> can't distribute their work with the "free" Lisps because those can't
> create "stand-alone" executables.
I guess it depends if you're talking about commercial, or freeware.
Freeware is actually OK, because I can deliver stuff "stand-alone" with
an offer of the sources. But commercial usage is out of the question if
one feels that they don't want to be bound with a GPL license. Why
programming language implementations are released under GPL is beyond me.
Seriously, as a n00b, I feel I have a reasonable grasp about what's
going through the mind of other n00bs. They'll be thinking where's the
GUI, can I do regular expressions, networking, and all the other common
stuff that users of the popular scripting languages take for granted.
They'll be contemplating its use for personal projects that they might
want to release on the internet, its use in office adminstrative tasks
where bosses tend not to mandate languages, and also as something to
show the boss as a possible real alternative way of developing
applications. These are the things that will go through a n00bs mind
when kicking the tyres of a language to see if they might like to make
greater use of it.
So, I reiterate that Ray Dillinger is essentially right in his assessment.
Mark Carter wrote:
[big snip]
>
> So, I reiterate that Ray Dillinger is essentially right in his assessment.
I don't think you or Ray has shown any evidence of making a careful
"assessment."
You both seem to have some vague criteria in the area of GUI
development which Common Lisp fails to meet, and you think is critical
to its "success."
But nowhere can I see any carefully thought-out description of what
your criteria *are*. Especially, a comparison of other languages and
implementations against these criteria.
Ray Dillinger, for instance, seems to think that C/C++ is sufficient
for GUI programming, but CL is not. This fails to stand up to *any*
analysis I can conceive of. GUI programming under C is the absolute
lowest common denominator.
You seem to think Python is sufficient, but when I browse through the
Python Wiki, I see a melange of stuff borrowed from Tk, various
home-grown packages, and so forth, which seems to be comparable to a
bunch of the freely available stuff for Common Lisp, and absolutely
pathetic compared to something like a commercial vendor's CLIM
implementation.
Consideration of commercial implementations seems to involve some other
poorly stated criteria about avoiding "lock-in" and retaining an
ability to "deliver" your applications.
Hey, no one can stop random kvetching on Usenet. But don't think you
are making any sort of coherent point when you do so.
··············@hotmail.com wrote:
> Mark Carter wrote:
> But nowhere can I see any carefully thought-out description of what
> your criteria *are*. Especially, a comparison of other languages and
> implementations against these criteria.
People experimenting with new languages try to get a "feel" for the
language. Sometimes they may have very definite requirements, sometimes
they may be quite broad.
At the end of the day, people are probably going to make pragmatic
decisions, like the commercial systems are good, but expensive, so I
can't use them for hobby work that I may want to distribute. Stuff like
that.
> You seem to think Python is sufficient, but when I browse through the
> Python Wiki, I see a melange of stuff borrowed from Tk, various
> home-grown packages, and so forth, which seems to be comparable to a
> bunch of the freely available stuff for Common Lisp,
Python libraries tend to be way more mature than CL libraries. I looked
at CL-SMTP, and it didn't support authentication, for example. As
another example, I looked at wxCL, and the wxColour arguments are,
AFAIK, slightly wrong. I'm not knocking wxCL - and in fact I've
expressed praise and appreciation for the author's work.
And so on, and so forth. The fact remains that there is a lot more
mature publicly available libraries for Python.
> and absolutely
> pathetic compared to something like a commercial vendor's CLIM
> implementation.
I don't know CLIM, so I'll accept your assertion that it's great.
However, if I'm using a free implementation, then it doesn't cut any ice.
Please don't misunderstand me, I'm really not trying to be awkward.
People are going to access the situation in this way.
> Hey, no one can stop random kvetching on Usenet. But don't think you
> are making any sort of coherent point when you do so.
Well, it all boils down to that age-old question: if Lisp is so great,
then why isn't it more popular? And I suspect the answer is not so much
that it has "toenail clippings" or that you have to write (+ 2 3)
instead of (2 + 3), it's that they see that it doesn't work in some
desirable way (be it the GUI, networking, licensing, or whatever).
Look at Franz licensing, for instance:
http://www.franz.com/products/licensing/commercial.lhtml#corporate
It looks to me (to the best of my inderstanding) that just to be able to
sell a product that I make the it I'd have to pay a royalty to Franz.
Seriously, who's going to stump up for that? Even Microsoft don't even
have the audacity to demand royalties from the product you sell.
From: Robert Uhl
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m3psqf6m4f.fsf@4dv.net>
···············@hotmail.com" <············@gmail.com> writes:
>
> You seem to think Python is sufficient, but when I browse through the
> Python Wiki, I see a melange of stuff borrowed from Tk, various
> home-grown packages, and so forth, which seems to be comparable to a
> bunch of the freely available stuff for Common Lisp, and absolutely
> pathetic compared to something like a commercial vendor's CLIM
> implementation.
pygtk+ os pretty nice...
> Consideration of commercial implementations seems to involve some
> other poorly stated criteria about avoiding "lock-in" and retaining an
> ability to "deliver" your applications.
Or, for some, a desire to remain free...
--
Robert Uhl <http://public.xdi.org/=ruhl>
I've used emacs for many years now, but have never reached its maximum
potential.
I think this is the motto of every emacs user. --LathI
Mark Carter <··@privacy.net> writes:
> I'm a complete n00b to Lisp, and I have to say that I agree with Ray's
> argument. He's completely right! 100% What n00bs like me want to see
> is that it has GUIs, network libraries, and all the goodies that we
> get with stuff like Python.
May I ask what you, as a complete Lisp n00b, are willing to do to get
all those goodies?
> projects, half-implemented APIs, incompatabilities galore. Take UFFI
> ... please. Not only is it incompatable with CLISP, it has been forked
> to hello-c.
[...]
> The best that Lispers can come out with is "Learn how to use the FFI".
Here's something more: learn how to do your homework.
Paolo
--
Why Lisp? http://wiki.alu.org/RtL%20Highlight%20Film
Recommended Common Lisp libraries/tools:
- ASDF/ASDF-INSTALL: system building/installation
- CL-PPCRE: regular expressions
- CFFI: Foreign Function Interface
Paolo Amoroso wrote:
> Mark Carter <··@privacy.net> writes:
>
>
>>I'm a complete n00b to Lisp, and I have to say that I agree with Ray's
>>argument. He's completely right! 100% What n00bs like me want to see
>>is that it has GUIs, network libraries, and all the goodies that we
>>get with stuff like Python.
>
>
> May I ask what you, as a complete Lisp n00b, are willing to do to get
> all those goodies?
Not much. I'm not expecting Lisp to "owe" me anything, and I'm not
expecting to it anything, either.
Look, people go along from their own language and wonder if there's
anything better out there. They have a broad idea of what they might
like to do with it, have a general play about with the language, and
keep a mental scorecard of its strengths and weaknesses.
For example, several years back I tried Perl. It required a compiler for
some bits, and the language looked messy. Then I discovered Python. It
seemed easier then Perl, and as I got into Python, the good news kept
getting better. It had network libraries, dictionaries that supported
complex keys, and all sorts of stuff that I found that when I needed
them, they were there. So needless to say, I'm quite keen on Python.
I had a look at Haskell a short while back. I went hunting for a GUI,
found wxHaskell, and discovered that it installed relatively easily. You
could deliver apps with it. These things stuck in my mind, so I started
to warm to it. I thought that its disadvantages were that it was too
purist, and that perhaps state wan't as bad as was made out. So that was
a negative point against it.
And so it goes on. People come in, have a root around to see what it's
strengths and weaknesses are, and take it from there.
When people come to Lisp, what they find is hopeless fragmentation with
respect to platforms and implementations. Sorry, it's just a fact. It's
not a dig against Lispers, it doesn't mean that they're any less of a
man, it just means that people take a look at Lisp, and find it wanting
in an important regard.
>>projects, half-implemented APIs, incompatabilities galore. Take UFFI
>>... please. Not only is it incompatable with CLISP, it has been forked
>>to hello-c.
>
> [...]
>
>>The best that Lispers can come out with is "Learn how to use the FFI".
>
>
> Here's something more: learn how to do your homework.
What's that supposed to mean?
Mark Carter wrote:
> And so it goes on. People come in, have a root around to see what it's
> strengths and weaknesses are, and take it from there.
>
> When people come to Lisp, what they find is hopeless fragmentation with
> respect to platforms and implementations. Sorry, it's just a fact. It's
> not a dig against Lispers, it doesn't mean that they're any less of a
> man, it just means that people take a look at Lisp, and find it wanting
> in an important regard.
There's an explanation someone gave me once (Samir Sekkat, who was
looking to hire people for his spinoff using Common Lisp). There are
two axes when evaluating a language. The language itself, and its
libraries/APIs. Currently, Lisp exceeds everything in language. In
libraries.. not so much. ;)
Now, we can consider which is a more permanent problem, but I think
that's a very accurate portrayal.
Tayssir
--
http://disciplined-minds.com/
Mark Carter <··@privacy.net> writes:
> Paolo Amoroso wrote:
>> Mark Carter <··@privacy.net> writes:
[...]
>>>projects, half-implemented APIs, incompatabilities galore. Take UFFI
>>>... please. Not only is it incompatable with CLISP, it has been forked
>>>to hello-c.
>> [...]
>>
>>>The best that Lispers can come out with is "Learn how to use the FFI".
>> Here's something more: learn how to do your homework.
>
> What's that supposed to mean?
That there were good reasons for both UFFI not to support CLISP, and
for an UFFI fork.
Paolo
--
Why Lisp? http://wiki.alu.org/RtL%20Highlight%20Film
Recommended Common Lisp libraries/tools:
- ASDF/ASDF-INSTALL: system building/installation
- CL-PPCRE: regular expressions
- CFFI: Foreign Function Interface
Paolo Amoroso wrote:
> Mark Carter <··@privacy.net> writes:
>
> > Paolo Amoroso wrote:
> >> Mark Carter <··@privacy.net> writes:
> [...]
> >>>projects, half-implemented APIs, incompatabilities galore. Take UFFI
> >>>... please. Not only is it incompatable with CLISP, it has been forked
> >>>to hello-c.
> >> [...]
> >>
> >>>The best that Lispers can come out with is "Learn how to use the FFI".
> >> Here's something more: learn how to do your homework.
> >
> > What's that supposed to mean?
>
> That there were good reasons for both UFFI not to support CLISP, and
> for an UFFI fork.
"Good" though they may be, it renders the concept of a "Universal" FFI
absolute baloney. That choice of brand identity was really
unfortunate, as clearly it won't ever live up to the billing. People
get pissed when expectations are so raised. Well, maybe a fork + new
labeling is the right thing for the long haul. Nobody will get a
priori pissed that hello-c only supports this, this, and that CL
implementation.
There was a time a couple of months ago when I thought I was going to
move to the Common Lisp camp, thinking it would have more standard
libraries and tools than the Scheme universe. But for my specific
needs - game development, low level optimization, talking to C, Windows
- I found that the landscape was no better than with Scheme. In fact,
there were more open source implementations available with Scheme.
Now, each Scheme implementation is a land unto itself - but for my
specific problems, I found that to be no less true with Common Lisp.
It's not the languages which have bogged me down. It's the tools and
APIs. I am forever discovering that using any HLL for commercial
Windows game development is pioneering work, fraught with much
brokenness.
Oh well. All I can do is slog forwards. Haven't found reason to give
up on Chicken Scheme yet. CMake may be coming to my cross-platform
build rescue. Getting Eclipse, MinGW, VC++, and Maya SDKs to cooperate
with each other sure is annoying though. I'm going with OpenGL, even
though Microsoft is making every effort to kill it.
http://www.opengl.org/discussion_boards/cgi_directory/ultimatebb.cgi?ubb=get_topic;f=12;t=000001
The good news is that Sony PS3 will be using OpenGL ES. So in the
worst case, I ditch Windows and become a Mac + PS3 developer. Forget
Linux though. No viability as a consumer desktop OS.
Toolchains really will drive you nuts. I think most of the people I've
pissed off over the past two years, are comfortably working on their
own problems and have no idea how broken the toolchains seem from some
people's perspectives. Depends entirely on your problem domain. And
also on your mentality: Lisp / Scheme is a breeding ground for people
who don't mind brokenness and are comfortable rolling everything
themselves. In other words, uber power programmers. The power of Lisp
may be contained not so much in the language, as people often think.
Rather, in the people who are willing to contend with it.
Cheers,
Brandon J. Van Every
(cruise (director (of SeaFunc)
'(Seattle Functional Programmers)))
http://groups.yahoo.com/group/SeaFunc
THINGS YOU SHOULD KNOW ABOUT BRANDON J. VAN EVERY BEFORE REPLYING TO
ONE OF HIS POSTS
1. He has never designed any game, nor contributed to the design of
any game, which has ever seen the light of day, despite referring
to himself as a "game designer." (In rebuttal, he pointed out his
"one complete game" from "1983" on the "Atari 800" which he showed
to his "8th grade math teacher.")
2. He has never been employed in the game industry, in any way,
shape, manner or form. Despite this, for some reason he managed
to get named as an Independent Games Festival judge; a curious
turn of events, since their stated intent is to appoint
"professionals in the game industry" (their quote, not his).
3. In fact, the only programming job he had listed on his resume was
for only "2 years" ending in "1998," working in C and assembly on
a graphics driver, as a "Sr. Software Engineer" -- a curious
title, since this was his first (and only) job in the software
industry. There is no evidence he has used C++, nor any other
language, professionally. (And the company in question is
defunct, anyway, so there is no way to verify his claim.)
4. The other jobs he has mentioned having after this one and only
items on his resume are: "yard maintenance work," "painting
apartments," "scrubbing floors," "sub minimum wage signature
gathering," and working for "$5/hour at a Vietnamese restaurant."
5. The only personal project he actually wrote code for and made
available in some manner was Free3d, a software 3D rendering
engine. Stating that its goals were to be "100% efficient, 100%
portable" and to release it in a "one year time frame," which he
started in "1993" and abandoned in "1996," admitting that it
"barely drew even a single polygon" and "did hardly anything in
the 3D department."
6. Almost every Internet community (Usenet newsgroup, mailing list,
etc.) he has ever introduced himself to has resulted in him
repeating the same pattern: asking leading questions, demanding
people do things his way, becoming hostile, annoying the other
participants, alienating them, and finally leaving in disgust.
7. Of the projects (open source and otherwise) whose communities he
has (briefly) joined, he has never contributed anything tangible
in terms of code or documentation.
8. The project he has intermittently claimed to be working on, Ocean
Mars, is vaporware -- and is one of his admitted "failures." He
allegedly sunk "nine months of full time 60 hours/week" and about
"$80K" into it (at least; he "stopped counting") with only a
"spherical hexified icosahedron" display to show for it (only
allegedly, since it has never been shown or demonstrated
publicly).
9. Since his embarassing frustration with his Ocean Mars project, he
has decided that C and C++ aren't "worth anything as a resume
skill anymore," and embarked on a quest in 2003 to find a
high-level language that will suit his needs. After more than a
year, at least ten languages, and not having even "written a line
of code" in any of them, he still has yet to find a language that
will suit him.
10. Finally, despite vehemently insisting that he is not a troll, many
people quite understandingly have great difficulty distinguishing
his public behavior from that of a troll.
Mark Carter sade:
> I'm a complete n00b to Lisp, and I have to say that I agree with Ray's
> argument. He's completely right! 100% What n00bs like me want to see is
> that it has GUIs, network libraries, and all the goodies that we get
> with stuff like Python.
>
Guess I must be unique in this sense. I've never done gui-work in
common lisp, and I will most likely not ever do it. I never asked
that big question of yours "where's the gui?". Never did it in perl
either. I've evaluated a lot of languages, and so far never has
the gui been of any prime concern.
I can agree that network facilities are important, but since it is
all derived from the same fundamental framework, network libraries
are quite the same, for, most likely, all languages; with REBOL at the
far end.
If python is your smorgasbord then use it instead.
> But praise the Lord, what do we see when we try Lisp? Abandoned
> projects, half-implemented APIs, incompatabilities galore. Take UFFI ...
> please. Not only is it incompatable with CLISP, it has been forked to
> hello-c.
>
Nothing in comparison with the wonderful world of C and C++.
> Many of the GUIs wont work on Windows. There's Ltk - which is for very
> lightweight work only. The only light at the end of the tunnel is wxCL,
> which is a full-featured GUI - full praise goes to Surendra K. Singhi in
> his efforts. I am aware that Lispworks and Allegro have GUIs - but
> people like me shy away from commercial stuff. We can't distribute our
> work.
>
> The best that Lispers can come out with is "Learn how to use the FFI".
>
> Seriously, I'm not trolling, I'm just saying it like it is. There's just
> too much unwarranted complexity in it; too much tail-chasing; too much
> brain damage just to accomplish something simple. You know, considering
> that Lisp is one of the world's oldest programming languages, you'd
> think that it would have these problems licked by now.
I think common lisp has evolved quite beautifully.
Tobias
--
IMPORTANT: The contents of this email and attachments are confidential
and may be subject to legal privilege and/or protected by copyright.
Copying or communicating any part of it to others is prohibited and may
be unlawful.
··············@hotmail.com wrote:
> Ray Dillinger wrote:
>
>>They get that privelege because the fundamental infrastructure
>>of the OS is developed *FOR* them, in a format guaranteed to
>>be linkable to their code. With C and things that share its
>>ABI, the GUI isn't part of the language because the GUI
>>facilities provided by the OS are guaranteed to be linkable.
>
>
> What privelege? What infrastructure? Have you actually tried writing a
> GUI-based application using C or even C++? The linker doesn't help *at
> all.* The real effort is learning a GUI toolkit (which standard GUI is
> that again?)
My evaluation went something like this:
1) no gui toolkit built into the language or standardized.
2) no gui toolkit in the free download of the language.
3) no standard access to the fundamental system calls needed
to *create* a gui toolkit, or handle hardware generally.
=> failure.
C has at least #3. It may not be much, and the system calls
we're talking about may be different on different platforms,
but on the strength of it has every GUI toolkit usable for C
and C++ been built.
And more than that; standard access to fundamental system
calls is core to controlling any and every sort of hardware,
so my little excursion in search of a GUI revealed a far
deeper problem.
People are telling me I should forgive this failure on the
basis of #4, nonstandard access to things through FFI. I
object; Nonstandard means that random implementation decisions
in dozens of places can break it, that it doesn't port across
different lisp implementations, and that substantial effort is
likely to be burned just "running in place" to keep it adapted
to current versions of particular implementations of Lisp. And
when I investigate further, that's exactly what I see evidence
of. Half-finished projects, projects that have succumbed to
bitrot as implementations changed out from under them, FFI's
that no longer work with current versions of what they were
built for, etc....
Now maybe it's obvious to you where to get the correct and
current versions of everything and which projects are dead
ends or cobwebs or incomplete or abandoned so you don't go
through the pain of trying to figure it out on your own, but
to me the fact that people have to sort through this crap
looking for stuff, is evidence of failure.
> Every GUI environment ranges from lousy to much worse when addressed
> from C. Your C compiler's compliance with the ABI gets you exactly
> nothing on the screen.
But the failure to comply with the ABI gets you no way to *BUILD*
anything that can put something on the screen. What's worse?
Bear
Ray Dillinger <····@sonic.net> writes:
> ··············@hotmail.com wrote:
> > Ray Dillinger wrote:
>
> My evaluation went something like this:
>
> 1) no gui toolkit built into the language or standardized.
That's true of virtually all programming languages. Java was the
first language I've seen to standardize on a GUI toolkit. So far it
is the only one, but I haven't gotten around that much.
Try the next best thing. CLIM looks a lot like a standard to me. If
nothing else, the document is one hell of a specification.
Alternatively you can go with an industry standard. OpenMCL has a
very high level of compatibility with Interface Builder. Apple really
wants you to use Interface Builder for new OS X applications. They
practically insist on it.
> 2) no gui toolkit in the free download of the language.
True, Interface Builder is bundled with Xcode and thus separate from
OpenMCL. Xcode comes from Apple and OpenMCL comes from Clozure. It's
at 1.0 now too! Furthermore, there is a freely available tool for
generating interfaces to Frameworks that have not already been covered
by the OpenMCL bundle.
Although it is a toy example on the level of "Hello, World!", I have
created (on an older version) a running application bundle with
OpenMCL. If nothing else, it proves a deliverable Lisp application
can be created that uses the native GUI.
> 3) no standard access to the fundamental system calls needed
> to *create* a gui toolkit, or handle hardware generally.
I've heard how easy this is to do in Perl, Java, Python, etc. At that
level you've left behind all notion of portability anyway. So going
back to OpenMCL I see that all those things seem to be there. I
haven't tried them all of course. It would take too many lifetimes to
try out every feature in a modern OS.
> => failure.
I think the only failure is a social and PR one. Lisp does have all
the things you are looking for, just not packaged up in the way you
seem to want (which seems to be impossible).
Lisp had some serious social and economic issues a while back.
Something about AI Winter I think. With funding yanked from large
projects, the only survivors in the commercial Lisp world were the
ones who decided that off the shelf hardware was a good target for
Lisp. So a relatively small community shrank.
Things are changing now. Lisp is getting more buzz. The only problem
is that the free implementations are not up to the standards that VB
programmers have gotten used to. There are far fewer people working
on all the free Lisp implementations than are working on Perl
libraries (or so I would guess).
The library issue is really a temporary one. As people come, they
will be built. Build them, and they will come.
--
http://www.david-steuber.com/
The UnBlog | Lisp on OS X topics for the most part
Click all the links you want. I'll make more!
David Steuber wrote:
> Ray Dillinger <····@sonic.net> writes:
>
>
>>··············@hotmail.com wrote:
>>
>>>Ray Dillinger wrote:
>>
>>My evaluation went something like this:
>>
>>1) no gui toolkit built into the language or standardized.
>
>
> That's true of virtually all programming languages. Java was the
> first language I've seen to standardize on a GUI toolkit. So far it
> is the only one, but I haven't gotten around that much.
>
> Try the next best thing. CLIM looks a lot like a standard to me. If
> nothing else, the document is one hell of a specification.
I don't know CLIM, but there seems to be a lot of good words said about
it, so I'll grant you that it's the best thing since sliced bread if it
makes you happier. The problem is, it isn't available for CLISP on Windows.
And I suspect that this is at the heart of Ray Dillinger's complaint
about Lisp. Too many square pegs trying to fit into too many round
holes. Using Lisp seems frustratingly like herding cats. You're just
about to put the last cat back in the box, only to have the lid spring
open and all the other cats escape.
The scripting languages seem to have this integration/compatability
problem largely nailed down. If you decide you need a GUI, you can go
low-fat (a la Tk), or high-fat (a la wxWidgets). And you stand a good
chance that it will be easy to install, mature, compatable, and
feature-complete. It's true that you still have to learn how to use the
API, that it may lack say a high-level declarative way of describing
GUIs; but still, at least you're pointing in the right direction, rather
than pushing peas 'round the plate in an interminable circle.
> The library issue is really a temporary one.
Or is it? Some of these issues seem to have stretched back to the 90's,
probably earlier.
> As people come, they
> will be built. Build them, and they will come.
At last, something we both can agree on.
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3qpo3uFg9njvU2@individual.net>
Mark Carter wrote:
> I don't know CLIM, but there seems to be a lot of good words said about
> it, so I'll grant you that it's the best thing since sliced bread if it
> makes you happier. The problem is, it isn't available for CLISP on Windows.
Windows is not an important platform.
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
From: Edi Weitz
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <uachkyvo0.fsf@agharta.de>
On Sat, 08 Oct 2005 13:16:14 +0200, Pascal Costanza <··@p-cos.net> wrote:
> Windows is not an important platform.
At least not for people who don't earn their money as professional
developers.
Cheers,
Edi.
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3qq1lqFgb9a8U1@individual.net>
Edi Weitz wrote:
> On Sat, 08 Oct 2005 13:16:14 +0200, Pascal Costanza <··@p-cos.net> wrote:
>
>>Windows is not an important platform.
>
> At least not for people who don't earn their money as professional
> developers.
Every rule has an exception... ;)
Pascal
P.S.: Come on, that statement was not less well-founded than lots of
other statements made recently around here... ;)
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
From: Edi Weitz
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <uslvcxf8w.fsf@agharta.de>
On Sat, 08 Oct 2005 15:59:22 +0200, Pascal Costanza <··@p-cos.net> wrote:
> P.S.: Come on, that statement was not less well-founded than lots of
> other statements made recently around here... ;)
That's certainly true... :)
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
Pascal Costanza wrote:
> Mark Carter wrote:
>
> > I don't know CLIM, but there seems to be a lot of good words said about
> > it, so I'll grant you that it's the best thing since sliced bread if it
> > makes you happier. The problem is, it isn't available for CLISP on Windows.
>
> Windows is not an important platform.
To some people, disproportionately represented in Lisp circles.
Whereas to game developers and multimedia content providers, it's a
very important platform.
Cheers,
Brandon J. Van Every
(cruise (director (of SeaFunc)
'(Seattle Functional Programmers)))
http://groups.yahoo.com/group/SeaFunc
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3qpofkFg8d8dU1@individual.net>
David Steuber wrote:
>>1) no gui toolkit built into the language or standardized.
>
> That's true of virtually all programming languages. Java was the
> first language I've seen to standardize on a GUI toolkit. So far it
> is the only one, but I haven't gotten around that much.
I also don't know whether Java is the first and/or the only language to
standardize on a GUI. But note that even in the case of Java this is not
a clear-cut thing. You can use AWT, Swing or SWT for desktops, and on
Mac OS X you can also use the bindings to the native GUI library. It
also depends on the specific IDE you use which of those alternatives is
better or at all supported, so no real difference to Common Lisp here.
And if you want to make sure that your programs also run on other
devices, it becomes even more problematic.
It seems to me that that happy world where it is obvious what GUI
library is the best to use doesn't exist.
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
Pascal Costanza wrote:
> David Steuber wrote:
> >>1) no gui toolkit built into the language or standardized.
> >
> > That's true of virtually all programming languages. Java was the
> > first language I've seen to standardize on a GUI toolkit. So far it
> > is the only one, but I haven't gotten around that much.
>
> I also don't know whether Java is the first and/or the only language to
> standardize on a GUI. But note that even in the case of Java this is not
> a clear-cut thing. You can use AWT, Swing or SWT for desktops, and on
> Mac OS X you can also use the bindings to the native GUI library. It
> also depends on the specific IDE you use which of those alternatives is
> better or at all supported, so no real difference to Common Lisp here.
> And if you want to make sure that your programs also run on other
> devices, it becomes even more problematic.
It's an uphill battle to please everyone with GUIs.
People even slam Java Swing for being a horrible GUI. (I think pretty
undeservedly, as there exist things like JGoodies.) I once mentioned
Edi's Regex Coach on some forum, and believe it or not, there was still
some (anonymous) guy who criticized it for not being Windows-like
enough.
Of course, it's #1 on a Google search for "regex", and exactly how
Windows-like is Firefox, Winamp, Bittorrent, and other successful
software? I think the Regex Coach looks more Windowsy than those
examples.
Tayssir
From: Edi Weitz
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <u64s8yvik.fsf@agharta.de>
On 8 Oct 2005 05:59:42 -0700, "Tayssir John Gabbour" <···········@yahoo.com> wrote:
> Of course, it's #1 on a Google search for "regex", and exactly how
> Windows-like is Firefox, Winamp, Bittorrent, and other successful
> software? I think the Regex Coach looks more Windowsy than those
> examples.
<plug>
Especially the brand-new "themable" version 0.7.0... :)
</plug>
Cheers,
Edi.
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
Pascal Costanza wrote:
>
> It seems to me that that happy world where it is obvious what GUI
> library is the best to use doesn't exist.
Indeed, especially as from my standpoint, none of these GUIs are ever
designed for game developers. For a long time now, I have contemplated
a GUI contained completely within OpenGL. So that when a game
developer wants to combine menus, skins, 2D, 3D, and text, all these
things are available and integrated. I hear that MacOS has already
done this, but that it's specific to MacOS. Microsoft seems to be
doing it for their Aerospace desktop, but that's all DirectX. What I
want is a self-contained cross-platform system. Of course, various
antagonists and the forces of Nature will try to prevent this from ever
happening.
GTK is supposed to have some kind of OpenGL rendering back-end as of
fairly recently, but I haven't investigated whether it's usable from a
game developer's standpoint. I doubt it, seeing as how GTK looks by
all accounts rather labyrinthine, and skinning + custom shapes really
isn't an ad hoc capability. But I could be mistaken. Hm, I guess I'll
go resolve that question now.
Cheers,
Brandon J. Van Every
(cruise (director (of SeaFunc)
'(Seattle Functional Programmers)))
http://groups.yahoo.com/group/SeaFunc
Cruise Director wrote:
>
> GTK is supposed to have some kind of OpenGL rendering back-end as of
> fairly recently, but I haven't investigated whether it's usable from a
> game developer's standpoint. I doubt it, seeing as how GTK looks by
> all accounts rather labyrinthine, and skinning + custom shapes really
> isn't an ad hoc capability. But I could be mistaken. Hm, I guess I'll
> go resolve that question now.
It appears to be a work-in-progress, not something usable yet.
http://bugzilla.gnome.org/show_bug.cgi?id=119189
http://live.gnome.org/ProjectRidley
Cheers,
Brandon J. Van Every
(cruise (director (of SeaFunc)
'(Seattle Functional Programmers)))
http://groups.yahoo.com/group/SeaFunc
From: lin8080
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <434D5918.29AC7549@freenet.de>
Cruise Director schrieb:
There is povray. Some work and the use of Lisp can bring nice things,
hm? (just a thought)
stefan
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3qpp4tFe7g7uU1@individual.net>
Ray Dillinger wrote:
> My evaluation went something like this:
>
> 1) no gui toolkit built into the language or standardized.
> 2) no gui toolkit in the free download of the language.
> 3) no standard access to the fundamental system calls needed
> to *create* a gui toolkit, or handle hardware generally.
> => failure.
>
> C has at least #3. It may not be much, and the system calls
> we're talking about may be different on different platforms,
> but on the strength of it has every GUI toolkit usable for C
> and C++ been built.
Your argumentation structure is circular. Of course C can use all the
GUI toolkits that have been built for C. ?!?
People are currently working on improving the infrastructure for Common
Lisp in the direction that you seem to think is necessary, and you
probably know that. What's your problem? That it's not available right
here, right now?
The Common Lisp "community" has seen a good improvement rate in all
kinds of aspects during the recent years. However, these things don't
happen over night, but they take their time. That should be obvious.
The reasons why a language that is nearly half a decade old lacks in
some respects have been discussed before. Discussing them won't help you
solve your problem. If you need something to solve your problem _today_,
there are options available. They may not fulfil all of your criteria,
but it is definitely possible to get things done. And if that's your
goal, I really don't understand why you are not more pragmatic about
this. If you are worried about how to make things work much better in
Common Lisp on a more general scale, there are also lots of
opportunities to do something constructive, like implementing, testing
and documenting APIs.
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
Ray Dillinger wrote:
>
> Now maybe it's obvious to you where to get the correct and
> current versions of everything and which projects are dead
> ends or cobwebs or incomplete or abandoned so you don't go
> through the pain of trying to figure it out on your own, but
> to me the fact that people have to sort through this crap
> looking for stuff, is evidence of failure.
Actually, in fairness, you do encounter these failures in the C/C++
universe as well. You just get farther along in hardware / GUI / OS
capabilities offered before experiencing the failures. Open Source has
a distinct "you get what you pay for" quality about it. How I wish I
had piles of money to pay people to make things work properly.
Meanwhile, Microsoft's business model is to keep pulling the API rug
out from under you, so that you continue to have to dance to their
tune. To quote from The Wiz: you can't win, you can't get even, and
you can't get out of the game.
Most of computerdom is a failure of some sort or another. I mean,
especially if you focus on the computer industry, it's mostly drivel.
Janitorial push-pull-push-click raised to excruciating levels of
minutiae. But what are we going to do? Getting APIs to automagically
talk to each other is exponentially hard. Currently it requires human
guidance, and there's little we can automate about it. How badly we
need something approaching strong AI....
Cheers,
Brandon J. Van Every
(cruise (director (of SeaFunc)
'(Seattle Functional Programmers)))
http://groups.yahoo.com/group/SeaFunc
On 12 Oct 2005 01:08:50 -0700, "Cruise Director"
<···········@gmail.com> wrote:
>Meanwhile, Microsoft's business model is to keep pulling the API rug
>out from under you, so that you continue to have to dance to their
>tune.
Sorry, but that's a cop out. Since about 1995 the Window's APIs have
had excellent backward compatibility with previous versions. This is
despite the fact that large parts of 32-bit Windows have been
reimplemented as COM components, and some have now been done over
again as .NET components.
Forget about updates ... just pick yourself a tool chain, freeze it
and start writing code. Don't bother with anything new unless you
have to.
George
--
for email reply remove "/" from address
From: Greg Menke
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m3d5m365og.fsf@athena.pienet>
George Neuner <·········@comcast.net> writes:
> On 12 Oct 2005 01:08:50 -0700, "Cruise Director"
> <···········@gmail.com> wrote:
> Forget about updates ... just pick yourself a tool chain, freeze it
> and start writing code. Don't bother with anything new unless you
> have to.
>
#ifdef WIN95
#endif
#ifdef WIN98
#endif
#ifdef WINME
#endif
#ifdef WINCE
#endif
#ifdef WINNT3
#endif
#ifdef WINNT4
#endif
#ifdef WINXP
#endif
Freeze away- just as long as you freeze the OS too...
Gregm
On 17 Oct 2005 20:15:59 -0400, Greg Menke <············@toadmail.com>
wrote:
>George Neuner <·········@comcast.net> writes:
>
>> On 12 Oct 2005 01:08:50 -0700, "Cruise Director"
>> <···········@gmail.com> wrote:
>> Forget about updates ... just pick yourself a tool chain, freeze it
>> and start writing code. Don't bother with anything new unless you
>> have to.
>>
>
>#ifdef WIN95
>#endif
>
>#ifdef WIN98
>#endif
>
>#ifdef WINME
>#endif
>
>#ifdef WINCE
>#endif
>
>#ifdef WINNT3
>#endif
>
>#ifdef WINNT4
>#endif
>
>#ifdef WINXP
>#endif
>
>Freeze away- just as long as you freeze the OS too...
>
You forgot to mention Win32s and 64-bit Windows 8-)
Excepting the oddballs [95, CE and NT3], for a large class of
applications you can write portable code for the rest - it just won't
run as efficiently as target specific code on the more capable
platforms. The majority of the platform API differences are just
performance enhancements. The differences that matter are security
related - and if you're really concerned about security you won't be
using 95, 98, ME or CE.
From the perspective of most desktop applications, NT4/2K/XP are the
same platform - what minor differences do exist can be handled
portably and fairly easily. Similarly server apps can largely treat
2K/XP/2003 as the same platform. If your application targets .NET, it
can run on any of the desktop platforms except 95 and if you target
Mono rather than MS.NET you can run .NET apps even on 95.
AFA networking, multimedia, gaming, crypto, etc. - all of those APIs
are add-ons, are backward compatible and are redistributable. A
program written for a particular version will work on any platform
running that version or higher [e.g., DirectDraw 8 still implements
DirectDraw 2, MAPI 2.0 still speaks MAPI 1.0, etc.].
My point in all of this is simply that it frequently isn't necessary
to keep pace with the Microsoft API treadmill. There are precious few
applications which absolutely demand the latest and greatest
functionality and Microsoft has been good about keeping backward
compatibility for a long time now.
George
--
for email reply remove "/" from address
···············@hotmail.com" <············@gmail.com> writes:
> Ray Dillinger wrote:
>> Greg Menke wrote:
>
>>
>> I reiterate: it is no longer okay for a language standard
>> to fail to explain how to put up a standard GUI, or at the
>> very least link to the C libraries that do.
>
> WTF do you mean by "standard GUI" here? What Java does?
You can choose between three of four different GUI.
I like Cocoa.
http://developer.apple.com/documentation/Cocoa/Conceptual/JavaTutorial/index.html
It's written in Objective-C.
And there's a FFI to Cocoa from OpenMCL, and of course, from the
commercial CL implementations on MacOSX.
Java 1 -- Lisp 1 -- Objective-C 1 -- C 0 -- C++ 0
Well you can call the Objective-C runtime from C or C++, but it'd feel
like assembler. There's no language level bindings to Cocoa from C or
C++.
> The C++ standard, for instance, which no one seems to worry about
> (i.e., you don't see trolls in C++ forums complaining "The C++ standard
> doesn't support GUI development..."), certainly does not provide
> facilities to do anything remotely close to that. In fact, you have to
> code for the platform you want to deliver on, and portability is
> nonexistent.
Right, C++ is quite lacking.
--
"Specifications are for the weak and timid!"
··············@hotmail.com wrote:
> Ray Dillinger wrote:
>
>>Greg Menke wrote:
>
>
>>I reiterate: it is no longer okay for a language standard
>>to fail to explain how to put up a standard GUI, or at the
>>very least link to the C libraries that do.
>
>
> WTF do you mean by "standard GUI" here? What Java does?
>
> Or are you talking about some other language standard which lets you
> write one program (completely within the standard,) and are able to do
> everything from device drivers to GUI output to direct screen access to
> OS kernel tweaks to networking code and have it work transparently, on,
> say Mac OS X, Linux, and Windows?
I mean being able to use the hardware and OS. I mean being
able to handle memory-mapped I/O and issue interrupts and
install machine-code interrupt handlers. I mean being able
to issue direct calls to routines that are part of the
operating system, including routines written in whatever
language the operating system is written in. I mean the
same kind of basic infrastructure that has allowed most
existing hardware handling (including Operating Systems and
GUIs) for all languages to be built.
Different on different operating systems, yes, because
different OS's provide different things to use. Different
hardware causes the same kind of problem in that there are
different things to use. I get that. But fundamentally,
what I want is for the bottom level of the infrastructure -
the fundamental bones that support everything - to be there.
When I use lisp, I feel like a very smart jellyfish in a
world dominated by vertebrates.
A "whole" language means one that can control the hardware
as well as manipulate information. A "whole" language is
one that a whole system and programming environment can be
built in. A "whole" language is not tenuously linked to
the OS via some FFI bridge or a set of wrappers or bindings
- it has a standard way of getting meaningful calls to *any*
OS functions, including ones its implementors didn't
consider, and a way of accessing information returned from
the OS, including information that's not in its own native
representation. Bits and bytes and words and data layout
in all their filth and inelegance, are dead necessary
for reading foreign binary data formats.
And I'll shut up about this now; this discussion was
originally an attempt to shed light on why people think
of Lisp as half a language, but has attracted the usual
crowd of partisans who take any request for this stuff
and pretend that substitutes and halfmeasures and
implementation-dependent extensions can possibly cover it.
It can't. My frustration is beginning to show in responses,
and we've gotten to the point of more heat than light.
Bear
Ray Dillinger <····@sonic.net> writes:
> And I'll shut up about this now; this discussion was
> originally an attempt to shed light on why people think
> of Lisp as half a language, but has attracted the usual
> crowd of partisans who take any request for this stuff
> and pretend that substitutes and halfmeasures and
> implementation-dependent extensions can possibly cover it.
> It can't. My frustration is beginning to show in responses,
> and we've gotten to the point of more heat than light.
Speaking of frustration and heat, there's not much need for extensive
explanations of why people think of Lisp as half a language because of
the lack of libraries. Even a Lisp newbie knows that. There's just
need for more people that sit down and write the fucking code.
Paolo
--
Why Lisp? http://wiki.alu.org/RtL%20Highlight%20Film
Recommended Common Lisp libraries/tools:
- ASDF/ASDF-INSTALL: system building/installation
- CL-PPCRE: regular expressions
- CFFI: Foreign Function Interface
On Sat, 08 Oct 2005 22:10:13 +0000, Christopher C. Stacy wrote:
> Some people come here repeatedly and hang around for a long time,
> sometimes years, sometimes under different names, repeating the same
> lies and misinformation about Lisp, and write in such a way as to
> mislead newbies about the facts.
Isn't that what a FAQ is for?
From: Surendra Singhi
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <64s7h050.fsf@netscape.net>
"justinhj" <········@gmail.com> writes:
> I was interested in wxCL and spent a few hours trying to get that
> working with clisp and cygwin. Had to download a special clisp version
> of uffi which eventually didn't seem to work. Perhaps with another few
> hours or days I could get it working, until something changes again and
> breaks it.
wxCL doesn't needs UFFI, it will work with clisp 2.34 and above. Can you
please elaborate what kind of problems you faced using it with clisp on
cygwin? Unless you tell whats going wrong or what kind of error messages you
are getting its hard to help you.
I remember you had reported a bug, did you try the fix? Please try the latest
wxcl release and if you are still having any trouble, please let us know.
You can download it from:
http://www.wxcl-project.org/en/downloads--downloads-1.html
And for bug reports or problems you can contact us:
http://www.wxcl-project.org/en/contact--contact-1.html
Cheers.
--
Surendra Singhi
http://www.public.asu.edu/~sksinghi/index.html
,----
| "All animals are equal, but some animals are more equal than others."
| -- Orwell, Animal Farm, 1945
`----
Having trouble installing wxcl-1.1.1
On the first try I was getting the same error I reported previously
about clisp_wrappers being accessed with an incorrect path. I realised
I needed to uninstall wxcl-1.0.0 first, and I 've now done that.
I'm now getting an error accessing the dll, which seems to be also path
related since the dll file does seem to exist where it's looking...
#P"/usr/local/asdf-install/site/wxcl-1.1.1/"
#P"/usr/local/asdf-install/site/wxcl-1.1.1/" ;;; ASDF-INSTALL: Loading
system "wxcl" via ASDF.
; loading system definition from
/usr/local/asdf-install/site-systems/wxcl.asd into #<PACKAGE ASDF3566>
;; Loading file /usr/local/asdf-install/site-systems/wxcl.asd ...
"Copyright (c) Surendra Singhi 2005"
"wxCL = wxWidgets + Common Lisp"
; registering #<SYSTEM WXCL #x102B2975> as WXCL
;; Loaded file /usr/local/asdf-install/site-systems/wxcl.asd
;; Loading file
/usr/local/asdf-install/site/wxcl-1.1.1/clisp-wrappers/wxCL.fas ...
*** - FFI::FOREIGN-LIBRARY: Cannot open library
"../miscellaneous/wxc-msw2.6.2.dll": "No such file or directory"
The following restarts are available:
USE-VALUE :R1 You may input a value to be used instead.
SKIP :R2 skip this form and proceed
STOP :R3 stop loading file
RETRY :R4 Retry performing #<ASDF:LOAD-OP NIL #x10130415>
on #<ASDF:CL-SOURCE-FILE "wxCL" #x1008479D>.
ACCEPT :R5 Continue, treating #<ASDF:LOAD-OP NIL
#x10130415> on #<ASDF:CL-SOURCE-FILE "wxCL" #x1008479D> as having been
successful.
RETRY :R6 Retry installation
ABORT :R7 ABORT
*** - UNIX error 13 (EACCES): Permission denied
The following restarts are available:
SKIP :R1 skip this form and proceed
STOP :R2 stop loading file
RETRY :R3 Retry performing #<ASDF:LOAD-OP NIL #x10130415>
on #<ASDF:CL-SOURCE-FILE "wxCL" #x1008479D>.
ACCEPT :R4 Continue, treating #<ASDF:LOAD-OP NIL
#x10130415> on #<ASDF:CL-SOURCE-FILE "wxCL" #x1008479D> as having been
successful.
RETRY :R5 Retry installation
ABORT :R6 ABORT
Break 1 WXCL[2]>
From: Surendra Singhi
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <zmpi9u9l.fsf@netscape.net>
"justinhj" <········@gmail.com> writes:
> Having trouble installing wxcl-1.1.1
>
> I'm now getting an error accessing the dll, which seems to be also path
> related since the dll file does seem to exist where it's looking...
>
> "../miscellaneous/wxc-msw2.6.2.dll": "No such file or directory"
OK. In the file 'clisp-wrappers/wxCL.lisp' please modify this
(defconstant +library-name+ "../miscellaneous/wxc-msw2.6.2.dll")
to point to the absolute library path.
which I think in your case is
"/usr/local/asdf-install/site/wxcl-1.1.1/miscellaneous/wxc-msw2.6.2.dll"
If after making this change, if you still have problem then please let me
know.
Cheers.
--
Surendra Singhi
http://www.public.asu.edu/~sksinghi/index.html
,----
| By all means marry; if you get a good wife, you'll be happy. If you
| get a bad one, you'll become a philosopher.
| -- Socrates
`----
I got ltk and installed it. Everything compiled without issue, and I
can run ltk-eyes. Unfortunately I'm getting a blank window and an
infinite wait if I do ltk-test and either of the first two examples in
the tutorial.
justinhj wrote:
> I got ltk and installed it. Everything compiled without issue, and I
> can run ltk-eyes. Unfortunately I'm getting a blank window and an
> infinite wait if I do ltk-test and either of the first two examples in
> the tutorial.
>
There are reports of problems like this from some windows users - known
reasons are AOL internet connections and some tray programs. Try to
disable those and if that works, please let me know about the culprit :)
Peter
--
Ltk, the easy lisp gui http://www.peter-herth.de/ltk/
"justinhj" <········@gmail.com> writes:
> I was interested in wxCL and spent a few hours trying to get that
> working with clisp and cygwin. Had to download a special clisp version
[...]
> So next I'll look at Clim and ltk and see how I fair with those.
McCLIM is not available for Windows. And I wouldn't recommend CLIM to
a newbie.
Paolo
--
Why Lisp? http://wiki.alu.org/RtL%20Highlight%20Film
Recommended Common Lisp libraries/tools:
- ASDF/ASDF-INSTALL: system building/installation
- CL-PPCRE: regular expressions
- CFFI: Foreign Function Interface
Paolo Amoroso เขียน:
> "justinhj" <········@gmail.com> writes:
>
> > I was interested in wxCL and spent a few hours trying to get that
> > working with clisp and cygwin. Had to download a special clisp version
> [...]
> > So next I'll look at Clim and ltk and see how I fair with those.
>
> McCLIM is not available for Windows. And I wouldn't recommend CLIM to
> a newbie.
>
>
> Paolo
> --
> Why Lisp? http://wiki.alu.org/RtL%20Highlight%20Film
> Recommended Common Lisp libraries/tools:
> - ASDF/ASDF-INSTALL: system building/installation
> - CL-PPCRE: regular expressions
> - CFFI: Foreign Function Interface
I thought it was possible to run CLIM under Win32 CLISP. providing that
you have a Win32 X Server; you can always use Cygwin X. CLX talk
through pure socket protocol, doesn't it?
From: Edi Weitz
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <uwtkn7wyy.fsf@agharta.de>
On 8 Oct 2005 16:12:07 -0700, "justinhj" <········@gmail.com> wrote:
> I'll try that, but the advantage I get from Cygwin is I can use
> emacs.
You can use Emacs/SLIME/CLISP without Cygwin.
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
On 8 Oct 2005 08:46:50 -0700, "justinhj" <········@gmail.com> wrote:
>I don't want to use Corman because it's a time expiry.
Corman Lisp itself has no time limit ... only the GUI editor supplied
with it expires. You can always use another editor.
George
--
for email reply remove "/" from address
From: Greg Menke
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m3slve7gsh.fsf@athena.pienet>
Ray Dillinger <····@sonic.net> writes:
> Greg Menke wrote:
>
> > Really though, gui support is pretty far down the list of "important
> > features", and its not as if this discussion hasn't happend at least
> > 10's of times before in the last year or two. Does "signpost" somehow
> > NOT include using google at least once?
>
> Excuse me... if it were really nowhere near the top of
> the list of "important features", then why the *HELL*
> would it keep coming up dozens of times in a year or
> two??
>
> I reiterate: it is no longer okay for a language standard
> to fail to explain how to put up a standard GUI, or at the
> very least link to the C libraries that do.
>
> Bear
I think you should jump up and down in a fit and hold your breath till
you turn blue.
Gregm
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3ql2g4Ffhv7hU1@individual.net>
Ray Dillinger wrote:
> I reiterate: it is no longer okay for a language standard
> to fail to explain how to put up a standard GUI, or at the
> very least link to the C libraries that do.
A language standard that specifies standard GUIs or standard ways to
interface to C only cements the status quo. This actively stands in the
way of possible future developments, for example better GUIs or better
operating systems that are not implemented in C. Specifying such things
only sove short-term problems and become very quickly out of date.
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
Pascal Costanza wrote:
> Ray Dillinger wrote:
>> I reiterate: it is no longer okay for a language standard
>> to fail to explain how to put up a standard GUI, or at the
>> very least link to the C libraries that do.
> A language standard that specifies standard GUIs or standard ways to
> interface to C only cements the status quo.
"The status quo" being that people who need to write apps with
GUI's don't use Lisp.
Seriously; if we develop something better, that's okay too. But
the state that is "the status quo" for languages that can link to
infrastructure the OS provides would be a hell of a lot better
than what we have.
And I don't think Lisp will even attract a sufficiently large
critical mass of users to attempt to develop something better
unless it becomes usable for ordinary programming tasks first.
Bear
From: Wade Humeniuk
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <7Ui1f.8509$yS6.1780@clgrps12>
Ray Dillinger wrote:
>
> "The status quo" being that people who need to write apps with
> GUI's don't use Lisp.
>
I write apps needing GUIs in Lisp.
http://www.download.com/The-Runner-s-Log/3000-2136_4-6893549.html?tag=lst-0-1
here is screenshot of the updated main interface to the progam...
http://www3.telus.net/public/whumeniu/screenshot.bmp
----------------------------------------------------------------
Others...
http://www3.telus.net/public/whumeniu/concentration.zip
http://www3.telus.net/public/whumeniu/time-is-money.zip
http://www3.telus.net/public/whumeniu/ybbil-capi.zip
http://www3.telus.net/public/whumeniu/package-browser.lisp
----------------------------------------------------------------
and others not mentioned...
----------------------------------------------------------------
and the latest....
http://www3.telus.net/public/whumeniu/courier-snap.bmp
Which is a screenshot of a prototype for a WinCE based Courier
Tool. Which pretty well has got us the job...
Wade
From: Pascal Costanza
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3qlqk2Ffl874U1@individual.net>
Ray Dillinger wrote:
> Pascal Costanza wrote:
>
>> Ray Dillinger wrote:
>
>>> I reiterate: it is no longer okay for a language standard
>>> to fail to explain how to put up a standard GUI, or at the
>>> very least link to the C libraries that do.
>
>> A language standard that specifies standard GUIs or standard ways to
>> interface to C only cements the status quo.
>
> "The status quo" being that people who need to write apps with
> GUI's don't use Lisp.
I know people who use Lisp to write apps with GUIs. I have seen
presentations of quite a few people who do so at ILC'05. I know some who
earn their living doing so. There's not a lack of libraries, there's a
wrong perception of what's possible.
> And I don't think Lisp will even attract a sufficiently large
> critical mass of users to attempt to develop something better
> unless it becomes usable for ordinary programming tasks first.
I don't think so. There are quite a few people actually doing something
about the infrastructure.
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
From: Joe Marshall
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <fyreqiae.fsf@alum.mit.edu>
Ray Dillinger <····@sonic.net> writes:
> Greg Menke wrote:
>
>> Really though, gui support is pretty far down the list of "important
>> features", and its not as if this discussion hasn't happend at least
>> 10's of times before in the last year or two. Does "signpost" somehow
>> NOT include using google at least once?
>
> Excuse me... if it were really nowhere near the top of
> the list of "important features", then why the *HELL*
> would it keep coming up dozens of times in a year or
> two??
Infix notation must be an `important feature' then.
···············@gmail.com" <··············@gmail.com> writes:
>> 3. I would like to see Lisp's situation improve.
>> Could you say something specific about what you think
>> the problems with the Lisp libraries are?
>> For example, which ones you went looking for but were unable
>> to find? How did you go looking?
>> How did you solve the problem in C?
>
> A full GUI. That's the missing piece that put me off for a long time.
> If you're on a unix you're laughing, but with windows and osx (until
> the recent bundling of X11) you had nothing like a portable way to do
> this.
Actually, there are several GUI systems developped natively in Lisp.
There are SO GOOD, and C/C++ is SO BAD at Lisp FFI, that some of these
Lisp GUI systems have even been translated to C/C++ (eg. Garnet). And
all the other GUI written for Pascal, C, Objective-C, C++ or Java,
have been inspired by and just copied the Lisp GUI (sometimes by way
of Smalltalk). Why didn't they just do Lisp FFI to the existing Lisp
GUI?
You can still find and use easily Garnet or CLIM.
--
__Pascal Bourguignon__ http://www.informatimago.com/
-----BEGIN GEEK CODE BLOCK-----
Version: 3.12
GCS d? s++:++ a+ C+++ UL++++ P--- L+++ E+++ W++ N+++ o-- K- w---
O- M++ V PS PE++ Y++ PGP t+ 5+ X++ R !tv b+++ DI++++ D++
G e+++ h+ r-- z?
------END GEEK CODE BLOCK------
From: Robert Uhl
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m31x2yfljj.fsf@4dv.net>
Pascal Bourguignon <····@mouse-potato.com> writes:
>
> You can still find and use easily Garnet or CLIM.
Easy and CLIM go in the same sentence? And last I checked, CLIM looked
like ca. 1978 and Garnet looked like ca. 1993...
--
Robert Uhl <http://public.xdi.org/=ruhl>
I am constrained to admit a failure to understand why even a Class-A
luser, holder of the Blue Maximum Luser with Palms and Swords, would go
so far as to put a tongue to an anemone. --Mike Andrews
Robert Uhl <·········@NOSPAMgmail.com> writes:
> Pascal Bourguignon <····@mouse-potato.com> writes:
> >
> > You can still find and use easily Garnet or CLIM.
>
> Easy and CLIM go in the same sentence? And last I checked, CLIM looked
> like ca. 1978 and Garnet looked like ca. 1993...
With Garnet you can choose between looking like System 7 or looking
like the mid-late '90s.
--
/|_ .-----------------------.
,' .\ / | Free Mumia Abu-Jamal! |
,--' _,' | Abolish the racist |
/ / | death penalty! |
( -. | `-----------------------'
| ) |
(`-. '--.)
`. )----'
Christopher C. Stacy wrote:
> Ray Dillinger <····@sonic.net> writes:
>
>>Furthermore, Libraries *are* part of the C standard, and even
>>libraries that aren't mentioned in C99 are widely distributed,
>>available for many different compilers and systems, and well
>>documented. Don't we *wish* the same were true of Lisp...
> 1. Here are the C standard libraries:
<clip>
> Seems to me that Common Lisp has all those kinds
> of things built into the language.
Yes, except for the crucial point; a linking mechanism.
In order to support its standard libraries, C has to
provide a linking mechanism. And that mechanism can be
used to link directly to the hardware drivers by programs
that call them.
There are standard formats for linkable libraries; ELF
or a.out formats are well documented, and whichever is in
use, you can conform to it in terms of grotty, binary
data layout in order to assure that the C system can link
*ANYTHING* that presents that particular binary interface.
You can write drivers entirely in machine code, manipulating
hardware ports and issuing interrupts directly (which you
can't actually do from C) but you conform to a standard
linkable format and they *will* be usable by the C compiler
on that platform.
Further, these "grotty" functions (hardware ports and
interrupts) are OS infrastructure, so there are general
libraries that encapsulate them in a form callable from
C using C's own ABI on every OS written in C.
> 2. A number of important Libraries for Lisp are widely distributed,
> available for many different compilers and systems, and well
> documented.
>
> For example: Networking, Web Serving, SQL embedding and
> database drivers, XML processing, crypto, etc.
Networking would have been nice for the standard to mention
as something that existed; the rest, as far as I'm concerned,
do not reach across the hardware gap. In other words, I
wouldn't be worried after reading CLTL2 that they couldn't
be implemented, because they're just algorithmic. What I
worried about not being able to implement, and still worry
about not being able to implement portably, is stuff to do
with hardware; capturing mouse input, sending commands to the
scanner, manipulating Interrupt driven RS232 ports so as to
drive the arms and legs and wheels on robotics projects,
drawing stuff on the screen, etc.
> 3. I would like to see Lisp's situation improve.
> Could you say something specific about what you think
> the problems with the Lisp libraries are?
Most of this stuff (screen, mouse, network stack, scanner,
etc) is OS calls or hardware drivers, which means libraries to
do it have already been written and the interfaces to those
libraries conform to same ABI used by the C system on a given
OS. They're directly linkable from C programs, guaranteed.
What's not already written, you can write a driver for in
C using OS infrastructure, or in machine code if you have to
*create* the OS infrastructure. Since the ABI used on a
given platform is well documented, even if you have to use
machine code you can *make* your driver conform to that ABI
and thereby ensure that it's just as linkable.
This is missing on Lisp systems. There is no documented ABI
that you can make your library conform to in order to assure
that it's linkable from a Lisp system. Or, if there is, it's
seldom well documented and it seems that every system has
cooked up its own "fasl format" and it's not usable by anything
else. There is no OS infrastructure that takes hardware-handling
primitives (interrupts and hardware ports) and presents them in
a form usable to write drivers. And finally, it isn't at all
clear how to handle hardware in something that is linkable using
a FASL loader the same way it's clear how to handle hardware
(with machine code) in something that's linkable according to
the ELF ABI.
> For example, which ones you went looking for but were unable
> to find?
Windows, Icons, Mice, Buttons, Dialog boxes -- very very
basic stuff.
Bear
From: Christopher C. Stacy
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <uoe62a8an.fsf@news.dtpq.com>
Ray Dillinger <····@sonic.net> writes:
> Christopher C. Stacy wrote:
> > Ray Dillinger <····@sonic.net> writes:
>
> Yes, except for the crucial point; a linking mechanism.
> In order to support its standard libraries, C has to
> provide a linking mechanism. And that mechanism can be
> used to link directly to the hardware drivers by programs
> that call them.
You can link Lisp programs to C and C++ programs,
and you can deliver Lisp programs as DLLs that
can be linked by them.
[...]
> ELF
[...]
> You can write drivers entirely in machine code,
> manipulating hardware ports and issuing interrupts
[...]
> "grotty" functions (hardware ports and
> interrupts) are OS infrastructure
[...]
This commentary is still not specific enough.
Can you describe some specific program that you
wanted to write in Lisp that required these features,
and exactly why you needed them?
> Networking would have been nice for the standard to mention
> as something that existed; the rest, as far as I'm concerned,
> do not reach across the hardware gap.
You seem to be concerned about interfacing to hardware.
Common Lisp was not really designed for that purpose,
but it was designed so that it is not impossible.
The standard allows language implementors to define a subset,
and it allows them to make extensions or add libraries.
So the only thing standing in your way is the lack of a compiler
that produces code that doesn't rely on operating system services,
and that has the extension to create machine pointers.
(The latter would be implemented in the compiler in about
3 lines of code.) I think ECL might be the right compiler
for you. Have you tried that one?
Is there some particular program you could tell us
about that you wound up implementing in C because
Lisp was inadquate? (Or are you just making this up?)
> What I worried about not being able to implement,
> and still worry about not being able to implement
> portably, is stuff to do with hardware; capturing
> mouse input, sending commands to the scanner,
> manipulating Interrupt driven RS232 ports so as to
> drive the arms and legs and wheels on robotics
> projects, drawing stuff on the screen, etc.
Lisp is heavily used in GUI applications with mice.
Lisp is heavily used in robotics.
(In fact, it's been heavily used in those areas for
many years before C, but let's not talk history.)
> What's not already written, you can write a driver for in
> C using OS infrastructure, or in machine code if you have to
> *create* the OS infrastructure. Since the ABI used on a
> given platform is well documented, even if you have to use
> machine code you can *make* your driver conform to that ABI
> and thereby ensure that it's just as linkable.
The C standard does not give you any ABI to write device
drivers (or anything else for that matter) -- that's just
particular C implementations. Have you tried some of
the Lisp implementations that are intended for those kinds
of purposes?
> This is missing on Lisp systems. There is no documented ABI
> that you can make your library conform to in order to assure
> that it's linkable from a Lisp system. Or, if there is,
> it's seldom well documented and it seems that every system
> has cooked up its own "fasl format" and it's not usable by
> anything else.
On the Lisp compilers that I use, they produce executable
or shared object library files that are linkable in the
operating system's normal ABI.
You have slightly misunderstood what FASL files are for.
I suppose that an implementation could
> There is no OS infrastructure that takes hardware-handling
> primitives (interrupts and hardware ports) and presents them in
> a form usable to write drivers.
There's nothing in C that does that, either.
But nothing stops a compiler writer in either language
from providing those. And they have.
> And finally, it isn't at all clear how to handle hardware in
> something that is linkable using a FASL loader the same way
> it's clear how to handle hardware (with machine code) in
> something that's linkable according to the ELF ABI.
That's not what FASL files are for. You need to tell
your Lisp compiler to produce an ".so" or a ".DLL" or
whatever the particular host operating system wants.
> > For example, which ones you went looking for but were unable
> > to find?
>
> Windows, Icons, Mice, Buttons, Dialog boxes -- very very
> basic stuff.
Have you tried the free Lispworks ("Personal edition") system?
It has all those things (and more).
C doesn't have them.
Ray Dillinger wrote:
> What she meant was probably something like "I looked over the
> language spec once, and there was no way to open a window,
> blit a bitmap, put up a menu, catch mouse input, handle my
> scanner/printer/modem/audio driver, establish interrupt
> handlers, handle sockets and IP communications... you know,
> actually DOING the stuff people want software to DO."
Apologies for bad usenet form; I'm replying to myself.
It is no longer okay for a language spec to take a pass
on these things. It hasn't been okay since about the time
CLTL2 was published. There are basically only three
things which are okay for a modern language. You've got
to pick one of them, and write it directly into the standard,
or you're going to have users assume (correctly) that the
language does not support what they want to do. (Extensions
may, but not the language itself; let's not quibble.)
1. Be the language the operating system is written in,
or use its ABI natively so you can link seamlessly
with system libraries that control hardware. Most
procedural, stack-based languages that can be
characterized as "misspelled C with a bunch of
syntactic differences" go this route. It's the
expected thing, and failure to do it leads to
the assumption on many people's part that your
language isn't capable of fully interfacing with the
OS. If they don't see this, they look for #2.
2. Provide and standardize the wrappers around all useful
system calls so that people can write windowed apps that
use native threads and the TCP/IP stack and control
peripherals using only the language described by the
standard. Java, C#, various DotNet languages, etc, are
going this way. It's a heinous amount of work, but this
is one of the only ways for a language with fundamentally
different call semantics to "quick-start" people who
want to write "normal" applications. In fact, if they
don't get #1, most people expect both #2 AND #3 before
they feel secure about a language's ability to be useful.
3. Provide a portable means of making particular calls
that conform to that ABI (or any fully documented
ABI) so that people can write their own wrappers
around native system calls _portably_. Most lisp
systems provide a means of producing calls that conform
to the OS ABI somehow, but the Common Lisp standard
fails the test by not standardizing a syntax and a
semantics for it. UFFI is arriving almost twenty
years too late, and it's not even part of the standard
now. It could be thirty years too late by the time it
finally makes it. Mind that this is the absolutely
minimal expectation; most users expect #1, or #2 and #3
together. #2 is acceptable by itself only if someone
has done an amazing and thorough job. Many will not
be satisfied with #3 alone no matter how well it's done.
This approach actually requires work on their parts,
and they will feel that they are wasting effort
as compared with using a language that has that stuff
built-in.
If most application programmers read the lisp standard and
see no mention of any such capability, then I can't blame
them for filing it under "waste of time" before they even
attempt to download an implementation which may or may not
provide the capabilities they need.
Bear
Ray Dillinger <····@sonic.net> writes:
[snip useful standard APIs for various things]
> It is no longer okay for a language spec to take a pass
> on these things.
I had to reply somewhere and here seemed as good as any. If you need
more context, Gnus does have ^.
Common Lisp has a number of properties that hinder growing the user
base. First, while there are a couple of first rate commercial
implementations, they are expensive (although an MSDN subscription
will kill the cost of Lispworks). Second, there are numerous free
implementations that are in various stages of maturity with different
approaches to things not in the standard. Thanks to a small user
community where everyone implements the functionality they need now,
the myriad of libraries that exist for various single (or few)
implementation languages are just not there yet.
Lisp isn't standing still though. Portable FFI wrappers beyond UFFI
are developed. There is a CLIM implementation in the works (and
people who's judgement I trust say that CLIM is good). These things
will come to those who wait, or better yet, implement them.
I still feel that Lisp can be learned by the average programmer,
especially with other Lispers around to help out. The base language
is a good one. Once Emacs + SLIME are setup with a decent Lisp, it is
only a matter of time before developing a good workflow. People just
need encouragement for the things they want to do.
I could be biased though. When I learned to program, graphics
terminals were exotic stuff. Networking, for me, ment dialing in to
another computer with a terminal program. Perhaps when you start
out primitive, you don't mind working in an environment that doesn't
give you three clicks to a score of source files with built in project
manager tool in the IDE that hides the ugly details of what boiler
plate code was just generated to run in your WYSIAYG environment.
--
http://www.david-steuber.com/
The UnBlog | Lisp on OS X topics for the most part
Click all the links you want. I'll make more!
David Steuber <·····@david-steuber.com> writes:
> plate code was just generated to run in your WYSIAYG environment.
This is a good one: ___________________________^^^^^^^
--
__Pascal Bourguignon__ http://www.informatimago.com/
Until real software engineering is developed, the next best practice
is to develop with a dynamic system that has extreme late binding in
all aspects. The first system to really do this in an important way
is Lisp. -- Alan Kay
Hello.
well i am a relative newbie to lisp. i feel that lisp has been
overhyped as 'language of the elite'. its a great language but requires
the same amount of effort to learn well as any other language.
mastering a language takes years and this is the same with any other
language. its not a language for elites...any person can learn it well
if they put in the same amount of effort. its just a bit different and
a bit lacking in good teaching material (PCL is a great book though)
secondly learning a language like python before lisp (which is what i
had done) helps lower the barrier to lisp. and then learning lisp
actually makes you a better programmer in those languages as well. i
know relatively less lisp but even now i feel i am writing better
python which is what i use for most of college work.
thirdly some languages have some good learning infrastructure (like
python..its well documented and has lots of tutorials) and sell
themselves actively as easy to learn. (python official tutorial says
'learn python in an afternoon') this is contrary to the image of lisp.
rahul
····@b.c wrote:
> What if it's really just sour grapes?
>
> To people who know and use Lisp, it seems easy to learn. But what if
> it's actually not easy at all for the average programmer to learn it?
> Different minds, different learning styles, might find some particular
> subject matter many times easier to learn than others. If two English
> speakers, A and B, know no other languages than English, A might learn
> Spanish twice as fast as B, and B might learn German twice as fast as
> A. There might be differences in their mindsets, learning styles,
> etc., which make it easier to learn one language than another. The
> same phenomenon might make A learn Lisp 10 times faster than B, and B
> learn something else 10 times faster than A.
>
> What if only a small fraction of those who attempt to learn Lisp
> actually learn it, and the others give up after finding it hard to
> learn? Those who learn it might not understand how it could be
> difficult, and might think those who don't learn it are just lazy.
>
> One can learn Lisp just well enough to be able to write some simple
> programs in it, without actually learning it enough to really
> appreciate it or make good use of it. What if that's where the vast
> majority of Lisp learners actually are? They could have sour grapes
> about Lisp. They could have a faint hint that there is something
> there beyond their grasp, but see it from a sour grapes point of view.
> I.e., to them it might seem to be not worth their time, "because the
> grapes are probably sour."
>
> But from the point of view of those who have never even attempted to
> learn Lisp, the sour grapes person might seem like a Lisp expert, from
> having actually learned a small amount of Lisp and written some simple
> programs in it.
>
> What if, for every sour grapes Lisp person, there are 10 other people
> who have formed their opinions of Lisp by listening to the sour grapes
> person? And for each of those 10 others, 10 others who have formed
> their opinions from listening to that 2nd hand sour grapes opinion?
>
> If this turns out to be a real reason for Lisp's lack of popularity
> among the masses, it might also help explain Java's popularity. What
> if enough people actually learn Java well enough to make good use of
> it, that the masses who don't know or use Java get a 2nd hand "sweet
> grapes" opinion of it, and are thereby motivated to learn it?
>
> --
> (do((x(coerce "iukd9/.-<`[kl_b^b^ _Uc"
> 'list)(cdr x)))((not x))(princ (code-char
> (- (char-code (car x)) -18 (length x)))))
From: Greg Menke
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m3vf0nreiq.fsf@athena.pienet>
"Rahul" <·······@gmail.com> writes:
> Hello.
>
> well i am a relative newbie to lisp. i feel that lisp has been
> overhyped as 'language of the elite'. its a great language but requires
> the same amount of effort to learn well as any other language.
> mastering a language takes years and this is the same with any other
> language. its not a language for elites...any person can learn it well
> if they put in the same amount of effort. its just a bit different and
> a bit lacking in good teaching material (PCL is a great book though)
>
Lisp is different because of the headroom it gives you once you start to
understand how to use it. For trivial examples its not much different.
Nobody here thinks its a "language of the elite".
If you want to appreciate how nice Lisp is, then start using it. When
you have some little program to write or an idea to test, treat it like
a scripting language. Sometimes those little ideas get bigger and at
some point your mental gears will shift and you'll realize Lisp is a
whole lot more powerful than you thought. Its not about libraries and
tutorials, its about getting rid of the distractions and constraints and
artificialities which other languages so often impose.
Gregm
From: Ulrich Hobelmann
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3ppn3jFblfqiU1@individual.net>
·@b.c wrote:
> What if it's really just sour grapes?
>
> To people who know and use Lisp, it seems easy to learn. But what if
> it's actually not easy at all for the average programmer to learn it?
> Different minds, different learning styles, might find some particular
> subject matter many times easier to learn than others.
I think it's more of a social thing. Just like all my German friends
always say "nobody likes the French", everybody considers Lisp a weirdo
thing. If you make them study French or Lisp, they say it's hard and
weird. I think both are elegant and not too hard if you sit down and
actually learn it. Admitted, I might be a language guy, but then I
believe that I can grasp *anything* if I *want* to. It's a matter of work.
Most people don't care about programming, so they'll only do whatever
the market asks for (Java, SQL, and C# right now).
It also helps that most undergrad classes involve Scheme, and that they
revolve around recursion and list manipulation while the Java ones
revolve around databases or GUIs. It also helps that most people have
never used or seen a Lisp application in action.
--
Some people like democracy. That's because it does whatever the
majority wants, and because they happen to be part of that majority.
"Do you want the Total War?"
From: Edi Weitz
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <uzmq0cid6.fsf@agharta.de>
On Mon, 26 Sep 2005 09:42:43 +0200, Ulrich Hobelmann <···········@web.de> wrote:
> Just like all my German friends always say "nobody likes the French"
Maybe you have strange friends...
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
From: Ulrich Hobelmann
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3pq1qnFbjornU1@individual.net>
Edi Weitz wrote:
> On Mon, 26 Sep 2005 09:42:43 +0200, Ulrich Hobelmann <···········@web.de> wrote:
>
>> Just like all my German friends always say "nobody likes the French"
>
> Maybe you have strange friends...
Well, it's partly joking. We also sometimes make fun of our friends who
were born near the Dutch border, but it's not entirely serious.
Learning French (and liking it) is considered a weird thing, though, as
is Lisp.
But things change. When I bought my first Mac in December 03 that was
weird too. Now several other people own one :D
Maybe I can show them some useful Lisp someday.
--
Some people like democracy. That's because it does whatever the
majority wants, and because they happen to be part of that majority.
"Do you want the Total War?"
Hi!
Well, I can only speak for myself. I'm a newbie learning lisp, and my
previous experience was java (I had my "Basic" time, little fortran,
php at work, and even assembler for an old cute little 'computer' with
a Z80A CPU -a TK85, a clone of the Sinclair 1500. Maybe one of you
remember it...).
I still 'don't get' Lisp, and just manage to do some simple tasks (as
you can see en c.l.l.), and I can say positively that common lisp was
great at doing them. For example, the problem of the representation of
a rotating hypercube was in my mind for several years; I never succeded
in it. But in a week or so, with CL, I could get it in my pc screen!
I'm not saying that it was entirely due to CL; maybe this new approach
to the problem came when I was prepared to solve it, using any language
of my choice. But I think that it is still significant that the 'right'
moment came along with my learning of CL.
Anyway, and despite the fact that in the future I can take advantage of
the full potential of lisp, I found that CL is a perfect tool for
simple tasks. And I don't feel it as if 'killing a fly with a missile';
the code looks as if it 'fits' the problem.
Just the 2 cents of a novice :-)
Luis.
From: Robert Uhl
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <m34q87s9zi.fsf@4dv.net>
Ulrich Hobelmann <···········@web.de> writes:
>
> I think it's more of a social thing. Just like all my German friends
> always say "nobody likes the French", everybody considers Lisp a
> weirdo thing.
But nobody _does_ like the French:-)
Actually, when I was over there I thought that everyone outside of Paris
was wonderful. Some of the nicest people around, even if their attitude
towards work was...casual.
--
Robert Uhl <http://public.xdi.org/=ruhl>
I wish everyone were peaceful. Then I could take over the planet with a
butter knife. --Dogbert
From: Revzala Haelmic
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <dh9hs5$rau$1@domitilla.aioe.org>
Ulrich Hobelmann wrote:
> I think it's more of a social thing. Just like all my German friends
> always say "nobody likes the French", everybody considers Lisp a weirdo
> thing. If you make them study French or Lisp, they say it's hard and
> weird. I think both are elegant and not too hard if you sit down and
> actually learn it. Admitted, I might be a language guy, but then I
> believe that I can grasp *anything* if I *want* to. It's a matter of work.
Well, really! Why do they always talk about Lisp here? Let's better talk about
more complicated things like the French or, for example, a democracy. :))
> It also helps that most undergrad classes involve Scheme, and that they
> revolve around recursion and list manipulation while the Java ones
> revolve around databases or GUIs. It also helps that most people have
> never used or seen a Lisp application in action.
Beyond the jokes, that gets exactly to the point. Why does it happen that having
spent almost equal amount of time, Scheme students continue to learn language
while Java folks start making fun with databases and GUIs?
Maybe the reason is that Scheme doesn't have good GUI or database libraries? So
a course continues on a desert ground of pure theory, where all beautiful things
being learned have no practical continuation and are soon forgot, or become
subconsciously adopted when using another languages. The latter was a perfectly
acceptable goal for the times when Lisp was for theory and prototypes only.
Let's take for an instance one of Java practical courses, which is about
buildling a real applicaion and involves DB or GUI or both. Now let's substitute
Lisp for Java. What makes such course impossible?
From: Ulrich Hobelmann
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3pr7qaFber97U1@individual.net>
Revzala Haelmic wrote:
>> It also helps that most undergrad classes involve Scheme, and that
>> they revolve around recursion and list manipulation while the Java
>> ones revolve around databases or GUIs. It also helps that most people
>> have never used or seen a Lisp application in action.
>
> Beyond the jokes, that gets exactly to the point. Why does it happen
> that having spent almost equal amount of time, Scheme students continue
> to learn language while Java folks start making fun with databases and
> GUIs?
I think they try to teach students language principles (in Scheme) and a
mainstream language (Java). At least that's what they did with me. The
point being that in Scheme you *can* teach language principles, whereas
Java isn't really orthogonal in its constructs.
> Maybe the reason is that Scheme doesn't have good GUI or database
> libraries? So a course continues on a desert ground of pure theory,
Hm, I'm sure there are Scheme ODBC libs out there. I'm sure they are
decent. Most people who use databases run either Tomcat or some kind of
LAMP (with whatever P).
> where all beautiful things being learned have no practical continuation
> and are soon forgot, or become subconsciously adopted when using another
> languages. The latter was a perfectly acceptable goal for the times when
> Lisp was for theory and prototypes only.
Well, maybe they should teach CL, not Scheme. It's not as elegant, but
much more practical (YMMV of course).
> Let's take for an instance one of Java practical courses, which is about
> buildling a real applicaion and involves DB or GUI or both. Now let's
> substitute Lisp for Java. What makes such course impossible?
Nothing I guess :)
--
Do or do not. There is no try.
Yoda
From: Edi Weitz
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <uk6h3qrrf.fsf@agharta.de>
On 26 Sep 2005 23:59:03 GMT, ···@zedat.fu-berlin.de (Stefan Ram) wrote:
> Using Scheme on dotnet should mean access to database
> management systems and GUI-libraries.
>
> The following page claimes "Scheme" was supported by
> the dotnet-platform, though I am not aware of where to
> actually get an implementation from.
>
> http://www.startvbdotnet.com/dotnet/languages.aspx
For Scheme:
<http://www.rivendell.ws/dot-scheme/>
<http://www.ccs.neu.edu/home/will/Larceny/download-common.html>
<http://www.cs.indiana.edu/~jgrinbla/>
For Common Lisp:
<http://foil.sourceforge.net/>
<http://weitz.de/rdnzl/>
Cheers,
Edi.
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
From: Matthias Buelow
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3ptgo3Fc5d26U3@news.dfncis.de>
Ulrich Hobelmann <···········@web.de> wrote:
>Just like all my German friends always say "nobody likes the French",
I don't know what friends you have, but for the reassurance of French
readers here, I would like to say that this is not a sentiment that
seems to be very common, at least not around me.
mkb.
Matthias Buelow <···@incubus.de> writes:
> Ulrich Hobelmann <···········@web.de> wrote:
>
> >Just like all my German friends always say "nobody likes the French",
>
> I don't know what friends you have, but for the reassurance of French
> readers here, I would like to say that this is not a sentiment that
> seems to be very common, at least not around me.
Nor around me here in Munich. Sounds like this Ulrich fellow just has
some nasty, ignorant friends. I do get more shit here about my
affection for Smalltalk and partial affection for static types, though.
--
/|_ .-----------------------.
,' .\ / | Free Mumia Abu-Jamal! |
,--' _,' | Abolish the racist |
/ / | death penalty! |
( -. | `-----------------------'
| ) |
(`-. '--.)
`. )----'
From: Edi Weitz
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <upsqunw63.fsf@agharta.de>
On 27 Sep 2005 12:24:46 -0700, ···@conquest.OCF.Berkeley.EDU (Thomas F. Burdick) wrote:
> Sounds like this Ulrich fellow just has some nasty, ignorant
> friends.
Either that or he doesn't know the difference between "nobody likes
French" and "nobody likes /the/ French." (Still, I personally don't
know any Germans who don't like French either. Just a few who don't
speak it very well, including myself.)
Cheers,
Edi.
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
From: Ulrich Hobelmann
Subject: Re: Why Lisp is not popular with average programmers
Date:
Message-ID: <3ptlg9Fc99nsU1@individual.net>
Edi Weitz wrote:
> On 27 Sep 2005 12:24:46 -0700, ···@conquest.OCF.Berkeley.EDU (Thomas F. Burdick) wrote:
>
>> Sounds like this Ulrich fellow just has some nasty, ignorant
>> friends.
>
> Either that or he doesn't know the difference between "nobody likes
> French" and "nobody likes /the/ French." (Still, I personally don't
I meant the second one, but, as I said earlier, it's half joking. My
friends aren't seriously against other nationalities. Probably it
indeed has to do with an aversion against the language.
--
Do or do not. There is no try.
Yoda