Placing all your "shareable" variables in a package (which is not OO) can help you to save lines of code (at least). Btw, making money from code has nothing to do with keeping your mind hussle-free and your program maintainable:

# package to group all constant, read-only vars like $DEBUG
# file is Constants.pm and can be placed in same dir as main script
# or in a './lib' dir, make sure to adjust 'use lib...' in any subscri
+pt it uses it
package Constants;

use strict;
use warnings;

# boilerplate
use Exporter;
our @ISA = qw/Exporter/;

# add here all the variables you want exported
our @EXPORT = qw/$CON1 $CON2 $DEBUG/;

our $CON1 = 'a constant';
our $CON2 = 'another constant';
our $DEBUG = 1;
1;
[download]

# usage from a so-called sub-script
use strict;
use warnings;

# this is where the Constants.pm file resides relative to the path of 
+the subscript.
# good practices exist for where to place these files, this is just fo
+r demo
use lib 'lib';
use Constants;

print "Debug: $DEBUG\n";
[download]

# test.pl to demo the whole setup
# run as perl -I. test.pl
use strict;
use warnings;
do 'lib/subscript.pl';
die "failed $@" if $@;
[download]

In this way you will at least save repeating the our $DEBUG; etc... lines in each of the sub-scripts. (and changing all the subscripts whenever you add a new constant)

I used the word constant but nothing stops you from modifying those "shareable" variables in package Constants, i.e. use them as read-write without any code change above (if you do then perhaps change the filename to 'Shareable.pm' just to be consistent). Caveat: if you want to add one more worries to your head then do that by all means. AFAIC I try to be as lazy as possible and keep my brain free from keeping track who wrote what and where and in which order. As a first step I would place these variables in a package like above, as a second step I would go OO if they had to be read-write. OO is nothing scary, at least in Perl. It's the best way to encapsulate all your data and keep track of who modifies them. The usual way is to create a function to read and modify these variables, for example:

package Sharedvariables;

use strict;
use warnings;

sub new {
    my $class = shift;

    my $self = {
      # store here all the variables you want to share with an initial
+ value
      'DEBUG' => 1,
    };
    bless $self, $class;

    return $self;
}
#   my ($class, $params) = $@;
#   return bless {} => $class;

sub debug {
  my $self = shift;
  # optional boilerplate to keep track who called us and from where:
  my $parent = (caller(1))[3]; if( ! defined($parent) ){ $parent = 'ma
+in' }
  my $whoami = ( caller(0) )[3];

  # optional parameter for setting the $DEBUG to a new value
  # if this new-value is absent the we just return current value of $D
+EBUG
  my $newvalue = shift;
  if( defined $newvalue ){
    warn "$whoami (via $parent) : modifying DEBUG from ".$self->{'DEBU
+G'}." to $newvalue";
    $self->{'DEBUG'} = $newvalue
  }
  return $self->{'DEBUG'}
}
1;
[download]

# test it
use strict;
use warnings;

use lib 'lib';

use Sharedvariables;

my $SVars = Sharedvariables->new();

print "DEBUG: ".$SVars->debug()."\n";
$SVars->debug(42);
print "DEBUG: ".$SVars->debug()."\n";
[download]

And here is a version which requires minimal maintentance, you don't have to modify Sharedvariables.pm if you need to add extra variables:

package SharedvariablesM;

use strict;
use warnings;

sub new {
    my $class = shift;

    my $self = {
      # we store here all shared variables, but this is done automatic
      store => {}
    };
    bless $self, $class;

    return $self;
}

sub value {
  my $self = shift;
  my $name = shift;
  # optional parameter for setting the $DEBUG to a new value
  # if this new-value is absent the we just return current value of $D
+EBUG
  my $newvalue = shift;

  # optional boilerplate to keep track who called us and from where:
  my $parent = (caller(1))[3]; if( ! defined($parent) ){ $parent = 'ma
+in' }
  my $whoami = ( caller(0) )[3].'()';

  my $itsnewname = ! exists $self->{'store'}->{$name};

  if( defined $newvalue ){
    if( $itsnewname ){
      warn "$whoami (via $parent) : creating new variable '$name'..."
    } else {
      warn "$whoami (via $parent) : modifying '$name' from ".$self->{'
+store'}->{$name}." to $newvalue";
    }
    $self->{'store'}->{$name} = $newvalue
  } elsif( $itsnewname ){
      die "$whoami (via $parent) : you are creating a new shared varia
+ble named '$name' without a value unless you have the variable name w
+rong!"
  }

  return $self->{'store'}->{$name}
}
# clone ourselves and return new object
sub clone {
  my $self = shift;
  my $aclone = SharedvariablesM->new();
  for my $name (keys %{$self->{'store'}}){
    $aclone->value($name, $self->value($name));
  }
  return $aclone
}

sub toString {
  my $self = shift;
  my $ret = __PACKAGE__." here is what I store:\n";
  for my $name (sort keys %{$self->{'store'}}){
    $ret .= $name . '=>' . $self->{'store'}->{$name} . "\n"
  }
  return $ret;
}
1;
[download]

# and here is a test usage
use strict;
use warnings;

use lib 'lib';
use SharedvariablesM;

my $SVars = SharedvariablesM->new();

for (qw/var1 var2 var3/){
    $SVars->value($_, $_);
}
print $SVars->toString();

my $clone = $SVars->clone();
print $clone->toString();
[download]

disclaimer: scripts are unpolished and not all cases tested. If and when you change your mind about Programming then we can talk further.

5' Edit: The OO way offers you some more advantages: 1) by cloning the object holding the variables you can keep different copies of these variables for testing purposes. A deep clone must be done if you keep anything more complex than scalars. 2) You can pass the variables object to each sub that needs to read configuration etc. And it's easy to save (serialise) the object to disk and reload it for the next run in order to remember state. Again, without you making any changes when you add an extra variable.

bw, bliako