Jeffrey Ryan Thalhammer
$3000.00
Pinto is a turnkey solution for constructing and managing local CPAN-like repositories of Perl modules. This purpose of this grant proposal is to obtain funding for development of the next release of Pinto, which will include specific features described below.
The Pinto project is less than 2 years old, but it has already gained a modest user base and is potentially relevant to a wide audience within the Perl community (i.e. anyone that uses CPAN module). Funding development on Pinto will help the Perl community by providing them with better tools for managing their CPAN modules.
The CPAN ecosystem is one of the most valuable assets of the Perl Community. However, it is not stable because authors can freely add or remove modules. As a result, end-users cannot rely on the public CPAN to provide a consistent set of Perl module dependencies from one day to the next. Sudden "breakage" of dependencies is a common frustration among Perl users.
Furthermore, the inner workings of CPAN itself (i.e. PAUSE) are not readily accessible. The code is arcane, has minimal testing, and can't be installed in the usual fashion. So despite its enormous value to the Perl Community, the CPAN infrastructure is largely unusable to those wishing to locally distribute their own private modules using the standard Perl toolchain.
Pinto solves both of these problems with a complete, robust, and extensible application. Pinto users can easily create local CPAN-like repositories that are stable and will yield the exact same modules every time. Pinto also duplicates the indexing functionality of PAUSE, so they can use these repositories to locally distribute their private modules as well. Pinto even provides novel tools for managing upgrades to dependent modules.
These capabilities are beneficial to the Perl Community because:
They make it safer to incorporate more CPAN modules into their work, thereby encouraging more use (and reuse) of CPAN modules.
They reduce the risk of breakage from upgrading CPAN modules, thereby enabling more frequent upgrades.
They facilitate sharing of private Perl modules within an organization, thereby promoting the growth of Perl.
For more details about Pinto, see the "More About Pinto" section below.
The deliverable will be a release of Pinto (and possibly other attendant modules) that support the features described below in the "Project Details" section. All software will be released under the same terms as Perl itself and delivered via the CPAN.
The deliverable will be a release of Pinto (and possibly other attendant modules) that support the features described below in the "Project Details" section. All software will be released under the same terms as Perl itself and delivered via the CPAN.
This proposal covers the addition of two key features to Pinto:
Pinto will continue to evolve and future versions will undoubtedly introduce non-compatible changes. To grow and maintain its user base, Pinto needs a way to migrate existing repositories into a format that is compatible with future versions of Pinto. This migration may involve changes to the internal database schema as well as changes to file formats and directory structures.
To be clear, the migration mechanism will only work for Pinto repositories created with the *next* release of Pinto or later. It will not work for Pinto repositories that exist right now. Currently, Pinto repositories are not versioned which makes them much more difficult to migrate. It is not impossible, but that is outside the scope of this proposal.
One of Pinto's most powerful features is an integrated versioning system. This allows users to "branch" and "merge" the indexes in their repository in a manner similar to version control systems like Git and Subversion. This allows users to upgrade modules in an isolated, audited, and reversible way, thereby reducing risks from changes and increasing visibility into the evolution of their dependency stack.
Pinto's current implementation of the version control mechanism is incomplete and does not scale well. I'll be finishing & enhancing the version control mechanism by either extending the built-in system it already has, or replacing it with an external VCS that is accessed through language bindings (e.g. Alien::SVN or Git::Raw).
For feature 1 (Schema Migration Mechanism)
Evaluate existing solutions for database schema migration.
Create or integrate database schema versioning and migration management code.
Create hooks for managing migration of non-database assets (e.g files, directories).
Implement and document command-line interface to migration hooks in App::Pinto.
For feature 2 (Version Control Mechanism)
Identify the key VCS features that are required (e.g. commit, branch, merge, log, diff).
Evaluate suitability of existing version control systems (notably libgit2).
Implement or integrate each of the aforementioned key VCS features in the Pinto core.
Implement and document command-line interfaces to those functions in App::Pinto.
The features outlined in this proposal are estimated to take 3 to 4 person-weeks of effort. However, the release may include additional work that is not covered in this proposal, so it may take longer to actually complete. I'm available to start the work immediately and can commit about 20 hours per week to the project. I expect completion within 9 to 12 calendar weeks.
Both features covered by this proposal can be developed concurrently. I'll be reporting progress via bi-weekly updates to blogs.perl.org.
Completeness can be evaluated when Pinto is released to the CPAN. The final implementation of the features outlined in this proposal will be described in the Changes file that accompanies the release. The details of the features can be further verified via the automated test cases that will also accompany the release.
Pinto is not the only tool in this space. CPAN::Mini, CPAN::Site, OrePAN, MyCPAN and others all have features that overlap with Pinto. They are all good tools that fit a particular niche. However, none of them are quite as robust and comprehensive as Pinto. For example, no other tool supports creating a single repository with multiple indexes like Pinto does. Also, Pinto is the only tool that is designed specifically to support team development and concurrent users.
https://www.youtube.com/watch?v=oaBBVZFhJUk
https://metacpan.org/module/THALJEF/Pinto-Common-0.064/lib/Pinto/Manual/Introduction.pod
https://metacpan.org/module/THALJEF/Pinto-Common-0.064/lib/Pinto/Manual/Tutorial.pod
I've been developing software (primarily in Perl) for more than 12 years. I am active in the Perl Community and have presented at YAPC and various Perl Monger meetings. I'm best known as the creator of Perl::Critic, the widely used static analyzer for Perl. I'm also the creator of Pinto, which was originally funded by Genentech in October of 2011. I have continued to work on Pinto ever since then.
UPDATE: The features outlined in this grant proposal have alaready been completed. However, the grant proposal still stands with these features instead:
The Perl community needs more well thought out and documented tools like Pinto. I think this is worth supporting.
I think this is well worth funding (and more so than my own proposal).