Bernd Lorbach wrote:
>
>Jish Karoshi wrote:
>
> > How do you design programs when you can't specify types?  If all
> > I can specify in a method definition are the names of the arguments,
> > then how does anybody know how to use that method without knowing
> > about the implementation of the method?
>
>If all you know about a function is the name of the arguments,
>you cannot do serious programming. But if you know the types
>of the arguments, you cannot do neiter! Imagine a function
>
>	pid_t waitpid(pid_t wpid, int *status, int options)
>
>do you exacly know what is does, or what meaning return values
>have, without having seen any documentation? Type information
>does not help much here.
>
>The clue is, if you write a function, and want it get used by
>others, you have to provide some documentation, either as
>comments, or elsewhere. In the documentation, you also
>can provide type informatin - if the functin is restricted
>to some types.

How could any function that does any sort of useful work not be
restricted to some types?  All I can come up with is some sort
of collection classes, although I am not even convinced of that
one.  A function must be able to rely on its arguments having some
sort of attributes or operations that are that function's reason
for existing I would think.

>If you just know parameter types, you start
>trying out - and programming by try and error might be fun,
>but is not a serious thing.
>
>In Ruby, you need not specify types, as often functions can take
>more than one type.
>
>	def add_up(a,b)
>		a + b
>	end
>
>It adds what you give - It cill act on every type having
>a method "+" defined. if you pass strings it will result
>strings. If you pass integer, it will return integer:
>
>	add_up("Hello", "World") --> "HelloWorld"
>	add_up(22, 33)           --> 55
>
>That is what I call polymorphic!

So is it true that in this system the first thing that every
function ought to do, in order to be robust, is check to see
that certain operations have been implemented by the arguments
that are passed to it?
Is the definition of a type in ruby or a language like it the
set of all combinations of operations which an object has
implemented?
Also, since the return types of functions are not defined, how
does function A know that checking for the existence of
function B in some parameter is enough to do something
useful with the parameter?  Do I really need to check the type
of every argument passed to my method and then check the
return type of every method I call from those arguments?

Please understand that I am not trying to get into a static
types good or bad argument here, I am just trying to understand
what sort of artifacts would have to be generated in the
design stage of a project if that project was going to be
implemented in ruby, and what sort of process one would use
to build a robust implementation using ruby.

...

> > I have only been looking into ruby for a brief time, but from what
> > I can tell, it seems like everybody on a project would have to know
> > implementation details of the whole system in order to participate.
> > I don't understand how to chop a system up into little black boxes
> > if I don't have type information.
>
>I do not agree here. The C++ STL has more in common with a black box
>(at least for beginners) than any Ruby function.
>
>Also, I do not consider black boxes to be that bad.
>It does a great deal in hiding implementation details.

I think you might have misunderstood what I wrote (or meant
to write anyway) which is black boxes are good.  My question
is how do you make a black box in ruby, since I don't know
a way to do non-trivial projects without them? Thanks,

- jish



_________________________________________________________________
Get your FREE download of MSN Explorer at http://explorer.msn.com