Lisp as glue language?

147 views
Skip to first unread message

ade...@my-deja.com

unread,
Nov 20, 2000, 3:00:00 AM11/20/00
to
Like it or not, Perl's "Swiss Army Knife" approach has been very useful
to me because of the large number of packages available that
answer "real-life" problems (e.g., Win32 package for system and machine
administration; telnet, sockets and other networking packages; simple
interacting with operating system command line). I'm curious about
Lisp and could probably "gear up" to it while writing some useful
programs that help with these sorts of administrative tasks.

My question: does Lisp have the ability to do many/all of the tasks
that I currently use Perl for?

Thanks,
Alan Deger


Sent via Deja.com http://www.deja.com/
Before you buy.

glauber

unread,
Nov 21, 2000, 3:00:00 AM11/21/00
to
In article <8vc93v$5bn$1...@nnrp1.deja.com>,

ade...@my-deja.com wrote:
> Like it or not, Perl's "Swiss Army Knife" approach has been very useful
> to me because of the large number of packages available that
> answer "real-life" problems (e.g., Win32 package for system and machine
> administration; telnet, sockets and other networking packages; simple
> interacting with operating system command line). I'm curious about
> Lisp and could probably "gear up" to it while writing some useful
> programs that help with these sorts of administrative tasks.
>
> My question: does Lisp have the ability to do many/all of the tasks
> that I currently use Perl for?


Once you get past the ()s, Common Lisp is surprisingly Perl-like. It supports
the same 3 qualities of a Perl programmer (lazyness, impatience and hubris).
:-) They're both languages that evolved with use to support real life tasks.
Unfortunately, there seem to be a lot more Perl programmers than Lisp
programmers out there, and Perl has better support for more systems than Lisp
does. Partly in consequence, Perl has a lot more pre-written code that you
can download and use. But there's some for Lisp too, and people in this
newsgroup are helpful.

If for nothing else, taking a good look at Lisp will probably improve your
programming.

As for using Lisp as a glue, check out Richard Stallman and the Guile project
at www.gnu.org. They have pretty strong opinions in favor of it. :-)

glauber


--
Glauber Ribeiro
thegl...@my-deja.com http://www.myvehiclehistoryreport.com
"Opinions stated are my own and not representative of Experian"

Paolo Amoroso

unread,
Nov 21, 2000, 3:00:00 AM11/21/00
to
On Mon, 20 Nov 2000 22:37:52 GMT, ade...@my-deja.com wrote:

> My question: does Lisp have the ability to do many/all of the tasks
> that I currently use Perl for?

If you don't mind Scheme, you may check scsh by Olin Shivers:

http://www-swiss.ai.mit.edu/ftpdir/scsh/


Paolo
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/

Erik Naggum

unread,
Nov 21, 2000, 3:00:00 AM11/21/00
to
* glauber <thegl...@my-deja.com>

| It supports the same 3 qualities of a Perl programmer (lazyness,
| impatience and hubris). :-)

I guess this depends on whether you come to Common Lisp from Perl and
write Perl in Common Lisp or come to Perl from Common Lisp and don't
write any Perl. The ultimate laziness is not using Perl. That saves
you so much work you wouldn't believe it if you had never tried it.

| Unfortunately, there seem to be a lot more Perl programmers than Lisp
| programmers out there, and Perl has better support for more systems
| than Lisp does.

This is not unfortunate. There are more insects than mammals, too.
You don't want an insect to grow as big as mammals do. It simply
cannot support itself once it violates its original specifications.

| As for using Lisp as a glue, check out Richard Stallman and the Guile
| project at www.gnu.org. They have pretty strong opinions in favor of
| it. :-)

Guile is hardly a Lisp. It's a Scheme with an attitude.

#:Erik
--
ALGORITHM: a procedure for solving a mathematical problem in a finite
number of steps that frequently involves repetition of an operation.
ALGOREISM: a procedure for solving an electoral problem in a finite
number of steps that frequently involves repetition of an operation.

glauber

unread,
Nov 21, 2000, 3:00:00 AM11/21/00
to
In article <31838154...@naggum.net>,
Erik Naggum <er...@naggum.net> wrote:
[...]

> | As for using Lisp as a glue, check out Richard Stallman and the Guile
> | project at www.gnu.org. They have pretty strong opinions in favor of
> | it. :-)
>
> Guile is hardly a Lisp. It's a Scheme with an attitude.

But they do have strong opinions about it! The discussions between RMS and
the TCL people gave so many of us so many hours of fun!

To be semi-serious again, you probably don't want Common Lisp or Perl as a
glue language. You want something small(er) and simple(r) like TCL or Scheme
(depending on whether you like ()s or not). Embedding a TCL interpreter in a
C application is one of the easiest things to do, since that's what TCL was
well designed for. I did my first one in less than 30 minutes, and it saved
me so many hours of work. I don't have any experience embedding Guile, so i
can't tell for sure, but it seems to be designed for the same thing (i.e., to
be the embedded interpreter when they "do Emacs right").

Of course one can always say that if you were programming in Lisp to start
with, you woudn't need to use an additional scripting language.

Christophe Rhodes

unread,
Nov 21, 2000, 3:00:00 AM11/21/00
to
glauber <thegl...@my-deja.com> writes:

> Of course one can always say that if you were programming in Lisp to start
> with, you woudn't need to use an additional scripting language.

Well, yes and no.

There was once in college a little programme (script, if you will)
written in Perl, used to monitor the users of the computers in the
computer centre[1]. It worked relatively happily, dealing with Windows
and Solaris machines, and gave the right kind of answers.

Then some of the assumptions behind the script were changed (machines
were allowed to dual boot, some fingerds changed, and so on) and so
the script broke. At this point, I came onto the scene and rewrote it
in Lisp, while still using some of the Perl `helper
scripts'. Basically, the ease of writing the _logic_ in Lisp far
outweighed the pain of having to use (unix:run-program "foo") for some
of the external bits; further, it has since been extended to be able
to deal with snmp, arbitrary locations of machines, etc, etc.

What I'm trying to say, I suppose, is that Lisp is a fine language to
write programme logic in, and it's not too difficult to write
something that interfaces to the OS/other languages -- for "scripts",
standard output is a fine method of communication with other
processes.

Christophe

[1] Not for any nefarious purpose, I hasten to add; basically, to
answer the question "is foo in there so that I can grab him and ask
this important question".
--
Jesus College, Cambridge, CB5 8BL +44 1223 524 842
(FORMAT T "(~@{~w ~}~3:*'~@{~w~^ ~})" 'FORMAT T "(~@{~w ~}~3:*'~@{~w~^ ~})")

Georges KO

unread,
Nov 21, 2000, 5:20:37 PM11/21/00
to
Christophe Rhodes <cs...@cam.ac.uk> writes:

> What I'm trying to say, I suppose, is that Lisp is a fine language to
> write programme logic in, and it's not too difficult to write
> something that interfaces to the OS/other languages -- for "scripts",
> standard output is a fine method of communication with other
> processes.

There is a Java interpreter called BeanShell (www.beanshell.org) :
has someone tried to use it from Lisp ?
--
Georges KO (Taipei, Taiwan) g...@gko.net
Mercredi 22 novembre 2000

David Bakhash

unread,
Nov 21, 2000, 7:16:11 PM11/21/00
to
glauber <thegl...@my-deja.com> writes:

> To be semi-serious again, you probably don't want Common Lisp or
> Perl as a glue language.

Define glue language. I must be missing your definition. I think
we're being too general here.

If what you're gluing together are a bunch of sed/awk/exec/grep/find
commands, then Perl is your glue language. If what you're gluing
together are a bunch of Corba-based backend servers, then Common Lisp
might be your preferred glue language. "Glue" is becomming a
hyper-overloaded word these days, and people are gluing together a lot
of different things, each of which is becoming more and more complex,
and the glue itself is getting more complex as well.

I think that both Lisp and Perl are excellent languages for general
gluing, and that's because they have good object systems, and can
interface with a variety of other systems very well (Perl a bit more
obviously and a lot more cost-effectively).

Rob Warnock

unread,
Nov 22, 2000, 12:10:48 AM11/22/00
to
<ade...@my-deja.com> wrote:
+---------------

| My question: does Lisp have the ability to do many/all of the tasks
| that I currently use Perl for?
+---------------

Well, what *do* you use Perl for? No, that's not a facetious question.
The answer really does depend on what you expect from a "glue language",
or as someone else said [paraphrased], "gluing what to what?"

If you're comfortable with Perl already, and use it frequently enough
that you don't forget all the myriads of magic characters [that's *my*
main problem with Perl, b.t.w.], and only use it in "write-only" mode
so that you don't ever, *ever* have to go back and figure out what
you wrote a year or a month or a week later [that's my #2 problem
with Perl], then Perl is just fine for certain tasks. It certainly
minimizes keystrokes, *that's* for sure!

If the answer to any of those "if"s is negative, then you may find
Common Lisp (or a robust Scheme, of which there are a few) to be
more to your taste... once you get used to it.

Myself, I've written a goodly number of tiny scripts in Scheme
(Rice PLT's "MzScheme", usually), since I came to Scheme and got
used to doing that sort of stuff in it before I got exposed to CL.
Most of them are the sorts of text-bashing thingies that others
around here tend to use Perl for. Here are a few examples:

plite Infix dialect of Scheme, used for Tcl-like scripting.
[*Why*? A very long story for another time...]

= A shell alias for "plite", mainly for quick&dirty
command-line arithmetic (including bignums), e.g.:
% = '41.3*(20.7+34.2)'
2267.37
% = expt 2 100
1267650600228229401496703205376
% = map iota "'(5 2 3)"
((0 1 2 3 4) (0 1) (0 1 2))
%

chklog Rummage through /usr/adm/SYSLOG & /usr/adm/oSYSLOG
looking for unexpected or "strange" events.

http-get Dirt-simple command-line web tool:
% http-get -head http://reality.sgi.com
HTTP/1.1 200 OK
Server: Zeus/3.3
Date: Wed, 22 Nov 2000 04:35:27 GMT
Connection: close
Content-type: text/html
%

keto Help with low-carb diet, e.g., what about almonds?
[Low-carb diets suggest ketogenic ratios >1.0]
% keto 6 4 16
grams: protein 6 carb 4 fat 16
calories: protein 24 carb 16 fat 144 total 184
%calories: protein 13.0 carb 8.7 fat 78.3
ketogenic ratio: 1.89
%

scan Rummage through heaps of saved email looking for matches
more complex than "grep" can handle. [Work in progress...]

sgi-opt What are my SGI options worth today? ;-} ;-}

stockquote Fetch quotes from a web page, trim all the HTML and
just show numbers (converted to decimals):
% stockquote SGI IBM
SGI = 4.0
IBM = 98.5
%
[This one keeps breaking as sites increasingly tart up
their pages with more & more eye candy... (*sigh*) ]

vq SGI provides a GUI calendar/reminder tool called
"vcal". The "vq" script dumps out plaintext from
vcal's database. E.g., to see what's on for tomorrow:
% vq -d 22
One-time events:
(none)
Repeating events:
2000 Nov 22 13:30 (60): staff meeting
2000 Nov 22 15:00 (60): gmh/rpw3 1-on-1
2000 Nov 22 20:00 (120): ex-SGI/friends dinner
%

Please note that any of those could just as easily have been written
in Common Lisp, had I started with it first instead of Scheme.


-Rob

-----
Rob Warnock, 31-2-510 rp...@sgi.com
Network Engineering http://reality.sgi.com/rpw3/
Silicon Graphics, Inc. Phone: 650-933-1673
1600 Amphitheatre Pkwy. PP-ASEL-IA
Mountain View, CA 94043

Erik Naggum

unread,
Nov 22, 2000, 3:00:00 AM11/22/00
to
* glauber <thegl...@my-deja.com>

| To be semi-serious again, you probably don't want Common Lisp or Perl as a
| glue language.

I actually want Common Lisp as the glue language, too.

| You want something small(er) and simple(r) like TCL or Scheme
| (depending on whether you like ()s or not).

No, I really want a real programming language as my glue language, but
I also want to compile the glue into something that has very, very
little overhead. Today's glue languages are _extremely_ wasteful and
betray an arrogance towards hardware that I find staggeringly stupid.
Just because we have had 1000 times more computing power in recent
years is not good reason to _spend_ 1000 times the computer resources
on our tasks, too. That's just telling the hardware people that the
harder they work, the softer the software people get.

| Of course one can always say that if you were programming in Lisp to
| start with, you woudn't need to use an additional scripting language.

That, too, but the whole idea of "scripting" is just plain wrong to
begin with.

To zoom out a bit, I want intralanguage glue, not interlanguage glue.
I want a "glue language" that produces source code in other languages
that interfaces between a pair of languages. With all the dumb-ass
languages out there, the work required to make things interoperate is
just too high, leading to an explosion in the need for glue, which it
is the wrong solution to provide. The right solution is to write
tools that produce source code. This is completely foreign to people
who manually write all their code in dumb-ass languages, but those who
have ever seen a real, code-generating Lisp macro should know better.

When I was only an egg, building language tools that read more complex
_languages_ than today's crop of silliness (like XML) were the order
of the day. YACC is not called Yet Another Compiler Compiler for no
reason. Such tools were manifold, but now there is no development of
new tools, except for stuff that generates HTML, of course, most of
which is _amazingly_ unintelligent and nearly completely ignorant of
past wisdom and knowledge.

vsync

unread,
Nov 22, 2000, 3:00:00 AM11/22/00
to
Erik Naggum <er...@naggum.net> writes:

> This is not unfortunate. There are more insects than mammals, too.
> You don't want an insect to grow as big as mammals do. It simply
> cannot support itself once it violates its original specifications.

This is one of the best analogies I've seen yet. Thank you. I've
saved it.

--
vsync
http://quadium.net/ - last updated Thu Nov 16 13:33:53 PST 2000
(cons (cons (car (cons 'c 'r)) (cdr (cons 'a 'o))) ; Orjner
(cons (cons (car (cons 'n 'c)) (cdr (cons nil 's))) nil))

vsync

unread,
Nov 22, 2000, 3:00:00 AM11/22/00
to
David Bakhash <ca...@alum.mit.edu> writes:

> If what you're gluing together are a bunch of sed/awk/exec/grep/find
> commands, then Perl is your glue language. If what you're gluing

Yes, but once you switch to an actual programming environment from
simple scripting, you don't need to use those commands, really. Even
in Perl, most of those would be replaced with the appropriate Perl
functions, and so you can switch from the question of "how well does
this tie together shell commands?" to "how good of a language is this,
and how well does it suit the task I'm doing?"

That said, I've found Common Lisp to be an incredible tool for
interfacing with shell commands. WITH-OPEN-FILE is very nice, and if
you stick with a functional approach, you'll be able to keep track of
what's going on much easier than in even object-oriented Perl.

When I was at Sun, I needed to write some wrappers for a package to be
distributed worldwide throughout the intranet. As part of this task,
I wrote SPLASH (http://quadium.net/code/splash/), and then I needed to
check that certain patches were installed before attempting to run the
program. Initially, I intended to modify an existing Perl script for
my needs, but when I took a good look at the script, I nearly died.

This was a bad Perl script.

First, it wasn't laid out well at all. Things that should have been
broken into procedures weren't, it mixed programming approaches, and
I'm pretty sure it called "eval" in several places for no good
reason. The kicker was the part where it actually checked for
patches. In Funky Pseudocode(TM), it looked like this:

foreach i in list_of_patches_we_need {
if ( not ( member ( i, `showrev -p` ) ) )
blow_up_and_die;
}

See, the command "showrev -p" does an inventory of all patches
installed on the system. It's quite expensive. And this joker was
running it inside the innermost loop.

Anyway, the splash screen package was already in Lisp, so I decided to
just make another function to check for patches. I spent some time on
it, but this was mainly due to wanting to Do It Right(TM). I ended up
with a nice functional approach that loaded the list of installed
patches once, went through the list, and returned all kinds of nifty
information. It's infinitely more readable than the Perl version (of
course, that may just be because I'm a better programmer than the
other guy...) and quite efficient. What I liked was the ease of
string and stream manipulation under Lisp.

The plan was to distribute these packages along with CLISP and provide
an easy and consistent way for product managers to have splash screens
and patch checks. However, managers got petty and killed the project
(_after_ I had finished, including documenting, testing, and packaging
everything) and as far as I know, they're still trying to hack
someone's pitiful dtksh script to act as a splash screen for various
stuff. Anyway, I have "patches.lisp" laying around, if anyone would
like to see how I interfaced with UNIX commands, or comment on my
approach.

Paolo Amoroso

unread,
Nov 22, 2000, 3:00:00 AM11/22/00
to
On 22 Nov 2000 07:32:44 +0000, Erik Naggum <er...@naggum.net> wrote:

> To zoom out a bit, I want intralanguage glue, not interlanguage glue.
> I want a "glue language" that produces source code in other languages
> that interfaces between a pair of languages. With all the dumb-ass

Do you mean something like SWIG (http://www.swig.org/)?

Lieven Marchand

unread,
Nov 22, 2000, 3:00:00 AM11/22/00
to
Christophe Rhodes <cs...@cam.ac.uk> writes:

> There was once in college a little programme (script, if you will)
> written in Perl, used to monitor the users of the computers in the
> computer centre[1]. It worked relatively happily, dealing with Windows
> and Solaris machines, and gave the right kind of answers.
>
> Then some of the assumptions behind the script were changed (machines
> were allowed to dual boot, some fingerds changed, and so on) and so
> the script broke. At this point, I came onto the scene and rewrote it
> in Lisp, while still using some of the Perl `helper
> scripts'. Basically, the ease of writing the _logic_ in Lisp far
> outweighed the pain of having to use (unix:run-program "foo") for some
> of the external bits; further, it has since been extended to be able
> to deal with snmp, arbitrary locations of machines, etc, etc.
>

> What I'm trying to say, I suppose, is that Lisp is a fine language to
> write programme logic in, and it's not too difficult to write
> something that interfaces to the OS/other languages -- for "scripts",
> standard output is a fine method of communication with other
> processes.

That's how I do a lot of sysadmin stuff too. If I occasionally need to
interact with some weird protocol, chances are there is a perl module
for it. I write the minimal amount of perl to dump the needed info in
a lisp friendly format (typically SEXPRs) and then do a READ and write
the rest of the program in CL.

If after a while I need it, I still have the option to implement weird
protocol in CL.

--
Lieven Marchand <m...@bewoner.dma.be>
Lambda calculus - Call us a mad club

john...@my-deja.com

unread,
Nov 24, 2000, 3:00:00 AM11/24/00
to
In article <8vfkgo$irir$1...@fido.engr.sgi.com>,

Are the sources to some of these scripts available? I'm very interested
in seeing it, and I'm sure at a few others would find it educational as
well.

Thanks,
-- John

Xah Lee

unread,
Dec 7, 2000, 3:00:00 AM12/7/00
to
Hi Adeger,

i came here late, and i see a lot people have already gave you baggy
opinions and factoids. Still, blind and deaf can't tell you all about Perl.

Perl's gluing ability goes beyond computation, to people. To the poor and
have-nots. It unites people in the computing field who are not endowed with
fancy engaging brains. It is the sanctuary of dunces. The expressions of
those thoughtless. The godsend for brainless coders. The means and banner of
sys admins. The lingua franca of trial-and-error hackers. The song and dance
of stultified engineers.

I'm also a Perler. Share a secret with me: When you are cornered by
mathematicians or the like, who are about to speak lamba or something we
don't understand, what do you do? Of course, flip out the little Swiss Army
Knives in our pockets, and splutter #%$@ syntaxes that is equally abstruse,
and we feel safe and secure. Fuck geniuses in this world. Leave Perlers
along. Larry Wall for President. The three principal virtues of ...

You mentioned the surplus of Perl libraries? Say, CGI, LWP, WWW, HTML, DBI,
File::,...etc and etc and etc? Yes I _know_. I have serious experience
wallowing in this giant dung pile. Yes I KNOW! If you are in a cesspool for
long, you will forget about shit but start to enjoy swimming. It is
intriguing to say the least. You discover backstroke, develop efficiency in
freestyle, enjoys relaxed breast stroke, and even dabble and splash in
butterfly to impress your friends. You begin to be amazed by the wonders and
size of the pool, don't you? Me too, pal. Me tooo.

Our crony glauber <thegl...@my-deja.com> sayz:
> Once you get past the ()s, Common Lisp is surprisingly Perl-like. It supports


> the same 3 qualities of a Perl programmer (lazyness, impatience and hubris).

> :-) They're both languages that evolved with use to support real life tasks.

I think comrade glauber is incorrect. First of all, he got our mantra wrong.
It is: The three characteristics of Perl programers: mundaneness,
sloppiness, and fatuousness. Secondly, our language is not evolved to
support no fucking real life no shit. Our language, is designed to be a
fuckup from the very beginning. Designed, to fuck up those computer
scientists. Fuck up their teachings. Fuck up their students. Fuck up their
language. Fuck up their correctness. Fuck up their fucking theoretical
theories. Remmeber, P is for Practical.

Xah
x...@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
perl5 -e'print "just another f@%#!^& perl moron.\n"'

> From: ade...@my-deja.com
> Organization: Deja.com - Before you buy.
> Newsgroups: comp.lang.lisp
> Date: Mon, 20 Nov 2000 22:37:52 GMT
> Subject: Lisp as glue language?
>
> Like it or not, Perl's "Swiss Army Knife" approach has been very useful
> to me because of the large number of packages available that
> answer "real-life" problems (e.g., Win32 package for system and machine
> administration; telnet, sockets and other networking packages; simple
> interacting with operating system command line). I'm curious about
> Lisp and could probably "gear up" to it while writing some useful
> programs that help with these sorts of administrative tasks.
>

> My question: does Lisp have the ability to do many/all of the tasks
> that I currently use Perl for?
>

> Thanks,
> Alan Deger

glauber

unread,
Dec 7, 2000, 3:00:00 AM12/7/00
to
In article <sfwk89c...@world.std.com>,
Kent M Pitman <pit...@world.std.com> wrote:
> glauber <thegl...@my-deja.com> writes:
>
> > ... The 3 characteristics of Perl programmers are definitely
> > lazyness, impatience and hubris. I read it in a book somewhere.
>
> Well, 2 out of 3 isn't bad. That is, laziness and impatience seem like
> virtues to me. I used to have a Garfield comic pasted to my door at
> Symbolics where he was remarking that laziness wasn't as bad as it
> was made out to be--if I recall the tag line on the comic, it was
> "You can bet power steering wasn't invented by an exercise freak."
>
> Impatience could be argued similarly to be just an acute understanding
> of the value of time.
>
> Hubris I can't think of any good reason for, though.


I always thought this was cute, and it does have a grain of truth. It's been
in Perl documentation for as long as i've known it. Here's how they're
defined in the "Camel" book ("Programming Perl", Wall, Christiansen &
Schwarz):

Laziness

The quality that makes you go to great effort to reduce overall energy
expenditure. It makes you write labor-saving programs that other people will
find useful, and document what you wrote so you don't have to answer so many
questions about it. Hence, the first great virtue of a programmer.

Impatience

The anger you feel when the computer is being lazy. This makes you write
programs that don't just react to your needs, but actually antecipate them.
Or at least that pretend to. Hence, the second great virtue of a programmer.

Hubris

Excessive pride, the sort of thing Zeus zaps you for. Also the quality that
makes you write (and maintain) programs that other people won't want to say
bad things about. Hence, the third great virtue of a programmer.

(end of quote)


So, laziness is working hard so you don't have to work harder; impatience is
using higher-level language functions; hubris is feeling strongly enough
about your programs to want to do them well.

--
Glauber Ribeiro
thegl...@my-deja.com http://www.myvehiclehistoryreport.com
"Opinions stated are my own and not representative of Experian"

Xah Lee

unread,
Dec 7, 2000, 3:00:00 AM12/7/00
to
Dear Kent,

Kent M Pitman <pit...@world.std.com> wrote:
> glauber <thegl...@my-deja.com> writes:
>
>> ... The 3 characteristics of Perl programmers are definitely
>> lazyness, impatience and hubris. I read it in a book somewhere.
>
> Well, 2 out of 3 isn't bad. That is, laziness and impatience seem like
> virtues to me. I used to have a Garfield comic pasted to my door at
> Symbolics where he was remarking that laziness wasn't as bad as it
> was made out to be--if I recall the tag line on the comic, it was
> "You can bet power steering wasn't invented by an exercise freak."

Here we go again. Kent Pitman, exhibiting his humanism, naturalism,
relativism, fuzzism, taking muddism to the next state of the art.

Laziness, by definition, means:
"Resistant to work or exertion; disposed to idleness"
(American Heritage Dictionary 1995)

Laziness does not mean:
"A preference for ease of operation and convenience"

Why do you are so often so fucked up in thinking? Larry Wall is by
intention. A brainless nevertheless artistic joker of sorts. Were you by
intention too? Have you studied logic and linguistics significantly? You
surely exhibit the manipulation of English.

> Impatience could be argued similarly to be just an acute understanding
> of the value of time.

Get a life.

> Hubris I can't think of any good reason for, though.

Let me help you. Hubris is good, because it shows that the person is alive
and actively participates in things he concerns. It is a fundamental human
nature. No hubris means not human. See my giant hubris? That is because i'm
concerned about this issue, and i care about you, very much. That is why, i
spent so much of my time helping you in things you got wrong or can't
decide. You know how ivy tower languages can't decide? Resulting stagnation
and death? This is where Perl contrasts, with Hubris, moves and shakes the
computing world. This is why, doesn't matter how Common of Lisp, it still
lacks this and that libraries. Hubris now!

Xah
x...@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
"Perl my ass" (there are more than one way to express love, too!)

> From: Kent M Pitman <pit...@world.std.com>
> Organization: The World Public Access UNIX, Brookline, MA
> Newsgroups: comp.lang.lisp
> Date: Thu, 7 Dec 2000 17:19:37 GMT
> Subject: Re: Lisp as glue language?


Xah Lee

unread,
Dec 7, 2000, 3:00:00 AM12/7/00
to
Dear glauber,

Did you know that throughout history there's this things called cult? It is
a very interesting phenomenon. I don't have time to expound and teach, but
will try to brief you.

These cults, are often lead my a single person. They form a group as small
as a dozen to multinational octopuses (such as Scientology). Their creed
varies from the mild in appearance (Dianetics) to appalling (flat earth,
extraordinary life-after-death, impinging apocalypse scenarios, militant
anti-government conspiracy, diabolism with human sacrifices ...). Don't
think that i'm citing from some arcane books buried in libraries. These are
real, and not difficult to find in real life. Some of these cult leaders,
are so able to totally wash their member's brain, as to have them
autonomously swear and volunteer to die for the cause of the cult.
Occasionally, you'll even see mass suicide.

You know, the world are not made completely of rubes. Somebody somewhere,
will observe this phenomenon and study or report it as is. Big brother
organizations, such as the FBI, is keen on these and very interested in
benefiting from social psychology themselves. They are recorded in books
too. Ever wonder why the library houses so many cold volumes of paper? This
is one contributing reason. You might be interested to verify that
sometimes.

These brain-washing phenomenon, is not limited to fanatical life-and-death
or otherwise dire beliefs. You see it work in all manners of human thought
in the general sense. From culture formation to fashion to commercialism.
Surely you have heard of Adolf Hitler and his atrocities of genocide? I must
alert you, that a single person couldn't commit such a crime. You see, even
if you are superman, you can only kill few at a time. You see, it is the
people, people like you and me, who commit the killings willingly, by
Hitler's teaching. You may say: "no, i won't ever do such stupid thing",
well because you are very ignorant about social psychology. It is precisely
innocent people like you and (not) me, who were lead by the radical leaders
of supreme brain-washing abilities. The innocent mob were fervent in their
leader's vision and beliefs to commit anything. You know the concept of war,
right? We have two massive body of people committed to cut off other
people's head or otherwise stick a knife in their bodies or bomb off an arm
or leg. How did that happen? Well, it starts with patriotism for people like
you and (not) me.

Now, back to topic. In the computing world, there're also bad seed with
colorful creed taking innocent mobs forming cults. The three principal
virtues of a programmer are Laziness, Impatience, and Hubris. Yes? Mr Kent
Pitman, Yes?

How can we prevent heinous cults then? Stop bending truths. Education and
rationalism. I'm starting my own cult to exterminate morons on this earth.
Two things are on the top of my agenda: Unixism and Perl.

Xah
x...@xahlee.org
http://xahlee.org/PageTwo_dir/more.html


> From: glauber <thegl...@my-deja.com>
> Organization: Experian: http://www.myvehiclehistoryreport.com
> Newsgroups: comp.lang.lisp
> Date: Thu, 07 Dec 2000 20:06:36 GMT
> Subject: Lazyness, Impatience and Hubris
>
> In article <sfwk89c...@world.std.com>,


> Kent M Pitman <pit...@world.std.com> wrote:
>> glauber <thegl...@my-deja.com> writes:
>>
>>> ... The 3 characteristics of Perl programmers are definitely
>>> lazyness, impatience and hubris. I read it in a book somewhere.
>>
>> Well, 2 out of 3 isn't bad. That is, laziness and impatience seem like
>> virtues to me. I used to have a Garfield comic pasted to my door at
>> Symbolics where he was remarking that laziness wasn't as bad as it
>> was made out to be--if I recall the tag line on the comic, it was
>> "You can bet power steering wasn't invented by an exercise freak."
>>

>> Impatience could be argued similarly to be just an acute understanding
>> of the value of time.
>>

>> Hubris I can't think of any good reason for, though.
>
>

glauber

unread,
Dec 7, 2000, 11:13:57 AM12/7/00
to
In article <B654B8EC.4767%x...@xahlee.org>,
Xah Lee <x...@xahlee.org> wrote:
[...]

> Our crony glauber <thegl...@my-deja.com> sayz:
> > Once you get past the ()s, Common Lisp is surprisingly Perl-like. It supports
> > the same 3 qualities of a Perl programmer (lazyness, impatience and hubris).
> > :-) They're both languages that evolved with use to support real life tasks.
>
> I think comrade glauber is incorrect. First of all, he got our mantra wrong.
> It is: The three characteristics of Perl programers: mundaneness,
> sloppiness, and fatuousness. Secondly, our language is not evolved to
> support no fucking real life no shit. Our language, is designed to be a
> fuckup from the very beginning. Designed, to fuck up those computer
> scientists. Fuck up their teachings. Fuck up their students. Fuck up their
> language. Fuck up their correctness. Fuck up their fucking theoretical
> theories. Remmeber, P is for Practical.
[...]


I don't agree. The 3 characteristics of Perl programmers are definitely


lazyness, impatience and hubris. I read it in a book somewhere.

glauber


P.S.: my apologies to Larry Wall.

Kent M Pitman

unread,
Dec 7, 2000, 12:19:37 PM12/7/00
to
glauber <thegl...@my-deja.com> writes:

> ... The 3 characteristics of Perl programmers are definitely


> lazyness, impatience and hubris. I read it in a book somewhere.

Well, 2 out of 3 isn't bad. That is, laziness and impatience seem like

glauber

unread,
Dec 7, 2000, 7:11:23 PM12/7/00
to
In article <B655552E.4805%x...@xahlee.org>, Xah Lee <x...@xahlee.org> wrote a
lot of stuff about the cult he wants to start...

Dear Xah,

it's nice to see you use a more friendly tone. I wish i could comment on your
message, but as you know, "they"'re watching...

David Bakhash

unread,
Dec 9, 2000, 8:26:21 PM12/9/00
to
Xah Lee <x...@xahlee.org> writes:

> Let me help you. Hubris is good, because it shows that the person is
> alive and actively participates in things he concerns. It is a
> fundamental human nature. No hubris means not human. See my giant
> hubris? That is because i'm concerned about this issue, and i care
> about you, very much. That is why, i spent so much of my time
> helping you in things you got wrong or can't decide. You know how
> ivy tower languages can't decide? Resulting stagnation and death?
> This is where Perl contrasts, with Hubris, moves and shakes the
> computing world. This is why, doesn't matter how Common of Lisp, it
> still lacks this and that libraries. Hubris now!

After reading Xah's posts over time, I can't really be sure what he
likes or dislikes, or even which he prefers, Perl or Common Lisp. But
that's neither here nor there.

I don't care about the "semantics of hubris", but I will strongly
agree with this last bit up here about how the Perl community, along
with it's "hubris", or more precisely, it's dedication to providing
immediate, efficient, and even elegant remedy to hard problems,
interfaces to new software, technologies, and excellent support.

It's okay to me that Common Lisp has not tackled some of the cruel
real-world nastiness in the Standard; it's good enough that there are
vendors out there which provide solutions, and more and more free
CL software is coming out all the time. I appreciate that CL is pure,
is powerful to solve the hardest part of any *real* software problem
(though only with multiprocessing; without this I would find CL much
less useful).

Hubris *is* human. I think that KMP knows this deep down as well, and
he exhibits it strongly for Common Lisp, hence his dedication to this
newsgroup, his continuous support, and the massive effort that he's
contributed, at least since I've been part of this community, which
has been a few years now. Of course, there's the CLHS, ... the list
goes on and on. The difference is not the hubris; it's the focus on
what's important.

What KMP was probably saying, if I may interpret his post, was that
excessive hubris is not always a good thing. But I'll be the first to
admit that I'm a religious zealot when it comes to CL, have a fine
appreciation for Perl, its originator, its history, its usefulness in
the messy real world, and its pricetag.

Let's put it this way. The last several years of computing have seen
tons of stupidity in new technolgies and languages. Some of us have
had little choice but to get involved with the mess, and CL didn't
dive into it very hard. So that's good for CL, but it also means that
in certain situations application programmers will look for other
solutions. Perl has been mine, and I simply recognize that there is
certainly an element of pride the that Perl gurus have in making sure
they pretty much cover everything (important). Given that, I will
agree that this `hubris' has a bit to do with both CL and Perl.

dave

Reply all
Reply to author
Forward
0 new messages