|XP is just a number|
200 lines is probably way below the threshold for loading things in at runtime.
On the other hand, I often find myself working in the world of 10 or 20 ( or 50 ) "couple of hundred line" classes. And then loading all of them all of the time becomes more painful, and you use a smaller percentage of them for each call.
So, to allow for run-time loading when I care, vs load-it-all for development, on a large number of classes, and only changing one line of code, I'd so something like the following (disclosure: Yes, I am the author)
Class::Autouse just intercepts the method call, loads the normal looking class in on-the-fly and then executes the method as normal. When developing/debugging, you just
And it loads in 'Foo' at compile time, just like a normal class. Of course, to get the lovely transparentness, there's the following conditions.
1. use Foo (); # only loaded, no ->import methods get called.
2. You only get class-level granularity
3. Class::Autouse has an overhead of about 200k itself
Of course, when you get to 50 classes, it's a great trade off to be able to do
And have all 50 children of Foo:: autoload transparently the first time a method gets called.
Anyways, that's my two cents.
In reply to Re: Program structure: subs vs modules vs Selfloader