Subject: Re: Barriers to Lisp acceptance - a "survey" question
From: Erik Naggum <>
Date: 1999/02/25
Newsgroups: comp.lang.lisp
Message-ID: <>

* Steve Gonedes <>
| The whole idea of marketing crap software seems to be based on selling
| limitations as benefits.  Lisp just can't compete very well on this level
| I don't think.

  well, marketing crap software is more about selling a better tomorrow
  than anything else.  the whole "new version" drive is about having people
  believe that the next version will somehow improve things.  as long as
  they have a next version dangled in front of them, they keep working with
  their present tools, _expecting_ the pain to end with the next version,
  or the next version after that.

  if you can make people _believe_ in tomorrow, they'll accept _whatever_
  today has to offer.  many religions may well be based on this principle.

  however, if what you have today is basically the top of the line, the
  opportunity for a belief in tomorrow as the relief of today's pain is
  gone: if it's painful today, it is likely to be painful tomorrow, too,
  and thus we have people bitching and moaning about FFI's and DEFSYSTEM
  and sockets and runtime licensing and "Lisp is dead" and all those
  extremely useless things compared to what other languages go through.

  I have also come to believe that the desire to see thing "standardized"
  comes from this lack of a belief in a better tomorrow.  if there is no
  better tomorrow, let's at least create a perfect _past_, instead, and
  that's what proper standards do.

| What I get upset with is when people invest _so_ much that their brains
| warp or something and they think that the original limitations are
| actually _desirable features_!  Don't understand how this happens, but
| this seems to be a reaction of fear in losing on their investment.   How
| many business people would invest lots of money, lose their investment,
| and continue to invest more money?  Why do people do this with software?
| Writing programs is so difficult.  Sigh.

  well, if you do something good and get rewarded for it every time, you'll
  get disappointed the first time you don't get rewarded, as if it were an
  actual signal that you were doing something wrong, and you try something
  different right away or maybe after ensuring through one or two attempts
  that you don't get rewarded, anymore: the world has changed, and what you
  do now has changed from good to indifferent or bad.  (if you can figure
  out why, a sense of efficacy reinforces your "do good - get rewarded"
  behavioral pattern.)  however, if you do something good and you get
  rewarded for it randomly and you very seldom get reprimanded for any bad
  things you do, lack of reward is a _reinforcer_ to keep doing the same
  thing over and over because you will _eventually_ get a reward, and then
  it'll all be worth it.  prayers work this way: if you pray for something
  and nothing happens like a million times, but then something close enough
  does, it wasn't coincidence -- your prayers were actually heard, and now
  you can pray for other things, and they'll eventually come true, too, if
  you pray sincerely enough or do whatever you can be duped into doing by
  some manipulative, evil person who exploits your lack of understanding of

  in other words, if you get what you deserve every time, your reaction
  pattern will be extremely well adjusted to whoever rewards or punishes
  you, but if you get random signals or no signals at all, you have to
  generate your own feedback, and this is how all psychological problems
  start if the feedback loop is out of tune with what's really out there.
  since programming is basically devoid of feedback from anything but the
  computer, a programming environment with random feedback will attract
  more users than one with consistent feedback.  another psychological
  aspect to programming is the time distance between action and reward.
  the reward or punishment may be consistently delivered, but after a
  random time, like a very frustrating random crash or bug.

  the clue to whether an environment succeeds, I think, is whether it
  manages to make people believe that they will get rewarded for doing the
  right thing, however, with sufficient randomness in delivering the reward
  that the users think that the system isn't always responding without that
  being their fault.  when it works, it's like a prayer come true, and
  people will refer to the stuff that works in religious terms like
  "incantations" instead of simply "commands" or "code".

  Common Lisp environments fail this test.  in safe mode, every error is
  reported, so you get punished consistently, you get a value (reward) from
  almost everything you do and you can predict when you won't get it, so
  the entire Common Lisp world is one that appeals to a certain type of
  people who, I believe, thrive with competent colleagues who demand and
  respect a consistent quality from their performance.  in contrast, C++
  and Perl and Windows and the other useful crap out there attract people
  who have non-caring bosses and incompetent colleagues from whom accurate
  feedback is a very rare thing, indeed.  I also believe that these tools
  _create_ that kind of working environment and that the introduction of
  Common Lisp to such environment poses a very significant threat to the
  prevailing belief systems, not because of any actual investments, but
  more like it would be to convince very religious people that their God is
  a figment of their own imagination.
#:Erik Covenant, the non-believer