Subject: Re: newbie Lisp question
From: Erik Naggum <>
Date: 2000/03/10
Newsgroups: comp.lang.lisp
Message-ID: <>

* Tim Bradshaw <>
| But I think that there *are* advantages to case-insensitive readers.
| Specifically, case-sensitive languages seem to be vulnerable to the
| drEadEd studlycaps vIrUs.  C seems to be badly infected with this despite
| having grown up with powerful Unix antibodies, and I think C++ was born
| with it (Java too I guess).

  the studlycaps infection is a serious issue.  however, I think it grew
  out of the stupid way symbols are constructed in some languages, with a
  fixed set of characters available in symbol names and everything else
  being "parsed" as operators and whatnot, causing people to get scared of
  anything that looks like blank spaces.  underscores, in particular, are
  used much like "visible blanks", but they look so ugly it's no wonder
  people don't use them.  if you aren't afraid of what might look like an
  operator, foo-bar-zot beats foo_bar_zot hands down any day, but if you
  are afraid of operator look-alikes, you need fooBarZot to feel "safe".

| While I appreciate that CL probably does need to talk with these infested
| languages, and thus presumably will in due course become fully studly
| itself, I find the prospect sad.

  I don't think this will happen, but I think it's _less_ likely to happen
  with a lower-case Lisp than an upper-case Lisp.  the reason may seem
  counter-intuitive, but here goes: in an upper-case Lisp, getting symbols
  right is just too difficult for mere mortals (more so when using anything
  other than readtable-case :upcase), so to get them right, people resort
  to various hacks, the _best_ of which is using strings to refer to the
  foreign object and a symbol to hold onto the reference in the Lisp world,
  but that's comparatively inconvenient, and the symbol won't be _created_
  from the foreign name, for the obvious reasons.  in a lower-case Lisp,
  you _may_ use the symbol directly, but now it has disadvantages that you
  can see, because they aren't overshadowed by the _disadvantages_ of
  case-mangling in Common Lisp, so you can see the _advantages_ of using
  strings to name foreign objects with funny names, _plus_ you get the
  predictable results when you try to create the symbol-name yourself.
  thus, an upcasing Lisp will present self-defeating inconveniences that
  completely destroy the advantages of case-insensitivity, while a case-
  preserving lower-case Lisp will present _encouragement_ to use the much
  richer set of available symbol names, instead of the stupid names that
  particularly Windowsized C++ use to look like mangled symbol names even
  before the C++ mangler gets at them.