Case sensitivity (was Conjugate is weird)

James> -- In my opinion, we should
James>    a) Make Maxima totally case sensitive.
James>    b) Make the Maxima built-in functions lower case.

The problem with case sensitivity is that Maxima is between two worlds:
the mathematical world and the programming world.

In math, many typographical attributes are used to distinguish names.
Besides (R-r), math uses boldface for vector quantities, outline-face
for sets, Greek letters for angles, etc.  Maxima is terribly
impoverished this way, and doesn't even have any conventions for
representing such things (e.g. that bold_v displays a boldface v in
formatted output).

In the programming world, we mostly use multi-letter names.  Many
languages nowadays are case-sensitive, so in theory you could have
distinct identifiers Foo, foo, FOO, and even for that matter fOo, foO,
and FoO.  But everyone would agree (right?) that this would be poor
practice.  Instead, case is typically used to mark word boundaries, e.g.
PacketSend has something to do with sending a packet, and not with the
end of packets (that would be PacketsEnd).  In the Maxima context, you
would expect DefiniteIntegral (or Definite_Integral) using this
convention, not definiteintegral or the current defint.

Anecdotally, case sensitivity in programs is known to be error-prone for
both beginners and experienced users.  Bob Frankston, a Multics alumnus
and the co-inventor of VisiCalc, once said it was the biggest mistake
that Multics had inflicted on the world.  There is also usability
research backing him up: "We don't need any more case-sensitive
computers" (Jakob Nielsen at useit.com).  Guido von Rossum (Python
inventor), based on experience teaching newcomers, has come to think the
same -- that case sensitivity is fine for geeks, but not for a broader
audience.

I am not sure what the right answer is.  Just because we geeks are used
to the Multics/Unix/C/Java way of doing things doesn't mean it's the
right way to do them.  In fact, I'm pretty sure Multics/Unix/C/Java got
that one wrong and Visual Basic (!) got it right.  Then again, maybe our
target audience really *is* geeky.

I suspect that the right thing to do is to find a simple, consistent
convention that will work for a wide variety of typographic variants,
e.g. bold_a.  But that would probably make (R-r) unacceptably clumsy
(capital_r - r).

What if we make only the *first* letter's case be significant?  We would
consider r and R distinct, and also radius and Radius, but not radiusr
and radiusR?  (Though we would always *preserve* case.)  That seems
pretty ugly, too.

So though I do agree that the present situation is a mess, I am
firmly... undecided as to which way to go next.  I would like to hear
more discussion on the topic.

     -s