[ruby-talk:14625] Re: Ruby code: the lost generation

On Fri, 4 May 2001, Colin Steele wrote:

>
> David Alan Black writes:
>
> 	"there are discussions and comments there [on RubyGarden] that
> 	do relate to what I mean, but the wiki itself is not what I
> 	mean...
>
> 	The same is true of Colin's Ruby Cookbook.  These are very
> 	useful things, but what I'm clumsily groping for is something
> 	that has more to do with actual code production and
> 	execution."
>
> Let me try to restate what I *think* you're asking for, David, and if
> I'm wrong, just say so. :)
>
> Your first post - the one starting this thread - posited the need for
> a solution to the problem of saving Ruby code for reuse that was
> inappropriate for either an RCR or the RAA.

Not exactly saving.  More the reusing process itself.

> Your lastest post, excerpted above, when read in conjunction with the
> comments on RubyGarden to which you refer, seems to outline a somewhat
> different issue.  To wit, that the Ruby community needs a resource for
> the colloborative development of code, which also facilitates its
> archival and distribution (read: reuse).

Yes, something like that.

> Am I near the mark with these two restatements?
>
> If so, then I think that there are a couple of solutions out there for
> the first need you've identified.  (Though there's room for
> improvement.)
>
> The second issue is intriguing, however, and I can't think of anything
> that solves this problem... but perhaps it would help if you
> elaborated a bit.

OK :-)

Each one of us can make certain decisions, at the level of the
behavior of the language, in writing a stand-alone Ruby program.  I
can decide, for instance, that I want Array#sort! to return self
instead of nil on non-change.  I go like this:

   class Array
   alias :old_sort! :sort!
     def sort!(&b)
       old_sort!(&b) || self
     end
   end

and it does.  Moreover, I can do this (obviously) based on my own
taste, whether or not this ever changes in the core language.

Now, what happens if a bunch of people all want Array#sort! to work
this way?  Everyone could of course write the above in some kind of
prologue to every program they write that uses Array#sort!.  But I
don't find that answer satisfying.  Also, that's why the Cookbook and
rubygarden aren't exact fits for this.  One can certainly use code
from those sources, but at the stage of actually writing and running a
program, there's no sharing and no distribution.

So... the idea would be to have some way to get at things at this
level of implementation, and this level of size.  Of course the flip
side of all of this is that, given the compactness of Ruby, it's not a
*huge* disaster if several people write the same three lines of code
:-)  However, I would love to find a way to have these tiny but
non-trivial methods available more systematically.  Such
systematization might have to include dependency-checking, among other
non-trivial things.  (Thanks to Dave Thomas and Guy Hurst for some irc
feedback along those lines.)

One thing that's important, in case it isn't clear from what I'm
saying, is that I am not talking about branching off different
"Rubies".  The whole point is that this kind of language-shaping power
is already available in the language, so it then becomes a question of
what one wants to do about it.  Also I'm not just talking about
reimplementations of existing core Ruby methods.  It's more the scale
(small) that unites these things.  And it's really just a matter of
abstraction: instead of writing a bunch of in-house methods, being
able to tap into them.  I don't know -- maybe we should all just
contribute our personal little libraries to RAA.... but, again, that
somehow doesn't strike me as the best fit for Ruby.


David

-- 
David Alan Black
home: [e-mail]
work: [e-mail]
Web:  http://pirate.shu.edu/~blackdav