Whatsnew in-perl

Dave Oswald
● Conferences Committee
Chairman
● Software Engineer
● Platform & Infrastructure
Engineering Manager

A brief history of time...
Perl 1: December 1987
Perl 2: June 1988
Perl 3: October 1989
Perl 4: March 1991
Perl 5: October 1994

Perl 5 and Perl 6 are different languages with
similar design philosophies.

Perl 5 development and innovation will continue
as Perl 5.x for the foreseeable future.

Perl 5 Versions
● Ancient History
– 5.001 (1995)
– 5.002 (1996)
– 5.003 (1996)
– 5.004 (1997)
– 5.005 (1998)
● Middle History
– 5.6 (2000)
– 5.8 (2002)

Stagnation in the Perl 5.8 era

Perl 5 Versions
● Modern Perl
– 5.10 (2007)
● 2008
● 2009
– 5.12 (2010)
– 5.14 (2011)
– 5.16 (2012)
– 5.18 (2013)
● Middle (Dark) Ages
– 5.6 (2000)
– 5.8 (2002)
● 2003
● 2004
● 2005
● 2006
● 2007

Annual Release Cycles Since 2010
(Perl 5.12)

Filling in of the core ecosystem

Core comparison
● Perl 5.000
– Core: 1MB (53 files)
– Libs: 250KB (76 files)
– Exts: 216KB (38 files)
– Tests: 154KB (92 files)
– Docs: 536KB (62 files)
– Total: 2.2MB (321 files)
● Perl 5.26.0
– Core: 9MB (121 files)
– Libs: 24MB (1200 files)
– Exts: 40MB (3017 files)
– Tests: 10MB (2614 files)
– Docs: 8MB (211 files)
– Total: 91MB (7163 files)

open my $fh, ‘>’, ‘foo.txt’

{
open my $fh, ‘<’, ‘foo.txt’;
my @input = <$fh>;
}
# $fh falls out of scope, filehandle
closed.
Lexical Filehandles

Three arg open
● Two-argument open
exposes the shell.
open my $fh, “>$foo”
$foo = “/tmp/foo; rm
-rf /”
● Three-argument open
does not expose the
shell.
open my $fh, ‘>’,
$foo

PerlIO
open my $fh, ‘>:utf8’,
$file;
open my $fh, ‘<+’,
$memory;

5.8.7
(The minimum version anyone should ever use)
sitecustomize.pl

Set up a sitecustomize.pl for all of
your perlbrew, plenv, and
containers.

This is the stuff you might have missed

$foo ||= $bar
$foo = $bar if ! $foo;

$foo = $bar if ! defined $foo;

$foo //= $bar;
$foo = $bar if ! defined $foo;

$foo = $bar || $baz;
$foo = ($bar) ? $bar : $baz;

$foo = (defined $bar) ? $bar : $baz;

$foo = $bar // $baz;
$foo = (defined $bar) ? $bar : $baz;

print “Yes!” if 42 ~~ @array;
print “Yes” if grep {m/^42$/} @array

Nearly all Perl operators are monomorphic, while
data-types are polymorphic.
Smartmatch is polymorphic.
Combining polymorphic operators with
polymorphic data is madness.

Smartmatch is deprecated in its current form.

given ($foo) {
when (/^abc/) { $abc = 1; }
when (/^def/) { $def = 1; }
when (/^xyz/) { $xyz = 1; }
default { $nothing = 1; }
}

Perl’s version of a switch statement

given / when uses smartmatch semantics

We just said that smartmatch is madness.
...and that it’s deprecated.

Perl doesn’t really need a switch statement

given / when are deprecated in their current
form

use feature ‘say’;
say “Hello world”;

perl -e ‘print “Hello worldn”’
perl -E ‘say “Hello world”;’

use feature qw(say state);
feature Pragma

feature Pragma
● say
● state
● switch
● unicode_strings
● unicode_eval
● current_sub
● array_base
● lexical_subs
● postderef
● postderef_qq
● signatures
● refaliasing
● bitwise
● declared_refs

state
{
my $foo = 1;
sub count {
return $foo++;
}
}
say count(); # 1
say count(); # 2
say count(); # 3
sub count {
state $foo = 1;
return $foo++;
}
say count(); # 1
say count(); # 2
say count(); # 3

$string =~ m/a(b)c/;
say $1; # “b” if $string
matched.

$string =~ m/a(?<foo>b)c/;
say $+{foo}; # “b” if $string
matched.

our $foo = 10;
{
local $foo = 20;
say $foo; # 20
}
say $foo; # 10

my %hash = (foo => 1, bar => 2);
{
local $hash{foo} = 4;
say $hash{foo}; # 4
}
say $hash{foo}; # 1

my %hash = (foo => 1, bar => 2);
{
my $bar = delete local
$hash{foo};
say $bar; # 1;
say $hash{foo}; # undef
}
say $hash{foo}; # 1

package NAME VERSION
● package Foo::Bar;
our $VERSION = 1.23;
● package Foo::Bar
1.23;

/d, /l, /u, /a regexp flags
● Modifiers to alter regex Unicode vs ASCII
semantics.
– enough said.

sub factorial {
my ($x) = @_;
return 1 if $x == 1;
return($x * factorial($x - 1));
};
say factorial(5);

my $factorial = sub {
my ($x) = @_;
return 1 if $x == 1;
return($x * __SUB__->($x - 1));
};
say $factorial->(5);

Extended Bracketed Character Classes
(Set operations on character classes)

sub foo { say “Goodbye world!” }
{
my sub foo { say “Hello world!” }
foo(); # Hello world!
}
foo(); # Goodbye
world!

**** Subroutine Signatures ****

sub add {
die "Too many arguments for subroutine" unless
@_ <= 2;
die "Too few arguments for subroutine" unless
@_ >= 2;
my ($x, $y) = @_;
return $x + $y;
}

sub add ($x, $y) {
return $x + $y;
}

sub greet ($name = ‘World’) {
say “Hello $name!”;
}
hello(); # Hello World!
hello(‘Dave’); # Hello Dave!

sub greet {
die "Too many arguments for subroutine" unless
@_ <= 1;
my $name = $_[0] // ‘World’;
say “Hello $name!”;
}
greet(); # Hello World!
greet(‘Dave’); # Hello Dave!

my @values = @{$args->{foo}->[0]}

my @values = @{$args->{foo}->[0]}
my @values = $args->{foo}->[0]->@*

my @values = $args->{foo}->[0]->@*
my @values = $args->{foo}[0]->@*

/r
(Non-destructive substitution)

my $string = “Hello world!”;
my $copy = $string;
$copy =~ s/world/David/;

(my $copy = $string) =~
s/world/David/;

my $copy = $string =~
s/world/David/r;

my $translaterated = $string =~ tr/a-
f/A-F/r

while(<>) {
chomp;
say $_ * 2;
}

while(<<>>) {
chomp;
say $_ * 2;
}

./myscript ‘|rm -rf’
Diamond operator implicitly opens files named in
@ARGV.
<> is like 2-arg open: Exposes the shell.
<<>> is like 3-arg open. Doesn’t expose the shell.

sub foo {
print <<’HERE’;
Hello world.
This is pretty ugly code formatting.
HERE
}

sub foo {
print <<~’HERE’;
Hello world.
This is much nicer
formatting.
HERE
}

What’s the problem?
● Different versions of a module can load based on where a
script is run from.
● The script’s behavior changes based on where we run it
from.
– From ~/ it may skip an optional dependency.
– From ~/scripts may find an optional dependency in @INC
and load it.
● User-writable directories such as /tmp were unsafe as a
working directory for running any script.

As long as . is in @INC you cannot ever be sure
when you run a script from a path that is writable
by anyone aside from yourself.

You cannot ever be sure modules you are using
don’t have optional dependencies.

Steps to protect yourself
● Use Perl 5.26

Perl 5.26 is the minimum Perl version anyone
should ever use

● Use Perl 5.26
● Set up a sitecustomize.pl
– System, perlbrew, plenv, containers

● Use Perl 5.26
● Set up a sitecustomize.pl
– System, perlbrew, plenv, containers
– Perl must be built with -Dusesitecustomize
– Check state using
perl -MConfig -E ‘say
$Config{usesitecustomize}’

Set up sitecustomize.pl if your
distribution doesn’t have one
already.

That’s all that has happened since Perl 5.6 in
2000?

Hundreds... thousands of bug fixes, performance
improvements, documentation enhancements,
and other features we don’t have time to discuss.

Thousands of...
● Security Patches / Enhancements
● Bug fixes
● Performance Enhancements
● Documentation Enhancements
● New features
● Unicode improvements
● Etc.

Examples
● Improved integer performance
● Better hash key order randomization to inhibit
DOS attacks.
● Many Unicode upgrades and improvements
● fc (fold case)
● More module improvements than you can shake a
stick at.
● Thousands of pages of added documentation.

How do I know when feature X was
added to Perl?

How do I know when feature X was
added to Perl?
grep -rin 'signatures' $(find $(perl -E 'say for @INC')
-name '*delta.pod')

Encourage upgrades to modern Perl versions.

Rather than upgrading “system Perl” use
perlbrew or plenv.

Object Orientation
package Foo
sub new {
my $class = shift;
return bless {@_},
$class;
}
sub name {
return $_[0]-
>{‘name’};
}
use Moo;
has name => (is =>
ro);

Many wonderful Modules
● Try::Tiny
● Capture::Tiny
● List::MoreUtils
● Mojolicious
● Moose or Moo
● CPAN has over
20000 distributions.

A concept is only valid in Perl if it can be expressed as
a one-liner
$ perl -Mojo -E 'say g("mojolicious.org")->dom("h1")->map("text")-
>join("n")'

Perl development is alive and well.
(Rumors to the contrary are grossly exaggerated)

Modern Perl
modernperlbooks.com

perldoc perldelta
perldoc perlhist
corelist

Whatsnew in-perl

Recommended

More Related Content

What's hot (20)

Similar to Whatsnew in-perl (20)

More from daoswald (10)

Recently uploaded (20)

Whatsnew in-perl