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

| Or even better, Franz should post some ACL-built executables on their web
| site, for just such purposes as this.

  the Franz Inc sales staff and their engineers have related to me in the
  past, and I'm sure I'm not misrepresenting them now, that they see
  extremely little business value in catering to people who mainly execute
  really tiny programs like the null program or "hello, world" programs.
  rather, they have told me, and I have reason to believe them, that their
  main customers use Common Lisp in large-scale applications.  their
  pricing model, licensing terms, and their Value Added Reseller programs
  all work very well together to indicate to me that they regard themselves
  somewhat like Oracle, which also provides a huge environment that people
  mainly use to deploy Really Important Applications, not somewhat like
  Larry Wall and the Perl team, who provide a large fuzzy toy environment
  that people mainly use to deploy Really Unimportant Applications.

  catering to the RUA people is antithetical to doing business well with
  the RIA people.  everybody in the computer business _knows_ this, except
  the RUA people, but they don't _actually_ count, even though they think
  they do.  for some bizarre reason, RUA people think their RUAs grow into
  RIAs when in fact they don't.  vast networks of half-cooperating RUAs are
  actually reimplemented by RIA people into a much smaller and leaner RIA
  than the RUA people could ever hope to realize when push comes to shove.

  RUA people can graduate into RIA people if they first learn to dispense
  with the notion that RUAs _matter_.  they don't.  really.  nobody is
  interested in how many RUAs you have written when they are looking for
  people to write RIAs.  and I _mean_ nobody.  RIA people need to show
  their ability to deal with complexity by reducing problems by solving the
  really big problems.  RUA people show their ability to create complexity
  by profilerating tiny solutions.  if making something you yourself can
  use takes 1 unit of time, making something somebody else can use takes 3
  units of time, and making a system that somebody else can use to to build
  something that starts the whole scale all over again, takes 9 units of
  time.  most people are extremely unprepared to build such systems, yet
  this is what it takes to grow an RIA programmer from an RUA programmer.
  that's why we need RIAs so people who think they are worth something in
  this here overheated industry can write RUAs on top of RIAs and make
  their employers happy -- they should not _ever_ believe that because they
  are using an RIA to write RUAs, they are somehow equipped to write RIAs.

| To really meet their needs, it has to fit not only the better paradigms
| but also the ones they already use, even if it doesn't fit them as well
| as C++ does.

  for some reason, everybody realizes that civil engineering is different
  from building a toy city in a sandbox.  you can't become a civil engineer
  by presenting however many pictures of beautiful sandbox cities.  it
  takes much more than that, different skills, realizing different needs,
  different attitudes, different time lines, different economies.  for one
  thing, you can't tear up a real city like you can destroy your sandbox
  city and you can't just start over if you realize that you failed.  this
  is the really big difference between RUAs and RIAs.  an RUA can be torn
  down and replaced on short notice.  that's what makes it an RUA.  an RIA
  can't be torn down without jeopardizing really serious investments, such
  as the entire existence of a company.

  there is hope for RUA people who are bored of writing small things, but
  there is no hope at all for RUA people who still think "hello, world" is
  interesting in any way, shape, or form.  RIA people think differently,
  too -- most of them enjoy discussing large-scale philosophical issues,
  and are usually very hostile to the really petty issues that most people
  think are inordinately important in their own lives.  RUa people are well
  suited to deal with their own lives in all its detail.  RIA people deal
  with thousands and millions of lives in some particular respect.

| The programmers know they will be working towards something better, but
| they need a foundation to stand on while they work, and that means being
| able to do what they do now, and advance from there one step at a time.

  this is almost entirely false.  it is true in the sense that people need
  to make one step at a time to make any serious changes to their lives,
  but deciding to go from RUA to RIA is like going from playing doctor with
  the kid next door (while yourself a kid -- we're not talking about Visual
  Basic, here) to actually putting in the planning and all the effort to
  _become_ a doctor some fifteen years later, during which time you don't
  play doctor all that much, I can tell you.  deciding to go from RUA to
  RIA is a _complete_ replacement of your whole mind-set towards what
  computers can and should do.  (e.g., an RUA person may think it's OK for
  a computer to crash.  an RIA person thinks of a dying machine the same
  way a doctor does about a patient, or a military leader about soldiers:
  it should not happen without conscious effort to avoid it to the best of
  one's ability.)

| But fear of other tradeoffs, such as a 1000 to 1 ratio of the above test,
| might be what keeps them from proceeding.

  no, what keeps them at bay is fear of insufficiency in becoming an RIA
  person.  trust me on this -- I try every single day to find RIA material
  among the hundreds and thousands of RUA people I brush against on the Net
  and in real life.  perhaps one in 200 people are suitable, and the best
  way you can spot them is they are _not_ exicited about trifling news and
  hyped-up products or stale ideas in new packaging.

| Your post of your numbers was appreciated and surprising.  I had no idea
| ACL could start that fast on any machine.  I'm a lot more interested in
| the possibility of using it for a future project now than I was before.

  I'm sort of glad you appreciate it, but to me, the whole point was to get
  _rid_ of your false concerns, not help you validate them.  I regret very
  much if I did the latter.  start-up time is _completely_ irrelevant.  as
  others have pointed out, if you need to perform a certain task often, you
  investigate scaling issues and find that optimizing for scale is a very
  different task from optimizing for individual execution.  it's somewhat
  like optimizing for having fun in your sandbox compared to saving a city
  billions of dollars through excellence in civil engineering.