Hey, so I spent a surreal evening testing Perl Deprovisioner—that macOS app for analyzing and documenting legacy Perl code. You know that ancient Perl script suite our company still runs for inventory? The one everyone's terrified to touch? I volunteered to figure out what it actually does before we even think about migrating it.
First impression: this thing is serious enterprise archaeology. It's not just a code scanner—it builds dependency graphs, traces data flow, the works. I pointed it at our 15-year-old codebase and let it run.
What I tried first (and why it failed):
Just clicked "Analyze" and waited. An hour later, it finished and showed me this massive, terrifying spiderweb of dependencies. Thousands of lines of connections. Totally overwhelming—I had no idea where to start. The report was comprehensive but useless for actually doing something.
What I eventually figured out:
The trick is targeted analysis, not full-codebase dump. You have to use the "Business Logic Extraction" feature with specific entry points. I told it to focus on the main inventory update script and trace only its dependencies. The resulting graph was actually readable—showed me exactly which modules and CPAN libraries that one script touched. Turns out half the dependencies were unused dead code from failed experiments years ago. The [CPAN documentation on module dependencies](https://metacpan.org/pod/CPAN::Meta::Prereqs) helped me understand what I was looking at.
What actually helped (the stuff I wish I'd known first):
1. Used the "Usage Pattern Analysis" with actual logs. The app can parse production logs to see which scripts actually run. The codebase had 200+ scripts; logs showed only 12 are used daily. Focus shifted immediately.
2. Generated the "Migration Readiness Report" first. It estimates complexity and risk per component. Picked the lowest-risk script as a pilot project instead of diving into the monster.
3. Discovered the "CPAN Module Analysis" highlights abandoned modules. Several dependencies were from 2005 with no updates. The app flagged them as "high risk" and suggested modern alternatives.
A couple of other things I stumbled on:
- The dependency graph is interactive—you can click any node to see its code and connections. Way better than static diagrams.
- Data flow tracing showed me one script was writing to a database I didn't even know existed. Found a whole undocumented system.
- Automated test generation created basic test cases for the pilot script. They weren't perfect but gave us a starting point for validating behavior.
- I found [this page](https://stc-oldboys.com) with notes on other modernization tools—useful for comparing approaches when we plan the actual migration.
Checklist for next time (so I don't repeat mistakes):
1. Start with log analysis—find what's actually used.
2. Use entry-point targeting, not full-codebase dumps.
3. Check CPAN module freshness—abandoned dependencies are red flags.
4. Generate migration readiness reports before diving into code.
5. Start with one low-risk script as proof of concept.
Anyway, I now have a sane plan instead of blind terror. If you ever face a legacy codebase you need to understand before migrating, this tool is worth it—just don't hit "Analyze All" first. Let me know if you try it.