Re: Program structure: subs vs modules vs Selfloader

[adamk]

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)

# In module
package Foo;

sub bar {
    print "Hello World!\n";
}

1;



# In code
use Class::Autouse 'Foo';

Foo->bar;

Done!
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

# The following two lines produce an identical result
use Class::Autouse ':devel', 'Foo';

# Is the same as
use Foo ();

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

use Class::Autouse;
Class::Autouse->load_recursive('Foo');

And have all 50 children of Foo:: autoload transparently the first time a method gets called.

Anyways, that's my two cents.