#!/usr/bin/perl

package subs::utils;   
    use strict;
    use warnings;
    
    BEGIN {
        require Exporter;
        # set the version for version checking
        our $VERSION     = 1.00; 
        # Inherit from Exporter to export functions and variables
        our @ISA         = qw(Exporter);
        # Functions and variables which are exported by default
        # exported only if fully qualified
        our @EXPORT_OK   = qw($henky);
    }
    
    my $filename = 'store.txt';
    our $henky;
    if (open my $fh, '<', $filename) {
        local $/;
        $henky = <$fh>;
    } else {
        $henky = "henky_init";
    }

    END {
        open my $fh, '>', $filename or die "Storage failed: $!"
        print $fh $henky;
    }      

1;  # return a true value, standard module behaviour
[download]

Note that this may cause some weird behavior if you don't expect a truly persistent type of behavior. Also note that my file name is unqualified, and is thus sensitive to your choice of working directory. If this is a problem, you'll need to give it a full path that everyone who might use the module has read permission on.

How exactly is first.pl calling second.pl? There are several ways this can be accomplished. If you're using system(), exec(), qx() or backticks, then they've got no chance of sharing variables. (Not the way you're doing it anyway.) With do "second.pl" you'll fare better.

But really, I believe you should rethink your approach to structuring your code. Generally speaking a single process should be a single ".pl" file; ideally only a few lines long. The bulk of code should be organised into reusable modules.

Thanks guys, Well, the first .pl actually calls a bash script which in turn calls the second .pl script. This is due to bash support for this framework. Quite logical that the Perl variables are not persistent... A file based approach is what I was trying to avoid : ) Maybe I can look into environment variables, but all sound hacky and I should reconsider the whole global idea as usual. Thanks.

A more significant question in my mind is why is the intermediate bash shell necessary? Can you rework the logic so that perl calls bash and then, once bash finishes, continues on its merry way?

In this context, my solution won't work because it only serializes the value upon exit. You should probably write an accessor method in your globals module so that, regardless of how your export scheme works, changes to your variable are propagated.

At the end of the day, the methods that sound cleanest to me are command line parameters or environment variables, depending on some secondary concerns like existing codebase. Setting environmental variables in Perl is as simple as modifying/reading the %ENV hash; e.g. perl -e '$ENV{HELLO} = "Hi\n"; system(q{echo $HELLO})' So, modifying my code from above, your module might read

#!/usr/bin/perl

package subs::utils;   
    use strict;
    use warnings;
    
    BEGIN {
        require Exporter;
        # set the version for version checking
        our $VERSION     = 1.00; 
        # Inherit from Exporter to export functions and variables
        our @ISA         = qw(Exporter);
        # Functions and variables which are exported by default
        # exported only if fully qualified
        our @EXPORT_OK   = qw(get_henky set_henky);
    }
    
    $ENV{HENKY} //= "henky_init";
    
    sub get_henky {return $ENV{HENKY}};
    sub set_henky {$ENV{HENKY} = shift};

1;  # return a true value, standard module behaviour
[download]

Update: But I neglected to point out that changes to the variable won't propagate back up the shells, since a change in a child's environment don't affect the parent. For example: perl -e '$sq=chr 39; $ENV{HELLO} = "Hi\n"; system(qq|perl -e ${sq}print \$ENV{HELLO};\$ENV{HELLO} = "Yo\n";print \$ENV{HELLO}${sq}|); print $ENV{HELLO};' outputs

Hi
Yo
Hi
[download]

---

#11929 First ask yourself `How would I do this without a computer?' Then have the computer do it the same way.

Although not exactly what you want, a viable workaround is to import a copy of a reference. Of cource, you must dereference it each time you use it.