John Peacock wrote:
Michael G Schwern wrote:
That is why I would not recommend Module::Install. Its new interface
sits on top of MakeMaker and thus contains all its underlying flaws.
Worse, it is a customization of MakeMaker. There is no safe way to
customize MakeMaker. Module::Install will eventually fail.
It doesn't even support all of the EU::MM methods that /do/ work:
https://rt.cpan.org/Ticket/Display.html?id=20375
Not surprisingly, after filing that ticket (and getting no response), I
converted SVN::Notify::(Config|Snapshot) to use Module::Build and I
haven't looked back.
Because Module::Install ships copies of itself in each distribution
this will cause a widespread CPAN cascade failure. Individual users
will not be able to fix this by just upgrading their installed copy of
Module::Install. Each author has to rebuild and release their
distribution to fix it. This will take months.
I can understand and even appreciate the impulse to have an install tool
that contains within itself all of the pieces needed, so that any module
using said tool doesn't require anything external at all. Sadly,
Module::Install clearly isn't it that tool. Module::Build isn't either,
but now that it is in Perl 5.10.0 (i.e. it comes free just like EU::MM
did), this isn't really a problem that needs to be solved that way any
more.
There is a happy medium. A bundled Module::Install will only ever use the
bundled copy. The rationale is that it guarantees that the same version of
the build environment which the author used will run on the user's machine.
This allows the author to customize their build modules by simply hacking the
code, but it ignores that there's more to building a module then
Module::Install. MakeMaker changes. perl changes. Compilers change. make
changes. New environments come into being. Some old ones the author wasn't
aware of might never have worked in the first place.
That leads to the CPAN cascade failure nightmare scenario when something in
the environment changes (probably perl or MakeMaker, but maybe a core module
changes and MI wasn't using it quite right) and all the bundled versions
suddenly stop working. Users have to wait for authors to update, they can't
even do it themselves since they don't know what customizations the author has
done.
A simple solution is to add easy module bundling to Module::Build which will
honor a higher external version. MakeMaker already does just this for itself
with things like ExtUtils::Install and ExtUtils::Manifest. This allows the
author to bundle their dependencies, but it also future proofs the distribution.
The other attraction to Module::Install is the interface. People seem to like
it. It might make sense to emulate the good stuff in a wrapper over
Module::Build, sans the auto-install stuff.
--
E: "Would you want to maintain a 5000 line Perl program?"
d: "Why would you write a 5000 line program?"
