Why Perl remains to be related in 2022

For a language principally thought of solely good for scripting, it has rubbish assortment. It’s a easy type referred to as reference counting, the place Perl counts the variety of references to a variable and reclaims these variables if there are not any extra references (or if a program leaves the scope {that a} variable was created in). There isn’t a C monstrosity of getting to free() and thoughts all of your malloc() calls.

There may be additionally no stack overflow hell as with node.js, through which an unintended closure leads to recursion and crash.

You’ll be able to all the time use the die() diagnostic device or the Information::Dumper to determine causes in case one thing doesn’t go as deliberate. Perl could be run in debug mode with the -d change, however I’ve hardly used it.

Now allow us to distinction Perl with another well-liked languages to get a context.

Evaluating Perl to different languages

Now allow us to evaluate Perl to different languages as soon as once more. What about non blocking socket I/O or file learn? What about coping with huge information? What about binary information?

In all these departments Perl has its muscle groups to flex. For binary information nevertheless, you’re a lot better off with C or one thing. Perl does have ord, pack, and buddies. However for textual content primarily based protocols like SMTP, HTTP, and the like, Perl socket I/O is sort of good. Notably utilizing the diamond operator, <>, for consuming information from any file descriptor.

What do these items remind you of…that’s proper, UNIX. Perl resides instance of how going all the way in which with UNIX philosophy will get issues performed.

Folks discuss of node.js streams and so forth, however to me it seems like a joke in comparison with the UNIX and Perl world.

Perl is nevertheless a straightforward various to insecure PHP. However for some motive the world doesn’t wish to surrender on PHP. Perl requires extra data and has a steep studying curve in comparison with PHP, however Perl is Perl. You employ it anyplace you need and get issues performed.

Perl vs Python

Python has an interactive shell the place you may simply develop code and be taught. It’s superb and actually helps language learners. Python serves as a superb learner’s programming language.

Perl nevertheless has a -c change to only compile the code to examine for primary syntax errors.

Perl has use strict and -w flags which make it extra immune to unintended variable spelling errors and scoping issues. Python doesn’t supply that.

Python is an out and out object-oriented paradigm. Perl is a combination. Python affords a number of useful programming ideas like lambda, map, and buddies, however it stays rooted in OOP.

Perl is extra invested in utilizing conventional references and hash semantics for subroutines and different superior utilization. Python tries to do it utilizing objects a little bit like how node.js does it.

Python has Jupyter pocket book that takes the ability of Python to the browser. Python scripts are typically shorter than Perl on the whole. Python has extra financial syntax, glorious saving in strains of code by chaining objects, however Perl shines in different areas.

Generally it isn’t an apples to apples comparability as every programming language has its personal advantages and particular makes use of.

Perl vs node.js

Node.js is totally object-oriented, however capabilities are firstclass variables, which suggests you should utilize a perform identify any which manner you need and invoke it in inventive methods, however this dangers complicated inexperienced persons. It’s totally asynchronous.

The node.js program move could be scary for inexperienced persons. Even skilled programmers battle with code move and determining when a perform returns. It may result in callback hell, although guarantees and async/await make issues higher—if they’re used. However the occasion loop and single threaded node.js move makes it tougher to make use of for one off duties.

Perl is nice and extra straight-forward. Sometimes, in the event you want to use a third-party library to resolve a selected drawback, you may both do it utilizing node.js or Perl. The open supply modules for plugging into most third-party libraries exist for each languages.

More often than not, node.js depends on bundle.json and native installations. Perl will depend on system-wide installations of dependencies or libraries/modules.

Perl vs ksh/bash

Properly, this can be a humorous factor to write down. Perl could possibly be a contender for shell-scripting jobs as it’s a scripting language, appropriate? However Perl set up is an element to contemplate whether or not to make use of it or some shell in a resource-constrained surroundings like Raspberry Pi or one thing.

Perl does supply loads of very nice issues missing in shell scripts, however this actually bears no additional dialogue. It’s not a significant comparability. As an example, we don’t evaluate ksh and Python however have a tendency to speak about Perl in identical context. This is because of its roots. In any other case, there is no such thing as a that means on this.

Some drawbacks of Perl

Whereas I’m a robust supporter of Perl, allow us to be balanced and study why it isn’t making inroads in sure areas like AI. In in the present day’s AI and ML centric world, Python appears to have made a really sturdy footprint.

Relating to the efficiency of node.js and its occasion loop single-threaded efficiency, Perl just isn’t a contender.

Within the race for efficiency and trendy tendencies, Perl positively seems a bit dated. Nevertheless it does have a spot as we’ve got seen above.

Why it’s nonetheless related in 2022

Perl just isn’t going away. That ain’t gonna occur.

It’s nonetheless being utilized in CGI scripts. It’s utilized in a number of sys admin duties. Perl remains to be alive and kicking.

When it comes to bindings to different libraries and utilities, Perl is nearly as good as different selections. As an example, in the event you want to discuss to libcurl or libtls or some third-party open-source library, then we are able to typically select the language we like. Right here, Perl is supported out of the field and you may simply get your job performed.

Perl shines in what it’s good at. And so long as the issues it solves properly should not solved by different instruments, Perl will live on and develop.

Conclusion

Perl has all the time been very outstanding about its documentation and tutorials—maybe being too wordy at occasions—however clearly they’re developer-friendly.

Hopefully this text makes a case for Perl that’s convincing and fairly goal primarily based on present tendencies, utilization statistics, and developer base. A programmer is often influenced by elements that differ from that of a enterprise want or a supervisor. In each instances, Perl makes a case because it affords comfort, fast growth occasions, and wealthy group assist and tooling.

Bonus: Perl code you should utilize

MIME decoding instance

Here’s a MIME decoded that I wrote some time in the past. It shows an electronic mail by doing recursive decoding of MIME our bodies.

#!/usr/bin/perl 

use JSON;
use CGI;
use DBI;
use Sys::Syslog;
use Dealer;
use Encode qw/decode/;
use File::Basename;
use MIME::Parser;
use File::Copy;
use File::Glob;
use File::Path;

$q = CGI->new;
print $q->header('utility/json');
$json = JSON->new;
@mailBody =();
@mailText =();

openlog("--Present one quamail...  :");

my $db = DBI->join("dbi:Pg:host=/tmp", "postgres", undef, {AutoCommit => 0});

if(!outlined($db)) {
    print("error","Couldn't connect with Postgres db");
}

sub dump_entity {
    my ($entity, $identify) = @_;
    outlined($identify) or $identify = "'nameless'";
    my $IO;

# Output the physique:
    my @elements = $entity->elements;
    if (@elements) {                     # multipart...
        my $i;
        foreach $i (0 .. $#elements) {       # dump every half...
            dump_entity($elements[$i], ("$identify, half ".(1+$i)));
        }
    }
    else {                            # single half...    

# Get MIME kind, and show accordingly...
        my $kind = $entity->head->mime_type;
        my $physique = $entity->bodyhandle;
        if ($kind =~ /textual content/html/) {     
            if ($IO = $body->open("r")) {
                whereas (outlined($_ = $IO->getline)) {
                    push @mailText, $_; 
                }
                $IO->shut;
            }
            else {       # d'oh!
                print "$0: could not discover/open '$identify': $!";
            }
        } elsif ($kind =~ /textual content/plain/) {   
            push @mailText, "<pre>";
            if ($IO = $body->open("r")) {
                whereas (outlined($_ = $IO->getline)) {
                    push @mailText, $_; 
                }
                push @mailText, "</pre>"; 
                $IO->shut;
            }
            else {       # d'oh!
                print "$0: could not discover/open '$identify': $!";
            }

        } else {                                 # binary: simply summarize it...
            my $path = $body->path;
            my $dimension = ($path ? (-s $path) : '???');

            $f = basename($path);

            push @mailBody, "<p>Hooked up <a href="/$path">$f<a> Dimension:: $dimension bytes </p>";
        }
    }
    1;
}

$id = $q->param('id');

$stmt = "choose envip,mailfile,headers,topic,dimension,fromid,toid,date from quamail the place id = $id";

@row = $db->selectrow_array($stmt);
($envip,$mailfile, $headers, $sub, $dimension, $from , $to, $date) = @row;

push @mailBody, "<sturdy>From</sturdy>: $from<br/>";
push @mailBody, "<sturdy>To</sturdy>: $to<br/>";
push @mailBody, "<sturdy>Date</sturdy>: $date<br/>";
push @mailBody, "<sturdy>Topic</sturdy>: $sub<br/>";

push @mailBody, "<br/>";

$mfile = "/quamail/$mailfile";
$parser = MIME::Parser->new;
$parser->output_under("/tmp");
$entity = $parser->parse_open($mfile);

push @mailBody, "<br/>";
&dump_entity($entity);
push @mailBody, "<br/>";
push @mailBody, @mailText;

$h = {'mailBody' => [@mailBody]};
print($json->pretty->encode($h));
@delfiles=</tmp/msg*>;
$ign = rmtree(@delfiles, {verbose => 0});

IP geolocation question

Right here is an IP geolocation lookup performed in Perl.

#!/usr/bin/perl

use File::Basename;
use lib dirname (__FILE__);
use SpamCheetahDBQuery;
use IO::Socket;
use JSON;
use CGI;
use Sys::Syslog;
$q = CGI->new;
$| = 1;

openlog("GeoIP Countrywise");
print $q->header('utility/json');
$ipsock = "/tmp/ipsock";

@ips = SpamCheetahDBQuery::dbQuery("geoip");

%cntryHash = (), %h = ();

for $ip (@ips) {
    $cntryHash{$ip} += 1;
}

sub queryapi {
    ($ip) = @_;

    my $ipjson = IO::Socket::UNIX->new(
            Sort      => SOCK_STREAM,
            Peer => $ipsock);
    print $ipjson $ip . "n";
    my $information = decode_json(<$ipjson>);
    $cntry = $info->{'countryCode'}; 
    $cntryName = $info->{'nation'}; 
    $h{$ip} = "$cntry,$cntryName";
    syslog("information", "Nation code $cntry");
}

for $ip (keys %cntryHash) {
    &queryapi($ip);
}

%outh = ();
%tmph = ();
for $ip (keys(%cntryHash)) {
    ($cntry, $identify) = break up /,/, $h{$ip};
    $h{$cntry} += $cntryHash{$ip};
    $outh{$cntry} = { 'worth' => $h{$cntry} };
    $tmph{$identify} = "$cntry,$h{$cntry}";
}

@desk = ();
for $identify (keys(%tmph)) {
    ($code, $val) = break up /,/, $tmph{$identify};
    push @desk, {"nation" => $identify,
        "code" => lc($code),
        "mails" =>  $val};
}

my @desk = type { $b->{'mails'} <=> $a->{'mails'} } @desk;

if($#desk gt 9) {
    @desk = @desk[0..9];
}

$json = JSON->new;
if ($q->param('desk')) {
    print($json->canonical->pretty->encode(@desk));
} else {
    print($json->canonical->pretty->encode(%outh));
}

Within the above instance, you discover Perl makes use of hashes to good impact. It normally takes some years of attending to know Perl to have the ability to code idiomatically and successfully.

Perl daemon instance

Right here is daemon code I take advantage of as properly.

#!/usr/bin/perl
use Tie::File;
use Sys::Syslog;
use JSON;
use Proc::Daemon;
use Proc::PID::File;
use IO::Socket::INET;


sub refresh_mtaip {
    native $/;
# XXX learn spamcheetah config and retailer vals
    open F, "/and many others/spamcheetah.json";
    $conf = <F>;
    shut(F);
    $json = JSON->new;
    $dec = $json->decode($conf);
    %schash = %$dec;
    $/ = "n";
    $mtaip = $schash{'mtaip'};
}

openlog("Activate_mta");


sub resume_relay {
    syslog("information", "MTA is up resuming relay");
    tie @conf, "Tie::File", "/and many others/pf.conf";
    for (@conf) {
        chomp();
        subsequent if(/^#/);

        if(/rdr-to 127.0.0.1 port 6300/) {
            final;
        }
        if(/port smtps*$/) {
            $_ =~ s/s+$//;
            $_ .= ' rdr-to 127.0.0.1 port 6300';
        }
    }
    untie @conf;
    system("/sbin/pfctl -f /and many others/pf.conf");
    system("/usr/bin/pkill -HUP smtprelay");
    syslog("information", "Nothing to do EXIT");
    exit(0);

}

sub pass_thro {
    tie @conf, "Tie::File", "/and many others/pf.conf";
    for (@conf) {
        chomp();
        subsequent if(/^#/);
        if(/rdr-to 127.0.0.1 port 6300/) {
            $_ =~ s/$&//;
        }
    }
    untie @conf;
    system("/sbin/pfctl -f /and many others/pf.conf");
    syslog("information", "ACTIVATED cross thro' as MTA $mta is down");
}

sub check_mta {
    my $sock = new IO::Socket::INET (
            PeerAddr => $mtaip,
            PeerPort => '25',
            Proto => 'tcp',
            Timeout => 15
            );
    if($sock) {
        &resume_relay;
    }

}

&pass_thro;

Proc::Daemon::Init();
die "Already operating!" if Proc::PID::File->operating();
for(;;) {
    syslog("information", "Operating in cross thro' mode");
    syslog("information", "Sleeping 2 minutes");
    sleep(120);
    &refresh_mtaip;
    $res = &check_mta;
}

As you may see from above examples, I’m closely invested in Perl. And in the event you can write daemons and background server processes, then that’s positively not scripting or automation.

That’s severe stuff.

Perl CGI

On the planet of server-side processing, earlier than the ubiquity of JavaScript and the appearance of HTML5 (and earlier than the browser itself changing into so heavy in performance and options), no person might use a web site with out Perl CGI for database queries and backend work. 

However Perl and CGI each appear to be much less talked about within the internet context. Now servers for HTTP are run in node.js, be it on the frameworks Specific, Hapi, or Koa.

Nonetheless for many internet functions, Perl continues to shine in CGI. The CGI scripts that do essential database queries could be simply carried out and wrapped right into a Perl script that follows guidelines of CGI. Listed here are some pattern scripts that use numerous OS-level inter-process mechanisms like UNIX area socket.

e JSON;
use CGI;
use DBI;
use IO::Socket;
use Sys::Syslog;
use JSON;
 
$q = CGI->new;
print $q->header('utility/json');
openlog("Dashboard");
$json = JSON->new;
my $proxysock = "/tmp/proxysock";
my $db = DBI->join("dbi:Pg:host=/tmp", "postgres", undef, {AutoCommit
=> 1});
 
if(!outlined($db)) {
	print("error","Couldn't connect with Postgres db");
}
sub getstats {
	my $proxy = IO::Socket::UNIX->new(
			Sort      => SOCK_STREAM,
			Peer => $proxysock);
	print $proxy "DUMPSTATS";
 
	@out = <$proxy>;
	for(@out) {
		chomp;
		($parm,$n) = break up/=/;
		if ($parm eq "totalmailattemptcnt") {
			$outh{"mails"}= $n;
		} elsif ($parm eq "goodmailcnt") {
			$outh{"goodmail"} = $n;
		} elsif ($parm eq "numattcnt") {
			$outh{"numatt"} =$n;
		} elsif ($parm eq "regexcnt") {
			$outh{"regmatch"} =$n;
		} elsif ($parm eq "viruscnt") {
			$outh{"viruses"} = $n;
		} elsif ($parm eq "spamcnt") {
			$outh{"spamcnt"} = $n;
		} elsif ($parm eq "relaydeniedcnt") {
			$outh{"relaydenied"} = $n; 
		} elsif ($parm eq "bannedrecipcnt") {
			$outh{"badrecip"} =$n; 
		} elsif ($parm eq "bannedsendercnt") {
			$outh{"badsender"} = $n; 
		} elsif ($parm eq "blockedmimecnt") {
			$outh{"badatt"} = $n; 
		} elsif ($parm eq "rfcrejcnt") {
			$outh{"rfcrej"} = $n; 
		} elsif ($parm eq "fqdnrejcnt") {
			$outh{"fqdnrej"} = $n; 
		} elsif ($parm eq "dkimrejcnt") {
			$outh{"dkimrej"} = $n; 
		} elsif ($parm eq "spfrejcnt") {
			$outh{"spfrej"} = $n; 
		} elsif ($parm eq "helorejcnt") {
			$outh{"helorej"} = $n; 
		} elsif ($parm eq "mailszcnt") {
			$outh{"mailszrej"} = $n; 
		} elsif ($parm eq "rblrejcnt") {
			$outh{"rblrej"} = $n; 
		} elsif ($parm eq "rating") {
			$outh{"rating"} = $n; 
		} elsif ($parm eq "sender_nomx") {
			$outh{"sender_nomx"} = $n; 
		} elsif ($parm eq "norevdns") {
			$outh{"norevdns"} = $n; 
		} elsif ($parm eq "malware_attach") {
			$outh{"malware_attach"} = $n; 
		} elsif ($parm eq "malware_url") {
			$outh{"malware_url"} = $n; 
	
		}
 
	}
}
 
sub query_mails {
	$stmt = $db->put together("choose rely(*) from mails;");
	($mail_count) = $db->selectrow_array($stmt);
}
 
sub query_quarantine {
	$stmt = $db->put together("choose rely(*) from quamail;");
	($qua_count) = $db->selectrow_array($stmt);
}
 
# XXX execution begin
%outh = ();
&getstats;
&query_mails;
&query_quarantine;
$outh{"Mails"} = $mail_count;
$outh{"Quarantined"} = $qua_count;
 
syslog("information", $json->canonical->pretty->encode(%outh));
print($json->canonical->pretty->encode(%outh));
$db->disconnect;

With out server facet processing nothing strikes.

Tags: perl, unix