view release on metacpan or  search on metacpan

README  view on Meta::CPAN

    Because Aspect-Oritented Programming moves this scattered code into a
    single module which is loaded as a single unit, another major benefit of
    this method is conditional compilation.

    Features implemented via Aspects can be compiled and added to you
    program only in certain situations, and because of this Aspects are
    useful when debugging or testing large or complex programs.

    Aspects can implement features necessary for correctness of programs
    such as reactivity or synchronisation, and can be used to add checking
    assertions to your or other people's modules.

    They can cause code to emit useful side effects not considered by the
    original author of a module, without changing the original function of
    the module.

    And, if necessary (although not recommended), they can do various types
    of "Monkey Patching", hijacking the functionality of some other module
    in an unexpected (by the original author) way so that the module acts
    differently when used in your program, when those changes might

inc/Module/Install.pm  view on Meta::CPAN

# }

use 5.005;
use strict 'vars';
use Cwd        ();
use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.
	$VERSION = '1.06';

	# Storage for the pseudo-singleton
	$MAIN    = undef;

lib/Aspect.pm  view on Meta::CPAN

Because Aspect-Oritented Programming moves this scattered code into a single
module which is loaded as a single unit, another major benefit of this method
is conditional compilation.

Features implemented via Aspects can be compiled and added to you program only
in certain situations, and because of this Aspects are useful when debugging
or testing large or complex programs.

Aspects can implement features necessary for correctness of programs such as
reactivity or synchronisation, and can be used to add checking assertions
to your or other people's modules.

They can cause code to emit useful side effects not considered by the original
author of a module, without changing the original function of the module.

And, if necessary (although not recommended), they can do various types of
"Monkey Patching", hijacking the functionality of some other module in an
unexpected (by the original author) way so that the module acts differently
when used in your program, when those changes might otherwise be dangerous or
if encountered by other programs.