James Hague <······@dadgum.com> writes:
> Still, I think Lisp has some trouble because it's not as easy to use
> for shippable desktop applications as, say, C. Most of the free
> Lisp systems tend to be rather large with little thought given to
> turnkey applications. The best commercial Lisp on the
> market--Allegro Common Lisp--isn't royalty free. On the other hand,
> desktop applications are a small part of the overall picture.
what do you mean desktop application?
lisp suffers because it's hard to make hello world type starter
programs that stand alone in a lisp hostile operating system, e.g.,
unix, microsoft dos/windows[1].
lisp tends to seem large and awkward in the context of unix. C has
run-time library support and all kinds of operating system hooks. the
comparison is unfair, however, a completely fair appraisal is
unrealistic.
if you mean by desktop applications things like spreadsheets and
wordprocessors, then i would think that lisp would be the perfect
language. these applications are large and complex in the first
place. lisp is good at large and complex. a lisp run-time would be
lost in the noise. consider how well emacs works for text. now
imagine a lisp based wordprocessor. unfortunately, no one uses lisp
for these but that is more out of ignorance than sound judgement imho.
[1] (format t "hello world~%") is certainly easy. the hard part is
getting the operating system to cooperate in loading and launching
lisp to process this.
--
J o h a n K u l l s t a m
[········@ne.mediaone.net]
Don't Fear the Penguin!
In article <··············@sophia.axel.nom>, Johan Kullstam <········@ne.mediaone.net> reiterated false information:
> lisp suffers because it's hard to make hello world type starter
> programs that stand alone in a lisp hostile operating system, e.g.,
> unix, microsoft dos/windows[1].
Have you ever tried? LWW? ACL? Golden CL? CLOE? LW? LCL?
Eclipse CL? Clisp? GCL? CMU CL? CLICC? MCL? Chestnut CL?
Corman Lisp? Exper Common Lisp? Procyon Common Lisp? L?
Codemist Common Lisp? ECoLisp? LinkLisp? ...?
You mean *all* these Lisp system have been developed
without making it easy to develop applications?
> lisp tends to seem large and awkward in the context of unix.
Have you ever tried? We are doing it all the time.
> now imagine a lisp based wordprocessor. unfortunately, no one uses lisp
> for these
No one? How do you know?
An example: Ever heard of Interleaf? From the Interleaf FAQ:
1.1. What is Interleaf?
Interleaf, Inc. provides software and services to allow organizations
to build, integrate and manage document systems. Interleaf software
covers the full range of document processes: accessing information,
developing text and graphic documents, putting them through their
review and revision processes, distributing them electronically or on
paper, and managing the entire process.
"Interleaf 6" is a document authoring and composition package. It
provides an integrated set of tools for creating compound documents:
word processing, graphics, data-driven business charts, tables,
equations, image editing, automated page layout, book building-
including automatic index and TOC, conditional document assembly. It
includes several features engineered to support the production of large
and complex document sets, including: centralized control over parts
or all of a document (format and/or content), global search and
replace/change on individual graphics objects regardless of specific
orientation or position, revision management.
Also available (on some platforms) is the optional Developer's Toolkit
(DTK) for customizing or extending the capabilities of the above
authoring tool. Developer's Toolkit is used to write programs in
Interleaf Lisp. Interleaf Lisp is similar to CommonLISP, but it also
contains an extensive set of classes, methods, and functions for
examining and changing almost all Interleaf objects, including
documents and their contents. DTK includes an editor, debugger,
compiler, listener, interpreter, and on-line documentation. Lisp code
developed with DTK, or even written with an ordinary editor, can be
executed by the stock system, so that customization or the provision of
special functionality is not limited to installations with DTK. In
fact, much of the distributed system is written in Lisp.
That you don't have heard about publishing applications using Lisp
doesn't mean that they don't exist (-> Schematext, Concordia, ...).
······@lavielle.com (Rainer Joswig) writes:
> In article <··············@sophia.axel.nom>, Johan Kullstam <········@ne.mediaone.net> reiterated false information:
>
> > lisp suffers because it's hard to make hello world type starter
> > programs that stand alone in a lisp hostile operating system, e.g.,
> > unix, microsoft dos/windows[1].
>
> Have you ever tried? LWW? ACL? Golden CL? CLOE? LW? LCL?
> Eclipse CL? Clisp? GCL? CMU CL? CLICC? MCL? Chestnut CL?
> Corman Lisp? Exper Common Lisp? Procyon Common Lisp? L?
> Codemist Common Lisp? ECoLisp? LinkLisp? ...?
> You mean *all* these Lisp system have been developed
> without making it easy to develop applications?
i use linux and windows nt. i've tried CMUCL, clisp and ACL5. i find
that they are all awkward at producing a hello world application.
sure i can open up a lisp and type (format t "hello world") or (load
"hello-world") and then run something. sometimes, i can put
#!/usr/bin/lisp at the top of a lisp script. some lisps get upset
about lines beginning with #!. in any event, they (at least CMUCL,
clisp and trial ACL5) don't produce a stand alone binary i can copy to
someone. maybe i am doing something wrong.
i am not trying to run anyone down. i just started using lisp about
6-7 months ago and i really like it. it's just that unix and windows
are set up to support C and C++. e.g., C has a largish libc these
days. it's pretty much always in core and therefore no one pays any
attention to it.
> > lisp tends to seem large and awkward in the context of unix.
>
> Have you ever tried? We are doing it all the time.
i use lisp for lots of stuff. i just wish i had an operating system
which offered better integration with lisp. perhaps i am missing some
things i could do? is there a lisp-howto for linux out there? i mean
paul graham's books, the hyperspec, steele's book, the cmucl user
manual, acls docs are great. however i haven't found a good low level
nitty gritty here's how you use emacs, here's how you get a bash shell
in linux to launch a lisp program, when should you clobber and restart
your lisp listener, how many lisps do you need going at once &c.
> > now imagine a lisp based wordprocessor. unfortunately, no one uses lisp
> > for these
>
> No one? How do you know?
>
> An example: Ever heard of Interleaf? From the Interleaf FAQ:
no, i had never heard of interleaf. thanks.
> 1.1. What is Interleaf?
[snip]
> That you don't have heard about publishing applications using Lisp
> doesn't mean that they don't exist (-> Schematext, Concordia, ...).
nod. thanks for the info.
--
J o h a n K u l l s t a m
[········@ne.mediaone.net]
Don't Fear the Penguin!
Johan Kullstam <········@ne.mediaone.net> writes:
> manual, acls docs are great. however i haven't found a good low level
> nitty gritty here's how you use emacs, here's how you get a bash shell
> in linux to launch a lisp program, when should you clobber and restart
> your lisp listener, how many lisps do you need going at once &c.
Bundled with the Debian CMU CL packages, there is a short file
somewhere in /usr/doc/cmucl/ that explains how to get Linux to start
lisp files via CMU CL...
Regs, Pierre.
--
Pierre Mai <····@acm.org> PGP and GPG keys at your nearest Keyserver
"One smaller motivation which, in part, stems from altruism is Microsoft-
bashing." [Microsoft memo, see http://www.opensource.org/halloween1.html]
Johan Kullstam <········@ne.mediaone.net> wrote:
>i use linux and windows nt. i've tried CMUCL, clisp and ACL5. i find
>that they are all awkward at producing a hello world application.
>sure i can open up a lisp and type (format t "hello world") or (load
>"hello-world") and then run something. sometimes, i can put
>#!/usr/bin/lisp at the top of a lisp script. some lisps get upset
>about lines beginning with #!. in any event, they (at least CMUCL,
>clisp and trial ACL5) don't produce a stand alone binary i can copy to
>someone. maybe i am doing something wrong.
>
>i am not trying to run anyone down. i just started using lisp about
>6-7 months ago and i really like it. it's just that unix and windows
>are set up to support C and C++. e.g., C has a largish libc these
>days. it's pretty much always in core and therefore no one pays any
>attention to it.
Using lisp for "Hello world" is a bit like:
- using Macsyma to balance your check book
- using Adobe Photoshop to view GIF files
- Using the Hoover dam to recharge your AA batteries
It's value is in its capacity to assist in solving big/complex problems.
Once viewed in that light, it's a question of "look at this solution to our hard
problem" and not "I can't run it from my .cshrc".
All a matter of perspective.
[...]
>
>i use lisp for lots of stuff. i just wish i had an operating system
>which offered better integration with lisp. perhaps i am missing some
>things i could do? is there a lisp-howto for linux out there? i mean
>paul graham's books, the hyperspec, steele's book, the cmucl user
>manual, acls docs are great. however i haven't found a good low level
>nitty gritty here's how you use emacs, here's how you get a bash shell
>in linux to launch a lisp program, when should you clobber and restart
>your lisp listener, how many lisps do you need going at once &c.
On that sentiment you'll find lots of agreement. Lots of people run scheme
derivatives as login shells, but I'm not the guy to tell you how.
D. Tenny
············@mediaone.net - no spam please
In article <··············@sophia.axel.nom>, Johan Kullstam <········@ne.mediaone.net> wrote:
> about lines beginning with #!. in any event, they (at least CMUCL,
> clisp and trial ACL5) don't produce a stand alone binary i can copy to
> someone. maybe i am doing something wrong.
I've been doing this for years with MCL and now also with LWW.
We do all our scripting and applications on Unix with CLisp (favorite),
GCL (historical), siod (CGIs) and scsh (shell scripting).
We don't do any PERL, Python, TCL or any other lesser language.
> > Have you ever tried? We are doing it all the time.
>
> i use lisp for lots of stuff. i just wish i had an operating system
> which offered better integration with lisp.
Unless you get a Lispm, Macintosh Common Lisp has (IMBO)
the best OS integration.
> perhaps i am missing some
> things i could do? is there a lisp-howto for linux out there?
http://www.telent.net/lisp/
http://www.telent.net/lisp/howto.html
http://clisp.cons.org/~haible/clisp.html
http://www.elwoodcorp.com/alu/table/contents.htm
...
> i mean
> paul graham's books, the hyperspec, steele's book, the cmucl user
> manual, acls docs are great. however i haven't found a good low level
> nitty gritty here's how you use emacs, here's how you get a bash shell
> in linux to launch a lisp program, when should you clobber and restart
> your lisp listener, how many lisps do you need going at once &c.
Such info is partly available. If you write something
or you find something on the web submit it to the
ALU pages:
http://www.elwoodcorp.com/alu/table/about.htm
Johan Kullstam (········@ne.mediaone.net) wrote:
: sometimes, i can put
: #!/usr/bin/lisp at the top of a lisp script. some lisps get upset
: about lines beginning with #!.
You may put an appropriate SET-DISPATCH-MACRO-CHARACTER in all the CLs
initialization files, like the following (not tested, as I don't have
a lisp here):
(set-dispatch-macro-character
#\# #\!
#'(lambda (stream char foo)
(declare (ignore char foo))
(loop for c = (read-char stream nil nil)
while c
while (char/= c #\Newline))
(values)))
P.
* Johan Kullstam <········@ne.mediaone.net>
| I've tried CMUCL, clisp and ACL5. I find that they are all awkward at
| producing a "hello world" application.
of course they are. however, have you ever seen how much work it takes
to boot a modern Unix machine and run a C program just to have it print
"hello world" in an xterm running under MOTIF? man, it sucks. and it's
even more work if it tries to run NT. the machine should be doing a very
limited amount of work for this very simple task, but instead it spends
minutes booting and preparing itself to be useful, not to mention all the
crap necessary to get a program in C able to produce that output. yea,
verily, it sucks.
unfair comparison? not at all. why do you think they chose that phrase?
because they were developing Unix and the C compiler. it's appropriate
to make a machine print "hello world" to verify that everything works
after all the mind-boggling nonsense has interfered with the real purpose
of a computer, and you never know which part of booting up will fail due
to a minor bug. the delight in a C programmer's eyes when his machine
thus booted typed "hello world" back at him would probably parallel that
of a Common Lisp programmer when the satellite communications subsystem
he designed beams back "hello world" after an almost-aborted launch, a
navigation jet which misfired, and the solar panels sustained some damage
by space debris. normally, it's unnecessary to have confirmations of
basic operations, but it makes perfect sense under C.
there are other simple tasks that require a tremendous infrastructure to
make a trivial task come back with a positive result. e.g., you need DNS
to be set up right, routers and firewalls must to do their job, the local
network and telecommunications links must let stuff through, etc, before
you can type "ping elvis" and have the system type "elvis is alive" back
at you. this is actually so delighting that there is a disproportionate
number of machines called "elvis" for this particular reason. (I think
it would be much more fun to have machines called "thelma" and "louise".)
who, these days, would pick up a telephone and consider "hello" to be a
landmark event in human history? while there's nothing wrong with a
strong sense of fascination with "all that which just _works_ around us",
getting excited about "hello world" programs appears to me to be a sure
sign of insanity, or at least a fairly constant case of missing the boat.
| it's just that unix and windows are set up to support C and C++. e.g., C
| has a largish libc these days.
these two statements are pretty much contradictory. the problem is that
neither Unix nor Windows _actually_ support either C or C++, but they
manage to make them work, with downright incredible effort. if you look
inside the libraries and see how a system call actually works and how
much it differs from the C calling convention and usage, you'd be a fool
not to revise your opinion. and _does_ an operating system that forces
the programmer to check to see whether the operating system did what it
was asked to do every damn time you ask it to do anything actually give
any relevant form of support to anyone?
in my view, Unix and Windows support Common Lisp better than they support
C because C is designed for a 70's style machine and operating system,
which modern machines and operating systems have to mimic with all their
flaws and misdesigns, while Common Lisp is a modern language that is well
suited to be hosted on modern systems, and it just happens to be, too.
the irony here is that Common Lisp has been what these machines and
operating systems have aspired to support for all these years and now
that they have finally grown to the task, people have so many problems
with the software written while they were growing up that day-to-day
survival has obscured everything to the point where people who are too
young to know that computers were designed to help people think better,
not just do the same old menial labor faster, believe there is nothing
more to it than luring lots and lots of people to perform menial tasks by
mouse instead of by lever.
anyone remember how the fear that machines would take over the world
quieted down as Bill Gates started to peddle his limpware? the computers
sure did take over the world, but whoever is afraid of toothless little
poodles who all wag their tails when they expected monsters? imagine a
little icon that said "My Scary Monster" or "My Scary Neighborhood" and
a browser that said "abandon all hope ye who click here". wouldn't sell
much, would it? and that's why they are called "confidence games".
I remember someone saying that if it hadn't been for automatic switches
in the telephone network, the entire population of planet earth would
have had to be telephone operators to handle the load of telephone usage
in 1993 or thereabout. I get the eerie feeling that because modern
computer systems are so incredibly braindamaged in their design and in
the tools used to program them, the entire population of planet earth
will be programming these idiotic boxes pretty soon if managers don't
wise up to the fact that the equivalent of automatic switches already
exist and have done so for at least 20 years. yet if Y2K doesn't light
up most manager's view of the world of programming, there isn't hope for
mankind at all.
so, yeah, Lisp is dying because we all have to program in C++ to Bill
Gates' tune, so we don't have time to think about making a better world
with better languages and less menial nonsense in programming computers.
the same thing happened in the last revolution, but fears in those times
caused labor unions and a strong sentiment against all business in some
quarters. user unions these days can't even stop the U.S. Congress from
enacting more laws to protect the software companies from Y2K lawsuits.
but of course, Lisp isn't dying -- it's just that if you think in terms
of the imminent end of the world, _everything_ is soon food for the great
garbage collector in the sky and whoever is not scrambling in panic looks
like they aren't moving and have been passed by or are dying.
the problem I see is not that Bill Gates has shaped the world of useless
trinkets in software, but has also managed to spread his competitiveness
and his personal fear of losing to imaginary competitors to businesses
and homes everywhere, so now everybody is _afraid_ of losing some battle
which isn't happening, instead of getting about their own lives. like,
if you aren't using today's fad language in the very latest version of
the IDE, you'll be left behind. aaaugh! but it's good that some people
run like they are scared out of their wits. if they suddenly disappear
over the edge of a cliff, a good number of people will notice in time and
_not_ follow them. those are the ones that matter.
you can scare most people most of the time, but you can't scare all of
the people all of the time -- some will always use Common Lisp.
#:Erik, who'll stop cross-posting to comp.lang.misc now
--
@1999-07-22T00:37:33Z -- pi billion seconds since the turn of the century
Erik Naggum <····@naggum.no> writes:
> [...] however, have you ever seen how much work it takes to boot a
> modern Unix machine and run a C program just to have it print "hello
> world" [...] C is designed for a 70's style machine and operating
> system [...]
I think this is an interesting point and the extent of its truth goes
a lot further than many realize. Unix and C were designed to program
and run on machines that had, as far as I know, 16-64k of core. All
configuration and state that you wished restored between boots or
crashes was stored textually on the filesystem, and your interface to
the system and the machines devices was pretty much through the
filesystem. Memory was really expensive at the time and machines had
very little so you wanted as much on the filesystem as you could get
so that you could spare every last byte to the current task.
Filesystems and the way they are used today are a relic of Unix and
the 70s when machines had very little RAM, even though nowadays your
basic Mac or Gateway/Dell comes with 128MB or so. Netscape takes about
7 seconds to start up on my P200 MMX if there has been a lot of memory
activity since its last use or after a fresh boot, or 4 seconds if it
just crashed or was shut down. It spends this time searching for and
loading shared libraries for image handling, searching for and loading
plugins, parsing the 794k /usr/lib/netscape/Netscape.ad configuration
file, and doing about 30 other distinct things. The resulting image in
memory is more less the same each time, but unless I have the sources
and compile the binary file just as I want it, I must tolerate things
as they are.
A feature of Lisp systems has always been that you can save images;
that you can dump and restore heap to and from core. I'm not sure what
the MIT CADR had in terms of RAM, but I think it was in the
whereabouts of 512 kilowords. As far as I know the Symbolics 3600
debuted with 2 megawords, 36 bits per word.
Many times, especially with something like a large database, you don't
want to parse some textual representation of configuration or state
off of a filesystem but instead you want heap. With a Lisp system you
can dump and restore your application's heap, and you can arrange an
interface to this ability for your users as well so that they don't
have to wait for their configuration data to be parsed and loaded on
each application boot. With a Lisp Machine you can dump and restore
your entire operating system's image so that you don't ever need to
start up an application if you always just want it there and ready to
go after boot.
My 20MHz Lisp Machine can go from shutdown to a Zmacs buffer in a
graphical GUI faster than my 200MHz Linux box can go from shutdown to
a mounted filesystem, loaded X windowing system, and loaded Emacs. (If
the Linux box weren't SCSI it would probably boot faster than the Lisp
Machine though; there are at least 2 five-second pauses during boot do
to SCSI: one during BIOS hardware probing and initialization and
another after Linux SCSI device detect when the bus is reset. This is
part of the hardware brain-damage aspect of modern PCs though which
are architecturally based on junk that was easy to mass-produce for
consumers in the early 80s and not designed to scale in any area at
all.)
Christopher
* Christopher R Barry wrote:
> Many times, especially with something like a large database, you don't
> want to parse some textual representation of configuration or state
> off of a filesystem but instead you want heap. With a Lisp system you
> can dump and restore your application's heap, and you can arrange an
> interface to this ability for your users as well so that they don't
> have to wait for their configuration data to be parsed and loaded on
> each application boot. With a Lisp Machine you can dump and restore
> your entire operating system's image so that you don't ever need to
> start up an application if you always just want it there and ready to
> go after boot.
But be aware how dangerous this is. `Resident' environments when
carried to extremes can result in a situation here you rely on an
image which you *can't* rebuild from its sources. You end up with
this sacred thing which you rely on but you can no longer reconstruct
from `textual' sources. So, although you might not want to do it too
often, it's actually really important that you regularly make sure
that you can cold boot your system from the source files.
I have been in exactly this situation on Xerox lisp machines. I
suspect in any case that the machines were a huge example of this
`sacred sysout' syndrome (Xerox called world loads or images
`sysouts'), but on top of this, we had a sysout which had various
stuff in it, some of which was now unwanted and we had to work to
turn off, which no one knew how to reconstruct any more. I was a lot
younger then so this didn't seem quite as frightening as it does now.
It's interesting that Windows machines seem to rather frequently get
into this state. Because there is (typically) rather poor control
over all the shared libraries & stuff they have, you end up with these
machines which will run stuff that you can no longer install on other
machines for reasons which are often totally opaque (to me, anyway,
the Windows people probably say the same stuff about Unix, and we both
say it about Macs). Worse still is when the machine that *would* run
stuff mysteriously stops doing so (usually because someone has
secretly installed doom or something & trashed some bit of state in
there).
I've never been in quite this state with a Symbolics, but they had a
lot more control over state than the Xerox machines did (though still
not enough in my opinion).
--tim
> My 20MHz Lisp Machine can go from shutdown to a Zmacs buffer in a
> graphical GUI faster than my 200MHz Linux box can go from shutdown to
> a mounted filesystem, loaded X windowing system, and loaded Emacs. (If
> the Linux box weren't SCSI it would probably boot faster than the Lisp
> Machine though; there are at least 2 five-second pauses during boot do
> to SCSI: one during BIOS hardware probing and initialization and
> another after Linux SCSI device detect when the bus is reset. This is
> part of the hardware brain-damage aspect of modern PCs though which
> are architecturally based on junk that was easy to mass-produce for
> consumers in the early 80s and not designed to scale in any area at
> all.)
> Christopher
In article <···············@lostwithiel.tfeb.org>, Tim Bradshaw <···@tfeb.org> wrote:
> It's interesting that Windows machines seem to rather frequently get
> into this state.
Windows NT is a nightmare in this respect.
> the Windows people probably say the same stuff about Unix, and we both
> say it about Macs).
Actually I can keep my Mac quite clean.
> > My 20MHz Lisp Machine can go from shutdown to a Zmacs buffer in a
> > graphical GUI faster than my 200MHz Linux box can go from shutdown to
> > a mounted filesystem, loaded X windowing system, and loaded Emacs.
Who cares? I tend to never reboot my personal Lisp machine.
It has a gig of VM and the GC runs smoothly.
My server Lispm runs for several months now. Unfortunately
I'm changing again office - this will mean another reboot, sigh.
>lisp suffers because it's hard to make hello world type starter
>programs that stand alone in a lisp hostile operating system, e.g.,
>unix, microsoft dos/windows[1].
I don't think this is true in the majority of (or, possibly, any) serious
lisps.
- n