Subject: Re: [executables] was: why Haskell hasn't replaced CL yet?
From: Erik Naggum <>
Date: 2000/03/04
Newsgroups: comp.lang.lisp
Message-ID: <>

| On 03 Mar 2000 22:58:49 +0000, Erik Naggum <> wrote:
| >  extremely little business value in catering to people who mainly execute
| >  really tiny programs like the null program or "hello, world" programs.
| That's silly.

  then why do you argue that people spend time publishing results in that
  area?  clearly, your argument is that these things matter a great deal.
  but I quite agree that it's silly to be concerned about such things, and
  I'm delighted that you recognize silliness when properly framed -- you
  might actually recognize that your core argument is indeed very silly.

| It should be obvious to you that people who want to test "hello world"
| programs do not have such programs as their main goal.  The main purpose
| of such a program is to minimize the complexity of a program to explore
| the issues of compiling, installing, etc., independently of issues of
| program complexity.

  if that _were_ the goal, I'd agree that it would be useful to help people
  with such programs.  however, it isn't, and you know it isn't.  those who
  argue for small executables do so on the basis of "overhead", which is
  not a question of how much the language needs, but how well the operating
  system is able to accomodate its needs.  so small executable size is a
  tribute to the operating system and the language, while large executable
  overhead is a blemish on the operating system.  oddly enough, people take
  it out on the language.  this is not just silly, it's idiotic.

| My interest in null programs is because I happen to presently use a lot
| of software in the "pipes and filters" paradigm, and I would like to
| replace some of that software with my own versions, which I might like to
| write in Lisp.

  if you were truly interested, you would be willing to consider many ways
  to accomplish your needs.  "pipes and filters" does _not_ translate into
  "small executable with short startup-up time" except to the permanently
  braindamaged C victims.  in particular, a good way to make use of Lisp is
  to have a very heavy process that maintains a lot of state, but which
  tiny C programs talk to via sockets, if this is hard to do directly from
  whatever "scripts" are otherwise engaged in the "pipes and filters"
  thing.  (IMNSHO, the sorry fact that shells have not grown to be able to
  make network connections instead of just pipes is _really_ pathetic.)

| Note that I am not advocating using "pipes and filters" as a good
| paradigm for any particular project.  The reason I want to use it is to
| be compatible with software I already have.  I also want to use Lisp or
| some such language for bigger projects, but would rather use the same
| language and programming environment for both types of projects.

  you can, but you have to zoom out and _think_ about your problem.  you
  can't expect everything new to fit the same old mold.  in this case, the
  friggin obvious solution is to write a pipe-and-filter thingy in C that
  talks to the Lisp process.  that way, you reduce the start-up time to
  that of C (which you seem to believe is short) plus the overhead of
  connecting to the already running Lisp process, which is, like, _really_
  short.  if you have problems with this extra "layer" of code, yet observe
  that you get dramatically improved performance, which you would if you
  tried it instead of just rejecting any other solutions than "run the
  program", I'd say you have a political agenda and not an engineering
  problem, anymore.

  it so happens that _every_ other person who has posted to this newsgroup
  about his misgivings about startup times has had a political agenda and a
  need to complain rather than get any real work done.  you're not in good
  company.  if you don't like this, you need do nothing more than show that
  you have worthy goals with your quest -- and that is best shown by simply
  abandoning the bad solutions that you keep complaining about.

| That's not a good analogy because Lisp is a lot more like playing than
| like doing civil engineering.

  I'm glad you show me I was right in judging you to be an RUA person, but
  really, don't you think I spent all that time with a glimmer of hope that
  you might recognize how RIA people _differ_ from yourself in what I

  time for the lament of the day: it is so often such a terrible _waste_ to
  write anything non-mundane to this newsgroup it's truly _exasperating_.
  the only thing you fucking dolts care about is whether people use nice
  words or bad, and then if you get nice, approved words, your brains seal
  shut with "oh, it's nothing dramatically new, so I'll just lull myself
  into my cozy old stupidity and enjoy the peace and quiet from not having
  to listen to anyone".  I get _sick_ of such idiocy and stupidity!  many
  of you guys seem to want it more than anything else, and some even go out
  of their way to _encourage_ nice and cozy, non-threatening stupidity.

  you, in particular, don't know much about programming, Mr. anonymous not
  for e-mail at not for spam dude, so it would help a lot if you didn't
  pretend you did and that you didn't tell people who have outgrown your
  childish approach to programming _decades_ ago about how you have _not_
  understood that this here programming thing is _not_ about playing in a
  sandbox.  a few people have tried to share their experience with you, and
  you just reject them because you refuse to believe that there's anything
  beyond toy code (by our measures, not yours).

#:Erik, actually irritated, for once