Off the top of my head, I came up with the following problems:

• Some errors that would occur at script start-up now occurs when the function is called instead.
• The prototypes of functions in the module will get ignored.
• CHECK blocks in the module won't get executed and will issue a warning.
• INIT blocks in the module won't get executed and will issue a warning.
• Packagers such are PAR might not notice the module. (I'm not sure how they work.)

Bearing in mind the caveats noted by ikegami, you can also use autouse the module at the top of your program, to defer the loading of the module until if and when it is called.

This means that your program doesn't need the make-work "should I load the module before I use it?" code. There are also the AnyLoader and AutoLoader modules which do roughly the same thing, but I am less familiar with them.

Just one other thing. In case the module you're requiring does have an import() routine that's doing something meaningful, you might want to call it manually after the require. (Doing require Module; is more like use Module (); (ignoring the difference, the implicit BEGIN, for the moment). This might not always be what you want.) However, in case you do need to call import manually, you'll probably want to devise some mechanism (e.g. checking %INC) to avoid having it execute on every invocation of you sub ... (i.e. exactly the issue you were worried about).

On the other hand, if the module is just inheriting Exporter's import method (as many modules do), this is probably not much of an issue, as you can always call the routines fully qualified (instead of having them imported into your namespace).

In other words, it depends... but it might be something worth thinking about — in particular if things are not behaving as expected :)

I feel at ease only if my overall code architecture is built upon runtime loading, or if I require modules as a last resort, e.g.

sub bail_out {
    require Carp;
    Carp::confess(@_);
}
[download]

I'd use a module like Cwd up front, btw. Consider AutoLoader. Likewise, you can define a namespace of a module without actually loading it, and declare stubs for methods/subroutines like

package Cwd;
sub cwd;
package main; # or whatever module you are in
...
[download]

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}