One thing which appears to be missing from this whole discussion is one 
key point:

Languages are tools to get work done.   I want my chosen language to 
help me get the work done as efficiently as possible, and of course 
correctly.

I prefer that I can convey what I need to get done to the language 
quickly and easily.   Often, Strongly typed languages add a whole 
additional layer of complexity that quite frankly isn't needed.   
Writing in Pascal versus C is a good example of what I am talking about, 
although perhaps C took it too far toward simplicity and perhaps into 
danger.   In pascal you define everything and doing anything weird adds 
a whole layer of complexity just to convince the language that you do in 
fact want to do what you are asking it to - "yes I do want to increment 
the 'ascii value' of the character in the third position on the string 
by one".

My favorite language to write in is Perl.   What is interesting is that 
perl is as close to a typeless language as you can get, and it makes 
well-defined decisions as to what you really want.   For instance if you 
use an arithmetic operator on two variables it will add them as 
numbers.   If one of the variables is a string, it will convert it to 
the numeric reference firrst.

If instead you wanted to concatenate two strings, you need to use the 
concatenation operator.   Concatenate to numeric values?  Well you get 
the result that you would if you convert each to a string and then 
concatenate them.

And so on.

I am not convinced by the argument that a more ridgid language produces 
better code.  Java is arguably much more ridgid than C, and I'll tell 
you that there is *lots* of buggy Java out there.

My original post was sort of asking what C did to figure out how it was 
going to produce the results it did, specifically when doing math on 
mixed types (and for the record, I typically use all integers, and very 
rarely have to mix types other than perhaps integers of different 
lengths).   It's important that a language does the right thing, and 
that the right thing is well defined.   I think some of Olin's argument 
is that it is impossible to ensure that without being lots more verbose 
toward the compiler.  My argument is that this is a bunch of bull, 
although I agree that C perhaps could have been a bit better in some 
regards as to either requiring additional verbosity, or doing things a 
bit smarter at times.   That said, most modern compilers do a fairly 
good job of telling you when they think something is weird.   "What do 
you mean you want to put a integer in a pointer?" or so on.

-forrest
-- 
http://www.piclist.com PIC/SX FAQ & list archive
View/change your membership options at
http://mailman.mit.edu/mailman/listinfo/piclist