Although you've responded to your own post rather than me, I'll assume the guilt for 'now being dogmatic' :) I'll also accept the judgement that I'm "simply lacking in mental horsepower" to see how this works?

Following on from your logger example. Each place in your application you have something like

package Some::Class;
use Logger;

sub new {
    ...
    $self->{logger} = Logger->new;
    ...
}
sub print_to_log {
    my $self = shift;
    $self->{logger}->( @_ )
}

sub someMethod {
    my( $self ) = @_;
    ...
    $self->print_to_log( 'some stuff' );
    ...
}

sub someOtherMethod {
    my( $self ) = @_;
    ...
    $self->print_to_log( 'some other stuff' );
    ...
}
[download]

Could you explain to me how you would arrange for the logging from someMethod to go to one file, and the logging from someOtherMethod to go to a different file without changing Some::Class?

I would create the new singleton instance when you need it, rather than in the initialiser, but I'll use your example where you create the object once in the initialiser.

In your example $self->{logger}->( @_ ) I will assume you meant something like $self->{logger}->log( @_ )

package Logger;

my $singleton_object;

sub new {
    my $class = ref $_[0] || $_[0];
    $singleton_object ||= bless $singleton_object, $class;
}

sub logfile_handle_for_method {
    my $self = shift;
    my ($package, $subroutine) = @_;

    # not cross-platform...
    $package =~ s!::!/!g;
    my $filename = "/var/log/$package/$subroutine.log";

    return $self->{filehandles}{$filename} if $self->{filehandles}{$fi
+lename};

    my $fh;
    open $fh, ">$filename" | die;

    $self->{filehandles}{$filename} = $fh;
}

sub log {
    my $self = shift;

    my ($package, $filename, $line, $subroutine, $hasargs,
                $wantarray, $evaltext, $is_require, $hints, $bitmask) 
+= caller(1);
    my $fh = $self->logfile_handle_for_method($package, $subroutine);

    print $fh, @_;
}
[download]

Now you could correctly point out that the same could be achieved with a file scoped hash and a package sub (rather than using OO). But if you had just used a global filehandle with a print statement at every log point (as I often see in code) you would not be able to extend it.

And that's really one reason why drilling rules like "use Singletons not globals" into younger or less skilled developers - it may not often buy them much, but it might prevent them from doing something stupid. You would hope that you could teach them about how to decide when to apply abstraction (which is all this really is about) but experience tells me that an abstract concept like abstraction is not universally understood by people wanting to be programmers.