I was going to post this in the 'What's so great about lisp?' thread since there are several brush fires in that thread on the efficacy of static typing, but those sub-threads are all over the place. So...
Also, I noticed that Clinger liked John Allen's talk about the future of software engineering. This is interesting, since one of the conclusions Allen reaches is that engineers will end up providing guarantees about software through the use of (static) type-systems. How does this fit into the lisp/scheme world?
Matt
-- "You do not really understand something unless you can explain it to your grandmother." — Albert Einstein.
Hm, strong typing could be something like verifying that the if and else clause of a function return values of the same type, as that is obviously important if the caller is to rely on that.
Strongarm typing might be something like C requiring you to declare a struct just so you can return more than one value from a function.
> I have an idea what he might be talking about, but I wasn't there.
Same here.
Optional type checking provides exactly the above, and doesn't prevent code from being run.
-- Some people like democracy. That's because it does whatever the majority wants, and because they happen to be part of that majority. "Do you want the Total War?"
> Hm, strong typing could be something like verifying that the if and else > clause of a function return values of the same type, as that is obviously > important if the caller is to rely on that.
I wouldn't think so. It should mean that the type of something cannot be abused or violated, i.e. interpreted as a value of another type. Perl "is it a string or a number" values are a great example of the violation of strong typing.
Note that I am not touching on statically versus dynamically typed here. Lisp is a dynamically strongly typed languages in that you cann't abuse the type of a value. A language like Ada is statically strongly typed, relying less on the runtime side and instead making the bindings strongly typed. A language like ML seems make things so that you can't tell the difference: your very thoughts must be strongly typed.
> Strongarm typing might be something like C requiring you to declare a struct > just so you can return more than one value from a function.
I would guess forcing one to do that things that make statically typed languages tedious: force everything to be explicitly declared/constructed/proved/whatever.
-- Cheers, The Rhythm is around me, The Rhythm has control. Ray Blaak The Rhythm is inside me, rAYbl...@STRIPCAPStelus.net The Rhythm has my soul.
> Hm, strong typing could be something like verifying that the if and else > clause of a function return values of the same type, as that is > obviously important if the caller is to rely on that.
> Strongarm typing might be something like C requiring you to declare a > struct just so you can return more than one value from a function.
>> I have an idea what he might be talking about, but I wasn't there.
> Same here.
> Optional type checking provides exactly the above, and doesn't prevent > code from being run.
I didn't RTFA yet but I felt the need to caution us about not confusing static typing and strong typing, which are different things. Static typing is when types can be determined at compile time, i.e. are specified in the text of the code; dynamic typing is when type-checking waits until runtime. Strong/weak typing is another dimension, dealing with how strictly types are enforced. Lisp/Scheme is strongly (= only works on numbers, for instance), but dynamically, typed. C is statically, but more weakly, typed. An example of very strong static typing would be Ada.
>> Hm, strong typing could be something like verifying that the if and >> else clause of a function return values of the same type, as that is >> obviously important if the caller is to rely on that.
>> Strongarm typing might be something like C requiring you to declare a >> struct just so you can return more than one value from a function.
>>> I have an idea what he might be talking about, but I wasn't there.
>> Same here.
>> Optional type checking provides exactly the above, and doesn't prevent >> code from being run.
> I didn't RTFA yet but I felt the need to caution us about not confusing > static typing and strong typing, which are different things. Static > typing is when types can be determined at compile time, i.e. are > specified in the text of the code; dynamic typing is when type-checking > waits until runtime. Strong/weak typing is another dimension, dealing > with how strictly types are enforced. Lisp/Scheme is strongly (= only > works on numbers, for instance), but dynamically, typed. C is > statically, but more weakly, typed. An example of very strong static > typing would be Ada.
Yes, I meant static strong typing, thanks. "Optional type checking" should read "optional static checking."
-- Blessed are the young for they shall inherit the national debt. Herbert Hoover
