Well, you could look at MS now and see all the same monopolistic
practices, and the same feeble attempts to prevent them crapping all
over the industry, and draw the same conclusions.  But they might be
equally wrong.  It would be interesting to understand what happened to
IBM and see if you can find analogous mistakes that MS are making.

This is topic drift of the worst kind, I should stop now!

        Of course, this happens with C programs too; just that these
.dll files are often placed there by the manufacturer.  I've had
to download huge VBRUN files for windoze apps though...

        Let's say, you wanted to

        I've thought of writing lisp apps for linux in cases where the
clients want a box on the network to do something specific.  This is
probably a market that hasa sales in it. but I'm not sure how many.

In article <358F5262.20A52...@lavielle.com>,
        Rainer Joswig <jos...@lavielle.com> writes:

In article <hg1cnfk0....@lise.lavielle.com>,
        Rainer Joswig <jos...@lavielle.com> writes:

  Wasn't Symbolics charging big bucks for Open Genera anyway? Well, big bucks
as compared to our "dream" anyway.

1) For very small, _self-contained_ utilities, Common Lisp may simply
   not be the right language.  On Unix you'd rather either use the
   built-in utilites, or perl/scsh.  On Windows, this could probably be
   hacked-up in Delphi/VB/VC++ in a couple of minutes. Or you could
   even use <HYPE>Java</HYPE> and be really portable (OTOH Java also
   needs much support-code, but this sometimes happens to be already
   installed on some systems).

   Another posibility are several Scheme implementations, which are
   able to produce small stand-alone images...

   Things look very different if you want the utility to work in CL,
   as a utility for developers, since then the user already has a CL
   environment, and you only distribute the (compiled) files.

2) If you really wanted to distribute smallish applications, then
   either ECL[1] or CLiCC[4], which compile to ANSI-C, and IIRC only
   link to those functions really needed, might be better choices.
   Another option might be clisp.

So this all boils down to using the right tools for the problem: Use
CL where it works best: In medium[3] to large applications that work on
complex data and/or implement complex functionality/logic.  CL is
_not_ the language of choice for small, stand-alone applications,
which could even be implemented in perl or VB and still be
maintainable.  You wouldn't use C++ with the STL, CORBA, OpenGL and
embedded Tcl for your utility either (other than for demoing purposes,
that is).

BTW: Your questions here are giving me the idea, that you might indeed
be better served with Harlequin's Dylan: Dylan is another member of the
Lisp family of languages, in that it shares a number of it's features,
but Dylan emphasizes more the kind of things you seem to be interested
in.  Take a look at Harlequin's site, and the various pages dedicated
to Dylan on the WWW (I imagine Yahoo has a section on Dylan, which
might be a good starting point).  See also the newsgroup
comp.lang.dylan, although there is little traffic at the moment.

Regs, Pierre.

Footnotes:
[1]  commercial

[2]  free (though discontinued, and probably Unix-only)

[3]  Here I define medium to be at least around 3k lines of Lisp code,
which would roughly translate to a minimum of 6-10k lines of C++ code.
I know that this is not in line with SE classification of projects,
which label much larger projects medium...

Hi, at least the support portion of Symbolics is defnitely alive again.
My just renewed our hardware support with them nd I just exchanged a
broken Merlin I/O board this week. Haven't inquired about Genera though.
However, I do know that 8.5 had been ready for shipment earlier this
year right before they went under for a couple of months.

Mike Harper
michael.har...@alcoa.com

* Zeno the Anonymous Poster
| the moment, is it possible to create a small application with Lisp which
| could be distributed over the web?

  yes, of course.  the question is: what does the recipient need to use it?
  for some languages, the user needs to have installed *huge* libraries of
  run-time support systems, a *massive* operating system, and have
  contributed a lot to Bill Gates's now 50 billion dollar fortune.  for
  other languages, the user needs to have installed libraries of run-time
  support systems, an operating system, and not have contributed to any
  top-20 fortune list.  that's the difference between VB and Common Lisp,
  for instance, and all you can really argue is "but I already have all the
  stuff for VB installed".  the question is then why you do that instead of
  the much more sensible thing, and perhaps why you should stop installing
  stuff now, just _before_ you get yourself a Common Lisp environment, too.

| Let's say, you wanted to create a small utility which would search the
| files on Win95/NT computers and find duplicates, then provide a list to
| the user allowing them to delete duplicate files as they see fit.  Can
| you do this with Lisp?  Can you do this with Allegro Common Lisp?  Are
| small utilities like these necessarily large programs because of the size
| of Lisp itself?

  yes, of course you can.  however, how do you run this utility?  with the
  VB approach, you basically run the huge run-time system from the command
  line or GUI environment and feed it some input that happens to be your
  "small utility".  with the Common Lisp approach, you basically run the
  Common Lisp environment, then invoke the function from the listener.
  (sufficiently advanced Lisp listeners are indistinguishable from GUI's.)

  Emacs users everywhere run some surprisingly large programs in Emacs and
  don't seem to have any craving for an "executable" version of, say, Gnus.
  the same applies to other Lisp software.  of course, you _can_ run a
  separate Emacs that you dumped with Gnus and argue against the size of
  the damn thing, but why bother?  running Gnus inside your already running
  Emacs is _easier_.  an that's the issue with Common Lisp, too: it's just
  a whole lot easier to have a Common Lisp environment running and then do
  all the cool stuff in it than to run whatever other environment your
  computer came with and fire up huge run-time systems every time you need
  the services of a small utility.

* Pierre Mai
| I hate repeating myself, but:
|
| 1) For very small, _self-contained_ utilities, Common Lisp may simply
|    not be the right language.

  I disagree profoundly.  first, "self-contained" is no longer a valid
  concept when used about general purpose computers like PC's or
  workstations -- the interdepencies between individual programs and the
  operating system environment has been so blurred as to make the choice
  between "data for the run-time system" and "executable program" all but
  meaningless.  second, I run self-contained utilities in Common Lisp all
  the time, if I may twist your words a little: I call them "functions".

|    On Unix you'd rather either use the built-in utilites, or perl/scsh.

  really?  if you consider perl and scsh "utilities" to be _small_, just
  because they fit in very small source files, I'm afraid that you really
  don't see the whole picture.  Common Lisp programs are easily shorter
  than Perl and Scheme programs, so I would imagine that if you could run
  Common Lisp programs with the hash-bang convention, they'd be even
  smaller than "very small", since you completely ignore the *enormous*
  costs of the Perl and Scheme Shell execution environment.

|    Another posibility are several Scheme implementations, which are
|    able to produce small stand-alone images...

  let me tease you a bit: do you mean images from which you can boot your
  computer, like form a floppy disk?  that is the truly "stand-alone"
  program.  dedicated software like Internet routers running on PC's meet
  this definition of "stand-alone", and they do exist -- they aren't even
  very hard to build -- all it takes is linking in the basic facilities
  from a library and asking the linker to write a slightly different file
  format that the boot loader recognizes.  matter of fact, the whole
  operating system meets this definition of "stand-alone".  (however, they
  aren't _small_, anymore, and frequently need more than one CD-ROM. :)
  incidentally, no Scheme implementations I know of can write such images.

|    Things look very different if you want the utility to work in CL,
|    as a utility for developers, since then the user already has a CL
|    environment, and you only distribute the (compiled) files.

  but the user _always_ "already has" the prerequisite environment!

  this actually reminds me of a user who sued an Internet provider over
  here because their marketing line for a "complete" package of software
  and hardware for Internet users, "all you need to use the Internet", was
  _entirely_ false -- you actually needed a whole _computer_ (and it had to
  pledge allegiance to Bill Gates to boot, but that didn't seem to worry
  anybody) and only _then_ did you have all you needed.

  if you don't have a Common Lisp environment, the question should _not_
  be: "how can we make our software available to users without computers?",
  but "how do we make them understand that they need a computer _with_ a
  Common Lisp environment?"

  the problem, then, is only selling them the first Common Lisp application
  that needs a Common Lisp environment.  once he's got it, it's just
  rolling them in!

| So this all boils down to using the right tools for the problem: Use CL
| where it works best: In medium[3] to large applications that work on
| complex data and/or implement complex functionality/logic.  CL is _not_
| the language of choice for small, stand-alone applications, which could
| even be implemented in perl or VB and still be maintainable.

  wrong!  this is _so_ wrong!  *cringe*  (uncringe, breathe.)

  nothing ever _starts_ large except in some extremely specialized areas.
  all over the place, you're expected to buy the large starting point and
  then make some small application on top of it, then get more funding and
  boss approval and peer recognition and all that, and _then_ you let the
  thousand cancers grow.  Perl is *huge*, VB is even bigger.  on top of
  these monsters, you can write a small program that does something useful.
  Common Lisp is not different in any possible regard, except it makes for
  smaller, more elegant, and more playable toys.  however, when Perl or VB
  code gets bigger than is good for them (a screenful in my opinion, but
  people seem to have very large screens these days), two things happen at
  once: (1) they realize they should have used a better language, and (2)
  they can't use a better language, for several reasons: (a) they don't
  know the better language because they have never started using it for
  small toys, (b) they don't have the better language available because
  they were encouraged to use Perl and VB for "small" applications and
  never got any experience with it, (c) they don't have the chutzpah to ask
  their boss for the better language that they don't know anything about
  because they didn't dare realize that their application would work on
  complex data and/or implement complex functionality/logic until just
  after they ran out of the chutzpah needed to say Perl or VB (and they)
  could handle it, (d) it means scrapping working code, and finally, (e)
  because the change to the better language is no longer incremental, like
  all the other changes to code they have worked on or written have been.

  what happens to a Common Lisp system that grows?  with a marginal amount
  of nurturing by people who care about elegance, it stays elegant, and it
  acquires functionality the same way that the Common Lisp language did: by
  careful consideration of the costs of changing one's ways as well as good
  design in general functionality where observed necessary.  I think a
  Common Lisp programmer who is able to think in the terms of Common Lisp
  the Standard (i.e, ANSI X3.226) and who is not afraid to write functions
  and macros and interfaces that need specification on the same level of
  precision as the standard facilities will necessarily write elegant code,
  and not end up with a hodge-podge of special-cased crud that fails to
  achieve abstraction by it's sheer lop-sided overweightness, which is what
  happens to the cancerously growing masses of code in languages that had
  all their abstraction done by the language designer and then you just get
  to use whatever they left you (C, C++, Perl, VB, etc, etc).

Zeno (z...@deltanet.com) asked:

  Setting distribution fees (royalties, run-time fees, etc.) aside for the
  moment, is it possible to create a small application with Lisp which could
  be distributed over the web?  Let's say, you wanted to create a small
  utility which would search the files on Win95/NT computers and find
  duplicates, then provide a list to the user allowing them to delete
  duplicate files as they see fit.  Can you do this with Lisp?  Can you do
  this with Allegro Common Lisp?  Are small utilities like these necessarily
  large programs because of the size of Lisp itself?

If you want small lisp deliverables, I would suggest going with a Scheme
implementation, rather than Common Lisp.  

I once had to do a project for an important pro bono client that required
both (a) pretty complex semantics-driven pattern matching and (b) had to run
on (even then) ancient 386/DOS machines with 2 or 4MB ram.  I really needed
a lisp to have any hope of being able to accomplish the functional goals,
and it needed to be small (and also free).  I fairly quickly found
MIT-Scheme (aka CScheme) which fit my needs perfectly.  My deliverable was
an "executable" (saved image) which fit on a single floppy, along with an
install script and a README file.

Most Schemes don't have extensive "libraries" built into them as CL does. If
you don't mind the coding work (and style) that comes along with that, then
Scheme is a very nice vehicle for writing and delivering the kind of program
that you are talking about.

Another possibility is to use Common Lisp, but then use a "tree shaker" to
eliminate all of the parts of the image that are unreachable in your final
product.  Unfortunately, one needs to adapt coding practices which make the
work of the tree shaker effective, which are sometimes non-obvious. Allegro
comes with a tree shaker, and fairly good documentation on how to code for
it effectively.  Personally, I find it easier to start small (Scheme) and
add functionality as I need it, rather than assume the world (CL) and try to
pare it down later.

Larry

    Zeno> [...] I do not, however, understand the
    Zeno> hatred of Microsoft/Gates which echoes through your posts
    Zeno> consistently.  To me, when I purchase something, it is to me
    Zeno> as a vote for that product or company, much the same as my
    Zeno> one vote contributes to the election of politicians and
    Zeno> laws.  [...]

The answer to your first sentence is contained in the second.  The
general impression is that MS goes a bit beyond being a software house
and they use as much trickery as the market allows to grow.  I am not
talking about arguably illegal trickery, but about gratuitous
incompatibilities, constantly changing file formats, stuff line
ms-tnef mime attachments, etc. etc.  These things look stupid at first
to people who were not exposed to MS before, and then you get this
eerie feeling that these people are NOT stupid but really know what
they are doing and you don't like what they want to accomplish.  So
your "vote" is important.  Ordinarily I wouldn't give a damn what
other people use, but now I'm beginning to because what others are
"choosing" to use in multitudes is scaring me some.  

    Zeno> For instance, in the above paragraph you say that for both
    Zeno> something like VB and for Lisp, one needs to have an
    Zeno> operating system and libraries which are huge, and that the
    Zeno> difference between VB and CL is that if you use CL, you will
    Zeno> be contributing to the less successful company and not given
    Zeno> money to someone who already has a lot.  I assume this is
    Zeno> because it is better to help the underdog.  But what I am
    Zeno> more concerned with is my own bottom line.  Selfish?
    Zeno> Perhaps, but truthful.

If you are convinced you can do what you need to do with Visual Basic
and CL wouldn't get you any efficiency gains (time wise) and you don't
have to deliver on anything but MS platforms, then why bother with CL
at all?  Franz isn't there to compete with Visual Basic or Microsoft,
so I don't understand why you think you should compare them?  As far
as their market go I don't think they are the underdog.  BTW, if
Microsoft wanted to go into the Lisp business, they'd buy a vendor and
then try to kill the others by seeing to it that their V-Lisp is
somehow more suitable to use on Windows (including the runtime on the
Windows CD just might do that).  Hasn't happened yet.

    Zeno> [...] You say that *all* that can be argued is that "I already
    Zeno> have all the stuff for VB installed".  But this is a huge
    Zeno> argument, because not only do I already have it, but every
    Zeno> business that I go to has it, and they do not want to buy
    Zeno> another if the one they have serves their purpose. [...]

Of course, but none of these arguments are technical arguments showing
the superiority of Visual Basic.  It might well make business sense to
use it for your application.  What people are reacting to is not that
it might make sense for you to use it, but the implication that Lisp
is huge and thus is somehow flawed.  At least that's my take on this
thread.  The only OS+GUI bundle you need to support comes with
libraries that can [only?] be used by the language the same vendor
sells.  That's a good business decision by MS to set things up that
that's the case, it doesn't have anything to do with what common lisp
might be capable of.

[...]
    Zeno> I have been told that CL programs can be an icon on the
    Zeno> screen, and the user can just click on it to start a program
    Zeno> without having to start the correct environment first.  If
    Zeno> this is true, then to the user, running a Lisp program is
    Zeno> the same as a VB program, but not any easier.

How is it supposed to be any easier?  Direct commands by the brain?

    Zeno> [...]  The users I deal with are
    Zeno> not even used to starting the word processor to edit a
    Zeno> document, they just double-click on the document from
    Zeno> whatever program they happen to be in, and the word
    Zeno> processor starts.

I've paid my rent and fed myself more than once by dealing with
such users.  These are the same folks who call you up because
someone somewhare in their organization has installed Office-mumble
and they can no longer "open" the excel spreadsheets they receive
from that guy.  This invariably is "our" problem, because MS is
way too big to call and bitch at ... the guy who's upgraded?...
well he's UPgrading -- can't argue against progress... So yes I think
I know what kind of users you are dealing with, right?

[...]
    Zeno> ...  They would not understand why I needed them to
    Zeno> install an expensive environment on top of Windows in order
    Zeno> to run my programs, while my competition does not require
    Zeno> this.  [...]

Clearly, if people who use Visual Basic are your competition and Franz
will not give you good pricing then they are out of the picture unless
you are convinced common lisp will help you do things that would be
hard to do with VB.  My understanding though is that their runtime
royalty is a fraction of _your_ selling price.  If you are delivering on
CD, runtime size won't matter, if ACL will make you more productive the
several thousand they charge initially might not matter also.  One
would assume that if you are looking for alternatives maybe VB isn't
doing what you want anyway?  It depends on the nature of the work and
the numbers involved.  ACL is would be a bad investment for writing a
simple directory tree recurser, but maybe they want some fancy
"intranet" thing that could be built on top of cl-http?  Or maybe you
heard about companies like viaweb using CL (in their case it clearly
seems to have paid off) and want to do something similar?  We don't
know.  Maybe you could tell us more?  (Or did you already, my
apologies if that's so)

Damn, *more* topic drift.  I should post articles about Lisp...

In article <w6k969apl9....@gromit.nextel.no>,
Espen Vestre  <e...@nextel.no> wrote:

To get a little back on track, it shouldn't be all that difficult to
port current Mac apps to OS X, as a large subset of the current API
is being rewritten to sit on Mach.  Assuming that MCL is as class
an act internally as externally, it should not be difficult to run it
on OS X, and then it could theoretically be ported freely.

Y'know, I was never very optimistic about Rhapsody on Intel, and I
was very nervous about Digitool porting MCL to Rhapsody.  I think
the OS X thing is a very good idea.

* Zeno the Anonymous Poster
| I assume this is because it is better to help the underdog.  

  I think this line pretty much sums up your whole line of inquiry, here.

  so, why did I hammer on your Microsoft affiliation?  I doubt that I could
  have gotten you to express the above sentiment in so many words unless I
  had hammered real hard on it.  I have been doing custom software since
  1980 (starting my own business in 1987), and I have _never_ worked under
  the Microsoft regime, but I have had ample opportunity to watch it from
  the outside and see projects to which I was invited crumble or fail, and
  I have watched people blame _everybody_ but the people really to blame:
  Microsoft, for their sheer lack of quality products and responsibility
  towards their customers.  their customers have _always_ believed that
  they have been to blame if something failed to work right, and the lies
  that Bill Gates personally have served his every partner have likewise
  been attributed to his "smartness" and others have just been stupid to
  believe him.  I saw this pattern _very_ early on, and _that_ is why I
  want nothing of their ilk or fandom, and I have acquired an eerie skill
  in predicting the few categories Microsoft users can be in.  my distinct
  impression is that managers who insist on Microsoft products don't want
  to _succeed_, they just want to avoid failing in a world they don't
  understand, and as long as Microsoft stays afloat, they think they will
  stay afloat, too.  funny as it may seem, fin-de-siècle syndromes make
  managers act weird, too.  the Year 2000 problem is little more than the
  age-old myth that the end of world coincides with new centuries, and my
  guess there are still so many managers who haven't reacted in time is
  that they don't actually believe there will be any life on planet earth
  in new millennium, anyway, so why waste all the money?  think about it.

  however, I must admit that you surprised me a bit today, and that's quite
  a feat for a hardened cynic like myself.  I didn't know it was _possible_
  for anybody to be so arrogant and so stupid at the same time as to
  express the above sentiment towards a "competing" product or solution,
  and so utterly lacking in understanding of basic economics.  sorry to be
  harsh, but you need to snap out of your dream and _listen_, not just to
  the stuff you are prepared to listen to, but to the underlying arguments.

  when you pay for something, there is a tacit assumption that you somehow
  value whatever you pay for higher than the money you part with, and an
  explicit assumption that whoever parts with the goods values your money
  higher than the goods he parts with.  the explicit assumption is well
  known and nobody argues its validity.  the tacit assumption is what makes
  the price he charges possible in his market, and the science of marketing
  and market management is founded in psychology so murky that you would
  prefer it to be unknown to you as a customer, but you _need_ to know.
  these tacit assumption need to be made explicit in order to change the
  direction and focus of a market, and that's where Microsoft's marketing
  is at its very best: they address your belief system, not their own
  products.  this is especially important for people who don't realize that
  these assumptions are there to begin with, and that includes you, "Zeno".

  a few people, yours truly among them, argue in various fora that kids
  should be exposed to psychology from kindergarten up to withstand the
  mind-wiping techniques of twenty-first century marketing, and although
  this sounds paranoid to people who know nothing about marketing, those
  who do and who know how the mass media work have been trying to alert the
  sleeping masses for many decades.  I'm trying to alert you now.  it will
  fail with a 98% probability (a statistical fact), because your belief
  system is so constructed as to block any suggestion that those beliefs
  are manufactured by others and not your own.  the consensus among your
  peers, upon which you base your judgments, is not your own, it has been
  deliberately manufactured by those who benefit from it, from politicans
  to businesses via religious leaders and news anchors.  however, it is
  _not_ a conspiracy, it is _not_ an evil plot to subdue the masses (as if
  they weren't to begin with!), and it is _not_ a take-over plot by aliens
  visiting earth, so listen up.  this is the _natural_ development of mass
  media at work in huge societies, and it could not have become otherwise;
  the only way _not_ to get where we are would have been to destroy the
  onset of mass communication, which would never have been tolerated by the
  same masses that are controlled by it today, in exactly the same way that
  tobacco and the automobile would have been prohibited immediately had
  they been proposed today, together with their attendant costs and loss of
  human lives, but cannot be removed from society today.

  the tacit assumption at work in your world is that a development system
  has a _fixed_ upper limit to its value to developers and that leads to
  the sentiment that you are willing to pay anything _below_ that upper
  limit, but that you would not feel you would get your money's worth if
  you paid more -- you would, in your own judgment, be better off keeping
  your money and being without that development environment.  put even more
  strongly, albeit less certain, a development system has a fixed _value_
  in your judgment: you know what you can get out of the development
  environment you use today, and you cannot imagine, nor will you listen to
  testimonials, that it is possible to be an order of magnitude more
  productive in another, nor will you consider slightly different modes of
  operation that would make your development environment look like the
  cheap plastic toy it is to many other people.  the result of your tacit
  assumptions is that it would not be possible to sell you anything more
  _valuable_ than your current development environment.  thus you see the
  world as fundamentally limited, and to you, it _would_ be helping some
  underdog who overcharges for his products, not because they do, but
  because _you_ are unable to see the extra value they charge for, and
  which _others_ accept as worth more than the money they part with.

  the key question when it comes to your Microsoft affiliation, if not
  marriage, is that you have "let" Microsoft implant in you the upper value
  of the goods that its _competitors_ could sell you, but not the price of
  their own products.  the _problem_ is that you have not _let_ this happen
  to you in any conscious way, of course -- it has been shaped by the
  extremely talented and equally manipulative people at Microsoft who have
  successfully set the entire agenda for the PC industry trade rags and
  (almost) all of their journalists.  in particular, the history of the
  quite fantastic marketing of the vaporware "Windows" product is worth
  studying for decades to come.  how _could_ a fraudulent little fart in
  Seattle manage to con the whole software world into believing he would
  release a product and then not do it, over and over and over?  why did
  _anyone_ believe him?

  to the people who are aware of the assumptions that are tacit among the
  sleeping masses, it is no wonder at all that Microsoft succeeds: Bill
  Gates is very good at playing the right lullabies at the right time so
  people who wake up and smell the coffee (a blistering asphalt by now),
  they are calmed down and go back to sleep for another marketing cycle.
  those who are unable to understand or appreciate the dire consequences of
  tacit assumptions that go completely unchallenged, appear to the sleeping
  masses as if they are on cocaine or paranoid or think they are sleepless
  over Seattle.  Microsoft is so good at turning off the alarm clock that
  it has become impossible to be concerned about their business ethics
  without being associated with something the tacit assumptions elsewhere
  say is "impossible" or "impractical" or "insane", like high quality
  software, communism, or anti-innovation.

| One of my concerns was with the price of Lisp development compared to VB.

:>> > Then, where do I get Digital Unix? How much would it cost?
:>>
:>>   You run Linux instead. Alpha Linux supposedly runs DEC Unix apps.
:>
:> But Open Genera? I'd be surprised.

:   I don't know anyone who's tried. Linux support for native apps is usually
: pretty good. Besides, since you have the source to Linux, one could always fix
: it if it didn't. :-)

In the paper describing the lispm-emulator on Alpha they mention that
the emulated lispm is like a machine on the net. It all looks a lot like
using the mach-features of OSF, is this is true Linux won't be
able to run Open Genera. (The tell-tale signs of mach-calls are
negative system-call numbers it seems)

I just hope it isn't true, Open Genera on a 21264 could be fun :-).

Groetjes, Peter

A modern version of Perlis' quip that Lisp programmers know the
value of everything but the cost of nothing. :)

On 24 Jun 1998 10:38:39 -0400, Larry Hunter <hun...@nlm.nih.gov> wrote:
[Snip]

Thanks,
--
Kenneth P. Turvey <ktur...@pug1.SprocketShop.com>

* Zeno the Anonymous Poster
| Agreed.  Monopolies are bad.  But I have no interest in breaking up any
| monopolies, and I wondered why answers to questions about Lisp in this
| group have more space dedicated to the evil empire of Microsoft than
| about the benefits of using Lisp.

  in brief, because you have let Microsoft define the value to you of any
  development system that you could ever want to purchase (and thus the
  price you would be willing to pay for "a development system", regardless
  of what value it would or could offer you), and because you parade this
  microsoftization of your value system before others all the time by
  incessantly comparing with Visual Basic.

* Zeno the Anonymous Poster
| ... I do not want technology to halt because file formats should remain
| consistent forever.  I want innovation to continue, and the best that can
| be done is to give the new program the ability to save in the old format,
| can you see a better way?

  yes, I can, and so can everybody else who has ever defined data formats
  and communication protocols.  again, this is not about Microsoft, but
  about how you have let your entire intellectual capacity be reduced to
  whatever Microsoft lets you imagine.  why would technology halt because
  file formats remained consistent?  this is a given in _your_ world, but
  it is a falsehood everywhere else.  it is mind-boggling that you believe
  this crap.  you _must_ break loose from and look beyond the propaganda.

  first, gratuitous incompatibilities with the past is _not_ evidence of
  innovation, but proof of rampant stupidity and technical inferiority.  if
  it is perpetrated on purpose, which it is by Microsoft, it is also evil.
  when the concept of innovation is expressed through incompatibilities,
  which it is by Microsoft, we're talking about conceptual pollution much
  more advanced than George Owell's Newspeak.  when customers believe this
  crap, we're talking about successful marketing and business smarts and
  billions of dollars going into the wrong hands.  it's all tied together
  like this, and it's somewhat disconcerting that a Microsoft victim is so
  dead set on defending the company and never listen.  Microsoft is really
  good at the propaganda game.

  second, designing a forward-compatible data format or communications
  protocol is trivial (except for people who think it's macho to be
  complex).  those who do not base their entire business on the hope and
  expectations that all their users will upgrade, have no problem applying
  the decade-old knowledge and experience that tells them that it is
  fantastically stupid _not_ to use forward-compatible techniques when they
  are so well known throughout the entire industry, _except_ for Microsoft,
  and apparently their believers.

  for the archetypical example of forward-compatible formats, consider the
  header-value pairs used in Internet mail.  the semantics of certain
  headers were defined in RFC 822 and a pattern to header names was defined
  never to obtain standard semantics (X-headers).  that's the extent of the
  core definition.  this format was _explicitly_ forward-compatible, in
  that new RFCs were supposed to add headers according to application
  needs, as they indeed have.

  if you need an elaborate example of what a data format would be like if
  people were concerned about standardizing syntax and not semantics, take
  a look at the Standard Generalized Markup Language, the foundation of the
  hugely successful and at least somewhat forward-compatible "HTML".  SGML
  is basically a meta-language for other languages, but while it is clouded
  in a _lot_ of problems because of its inexperienced designers at the time
  it got its core definition hammered out (early 1970's), it has some
  rather unique and interesting properties with respect to forward- and
  backward-compatibility.  it would take too long to explain them here, but
  consider the HyperText Markup Language.  HTML made the same mistake by
  accident that Microsoft does on purpose: they defined the behavior of
  future additions to be intrusive on the past.  in particular, an unknown
  element in HTML _always_ causes its contents to be treated as if the
  element's boundary syntax ("tags" to the public) were absent.  this is
  _really_ stupid.  the smart choice would be to have standardized on a
  property, perhaps syntactic, which defined whether an element should
  display or should be skipped.  it doesn't take a genius to think up these
  things, but it does require people who haven't been brain-washed to think
  in terms that _exclude_ such ways.  so, surprisingly, Microsoft's RTF
  does exactly that.  one is left to wonder how that can be when they argue
  so strongly that data formats _must_ change for them to "innovate".

  don't you think it's time to get off your Microsoft horse and stop saying
  things like "the best that can be done" when you clearly lack the theory
  and the practical experience to even be _able_ to say those words?  not
  only does it _offend_ some people to see monumentally stupid ways to do
  things being paraded as "the best that can be done", it indicates that
  you are not prepared to listen, you are not coming to a new world with a
  desire to learn, but you are (in effect) coming to a new world to defend
  your old world and your old ways.  if you hear arguments intended to make
  you realize that your old world is mostly bogus, it is because you make a
  point out of telling people it's great when they know that it isn't.

  what started as small stabs at somebody's even then apparent marriage to
  Visual Basic, actually went to prove that that person would be defending
  his Microsoft ways, not because they are better, but because he wouldn't
  _let_ anything better than them _exist_, and would even be upset that
  anybody could charge a lot more money for a kind of product that he
  thought he already knew everything about and which would compete with
  "the best that could be done", because surely, _nothing_ can ever exceed
  Microsoft's work in technical excellence.  right?  (wrong!)

  as long as people say Microsoft's mass-marketed crapware is technically
  superior or even quality products, they _will_ be beat over the head with
  huge sticks by those who know better, and they are becoming more and more
  numerous because it is impossible to keep a whole nation subdued with
  propaganda _all_ the time.  operating systems that actually manage to
  keep their data formats compatible and consistent for decades have begun
  to destroy the belief systems of die-hard Microsoftians everywhere.

  BTW, Lisp's syntax and data formats have remained consistent for several
  decades.  nobody needed to define a new and incompatible _syntax_ just
  because they issued a new definition of the _language_.  this is what
  happens when good people think.  gratuitous incompatibilities is what
  happens when stupid people don't think or bad people think too much.

* Zeno the Anonymous Poster
| You say that you hammered on my Microsoft affiliation so that I would
| express the sentiments I did.

  no, that's not what I said, and that's not what I did.  I'm beginning to
  realize it's a fucking waste of time to write anything to you at all, but
  please, in the interest of understanding what I _have_ said, realize the
  difference between observing an unexpected result that could not have
  happened without a specific antecedent which had its own purpose and
  causes, and an action intended to cause the exact same result.  just
  because you see the result doesn't mean it had to come from the set of
  causes your failing brain imagines.  this is _extremely_ elementary.

  please also refrain from rewriting what other people say and making
  stupid summaries of what you fail so utterly to understand.  it may be
  entertainment to you, just as it is _expected_ of people who have to
  defend their very core beliefs, but can't and won't, always find cause to
  laugh or find themselves "entertained", but that doesn't mean it wasn't
  an attempt to reach a working brain at least somewhat open for new views
  (which failed, with the 98% expected probability, which you went on to
  prove, for reasons I do not understand -- usually people pull themselves
  together and try real hard to be in the select crowd that "gets" an idea
  in the face of such statistics -- perhaps the ideas were just to much for
  your brain to handle all at once and you _had_ to assume it wasn't real).

| I would have to think extremely hard, and have the help of some mushrooms
| to understand that managers are buying Microsoft products because there
| will be no life on planet earth in a short few years.

  excuse me?  whoever _wrote_ this insane bullshit but _yourself_?  does
  your brain work, not by thinking, integrating, and analyzing ideas, but
  by juxtaposing random sentences and declaring yourself "entertained" by
  results like the above?  does your brain run Visual Basic?

| Yes, you certainly do have the most open, inquisitive mind I have ever
| encountered.  Not set in your ways, you're not--oh, no.

  thank you for the final proof of the upper limit to your capabilities.
  it saves me a lot of time and effort to know that I would have been
  dealing with someone whose ability to accept information and ideas
  contrary to his tacit assumptions is _exactly_ zero.