[plt-dev] a common collection for utility modules

From: Eli Barzilay (eli at barzilay.org)
Date: Fri Nov 6 23:37:50 EST 2009

On Nov  6, Carl Eastlund wrote:
> Second, I'm all for cleaning up stuff.  But I have no idea what
> stuff needs to be cleaned up,

Start with grepping `module.*mzscheme' -- this should give you a few
hundred files to work on.

> or which things, when cleaned up, might have something in them I
> could use.

Right -- this gives a payoff after you've done some work cleaning up

> I don't see that unstable/{foo,bar,baz,bag} requires any more
> tidying up than if it were {foo,bar,baz,bag}/private/util.

When `foo' becomes too old and gets rewritten or replaced, everything
goes with it.  `unstable' will just guarantee that rotting bits will
stay there.  (That's exactly why I said that it seems better to
accompany this proposal with a time limit for all libraries.)

> I see, mostly, the reduction in stuff that needs to be tidied up and
> removed, because there are more eyes on this code, more people
> picking it up and using it, more people who might keep it in good
> shape.  Any that stays in bad shape, well, would have anyway.

Why does it have to be this way?  This is like claiming that most of
the tree is closed source.  What's preventing you from going over
other people's code and fixing things?  Or pointing out things that
should be shared?  Or telling them that something is so useful that if
they just generalize that one bit and put it in a more general
library, you'll volunteer to document, write tests, and maintain it?
This lack of shared workload is something that exist now, and
`unstable' is just putting a new label on it.

> The fact of the matter is, we each currently treat our internal code
> as our personal code.  And this is not realistic.

Yes -- fix that!  And it can be fixed regardless of a new toplevel
label and a new kind of a "not really organized collection of code"

On Nov  6, Ryan Culpepper wrote:
> Eli Barzilay wrote:
> > 
> > (Leaving beind an unstable library that I'm using, and nobody
> > owns.  A major point that I failed to make initially is that such
> > code should never, IMO, become permanent.)
> If you're using an unstable library and nobody owns it... you own
> it.  Unless you can foist it off on someone else. If no one else
> owns it you can, of course, start assimilating the parts you want
> and junking the rest.

See above.  What needs fixing is for people to start looking beyond
their collections -- regardless of a new collection.  (And you can
summarize my above concern as: if this is not fixed, then we haven't
done anything besides shuffle some code around -- so now people still
don't care, and the code is messier.)

> If no one depends on it and no one owns it or wants to, it can be
> junked immediately. And yes, we should periodically review the
> unstable collection and eliminate dead libraries. We should probably
> do the same for all collections, but there's a higher risk of
> breaking code in planet or in some other project when we do that.

So why not do that??  Everyone's jumping up and down about adding new
stuff, but when it comes to improving existing code then we get these
"should probably"s.

          ((lambda (x) (x x)) (lambda (x) (x x)))          Eli Barzilay:
                    http://barzilay.org/                   Maze is Life!

Posted on the dev mailing list.