On Thursday 20 November 2003 11:07 am, Michael Campbell wrote:
> Sean O'Dell wrote:
> > No has to just do it.  But when people ask for something, it gets
>
> annoying to
>
> > hear over and over "but why but why but why."  Why is not an
>
> appropriate
>
> > question anymore.
>
> It might not be appropriate to you because you seem to feel that
> there
> have been answers to it already.
>
> I'm guessing here that the people that ask now either haven't
> accepted
> that the answers that have been given to be valid.

When people give their reasons, that's it.  That's the reason.  The line of 
questioning tends to go like this:

Q = random programmer questioner
A = Ruby community answerer

Q: Does Ruby have type checking?

A: No.

Q: I need type checking.  Will it ever have type checking?

A: Maybe, but we can't figure out how to do it right now so our official 
answer is that you don't need it.  If we figure it out, then your needs will 
be considered valid.  Why do you need type checking anyway?

Q: Because we find it helps us control our large team projects.

A: I don't agree that it helps you control your large team projects.  Can you 
offer more evidence?

Q: Okay. We have to look to code quite often in lieu of project documentation, 
and normally we look to the description of classes, and the declarations of 
function parameters to determine how to make calls and to understand how 
classes are designed that are unfamiliar to some of the programmers on the 
team.  Type checking would help us to know what parameters are used by 
certain methods at-a-glance, which saves us from having to spend time 
studying source code to figure things out.

A: We always just read the source code, so that should be good enough for you.  
Perhaps if you gave us another reason.

Q: Okay. When an unsuitable object is passed to a method, and that method 
tries to call a method of the object that either doesn't exist or has a 
different number of parameters than expected, an error occurs deep inside the 
method and it's tedious figuring out how to fix what went wrong.  Some form 
of type checking would help us recognize our mistakes faster.

A: We always just read the source code where the error occured, unless it's a 
C-extension object, so that should be good enough for you.  Perhaps another 
reason would convince us.

Q: Gee, alright, but I'm running out of reasons.

A: Thus you are close to realizing the friviolity of your request.  If you had 
a sufficient quantity of reasons, you could argue indefinitely, and therefore 
win the argument.  The fact that you are running out of reasons and are 
leaving the discussion indicates that perhaps you don't really know what you 
need.  The Great Ziegler knows what you need.  Or would you prefer to 
continue discussing this?

Q: Huh?  Okay, I think.  Uhm ... well, we've been pushing to use Ruby on some 
of our projects for a long time here, and the higher ups aren't crazy about 
Ruby for a couple of reasons, and one of them is type checking.  See, they 
used to be programmers and they still know a lot about what we do, and they 
also know the value of type checking, but they're not quite as willing as we 
are to experiment a little.  I think they may have a lot of money sunk into 
the company or something.  Just for the sake of argument, to promote its use, 
having any form of type checking, even if it's completely circumventable, 
would give us a way to assuage our superiors that Ruby would not become an 
unmanagable tangle.

A: We have heard that argument before, and we will laugh at you now as we have 
laughed at others before.  HA HA!  Don't try the pointy-haired boss argument 
with us, apprentice.  Away with you now!  To Smalltalk or Python, we care 
not!  At least until we figure out how to implement some form of type 
checking that we're satisfied is strict enough to crack diamonds on, then you 
may return and we will gladly accept all of your arguments.



Okay, I'm just jabbing now.  But in all seriousness, it really sounds like the 
message around here is: "we don't want type checking, but we're trying to 
figure out how to implement it, and so far we have rejected some attempts 
because they were too soft for us because while we're really into no typing 
at all, when we do implement type checking, it must be super-rigorous or not 
at all, and until then your arguments for why you need type checking are 
completely beneath contempt, although if we do ever figure out how to 
implement a super-rigorous type checking system, then we'll give you what 
you've been asking for."

	Sean O'Dell