All the hype about perl 5.10 can sound a little intimidating. User-level pragmata! Overloadable smartmatching operator! Thread-safe refkey hashes! For Pete's sake, have you heard about lexically ...
All the hype about perl 5.10 can sound a little intimidating. User-level pragmata! Overloadable smartmatching operator! Thread-safe refkey hashes! For Pete's sake, have you heard about lexically scoped pluggable regexp engines?
It's enough to make you think that 5.10's changes are just for the hard-core perl hackers, but it couldn't be further from the truth! The new version of Perl is full of changes that are easy to use and pack lots of useful benefits for doing plain old every day Perl programming.
We'll look at the new features, small and large, and see why you, too, will love 5.10.
JackOliviaI have learned a couple of things from your presentation. Nicely done!
http://www.riding-mower.org/
http://www.riding-mower.org/la105-john-deere-lawn-tractor/2 years ago
Are you sure you want to
Ricardo Signes, computer programmer at Pobox.comThe slides showing how awful it can be to have to manage your own inside-out objects are not intended to be a robust explanation of how to force yourself to suffer through it, but an overview of the various levels of annoyance that heap up without fieldhashes.
kevinoldYou can download and play with it here: http://search.cpan.org/~rgarcia/perl-5.10.0-RC1/
5 years ago
Are you sure you want to
Ricardo Signes, computer programmer at Pobox.comI have no idea what that Python/Ruby comment means. Are any of these features, except maybe named regex captures, inspired by Python or Ruby? Not that I can think of.
I think there are plenty of good ideas to steal from Python and Ruby, but these aren't those. Meanwhile, there are plenty of good ideas for those languages to steal from Perl.
The above program demonstrates that my slides are correct and perlsub is wrong. I will try to send a patch to p5p.
5 years ago
Are you sure you want to
Ricardo Signes, computer programmer at Pobox.com5.9.5 is the current development release. To get the closest thing to a released 5.10, check out http://dev.perl.org/perl5/docs/perlhack.html#Keeping_in_sync
I *am* glad we have Ruby and Python. Well, mostly Ruby. I don't see how they make me likely to get rid of Perl, though. Perl remains the most useful programming language in my toolbox.
Perl 5.10 for People Who Aren’t Totally InsanePresentation Transcript
Perl 5.10
for people who are not insane
Perl 5.10
for people who are not totally insane
5.10 isn’t like 5.8.x
perl5100delta
5.10 isn’t like 5.8.x
- features only get added in new 5.x releases
perl5100delta
5.10 isn’t like 5.8.x
- features only get added in new 5.x releases
- it’s been 5 years since the last release (5.8)
perl5100delta
5.10 is Way Cool
perl51000delta
5.10 is Way Cool
- no significant new features in Perl since 2002
perl51000delta
5.10 is Way Cool
- no significant new features in Perl since 2002
- remember how bad you wanted to see Star
Wars: Episode 1?
perl51000delta
5.10 is Way Cool
- no significant new features in Perl since 2002
- remember how bad you wanted to see Star
Wars: Episode 1?
- that’s how excited you should be for 5.10
perl51000delta
5.10 is Way Cool
- no significant new features in Perl since 2002
- remember how bad you wanted to see Star
Wars: Episode 1?
- that’s how excited you should be for 5.10
- but it won’t suck (no POD race scene)
perl51000delta
Lexicascopasmartwhat?
perl51000delta
Lexicascopasmartwhat?
- lexically scoped user pragmata!
perl51000delta
Yes, You Care
- Not everything in 5.10 is esoteric.
perl51000delta
Yes, You Care
- Not everything in 5.10 is esoteric.
- Not everything in 5.10 is for gurus.
perl51000delta
Yes, You Care
- Not everything in 5.10 is esoteric.
- Not everything in 5.10 is for gurus.
- Not everything in 5.10 is for C programmers.
perl51000delta
Yes, You Care
- Not everything in 5.10 is esoteric.
- Not everything in 5.10 is for gurus.
- Not everything in 5.10 is for C programmers.
- Not everything in 5.10 is super advanced.
perl51000delta
First: A Warning
feature
First: A Warning
- 5.10 is backwards compatible
feature
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
feature
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
- they’re not enabled by default
feature
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
- they’re not enabled by default
- use feature ‘mtfnpy’;
feature
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
- they’re not enabled by default
- use feature ‘mtfnpy’;
- use 5.010;
feature
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
- they’re not enabled by default
- use feature ‘mtfnpy’;
- use 5.010;
- read the perldoc
feature
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
- they’re not enabled by default
- use feature ‘mtfnpy’;
- use 5.010;
- read the perldoc I’m a perldoc
ref!
feature
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
- they’re not enabled by default
- use feature ‘mtfnpy’;
- use 5.010;
- read the perldoc
feature
say what
say $what
- new built-in, say
- it’s like print
- but it adds a newline for you
perlfunc
say $what
perlfunc
say $what
print “Hello, world!n”;
perlfunc
say $what
print “Hello, world!n”;
print “$messagen”;
perlfunc
say $what
print “Hello, world!n”;
print “$messagen”;
print “$_n” for @lines;
perlfunc
say $what
print “Hello, world!n”;
say “Hello, world!”;
print “$messagen”;
print “$_n” for @lines;
perlfunc
say $what
print “Hello, world!n”;
say “Hello, world!”;
print “$messagen”;
say $message;
print “$_n” for @lines;
perlfunc
say $what
print “Hello, world!n”;
say “Hello, world!”;
print “$messagen”;
say $message;
print “$_n” for @lines;
say for @lines;
perlfunc
truth and definedness
truth and definedness
perlop
truth and definedness
sub record_sale {
perlop
truth and definedness
sub record_sale {
my ($product, $amount) = @_;
perlop
truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$amount ||= $product->cost;
perlop
truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$amount ||= $product->cost;
...
perlop
truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$amount ||= $product->cost;
...
}
perlop
truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$amount = defined $amount
? $amount
: $product->cost;
...
}
perlop
truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$amount ||= $product->cost;
...
}
perlop
truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$amount ||= $product->cost;
...
}
perlop
the new OR operator
sub record_sale {
my ($product, $amount) = @_;
$amount //= $product->cost;
...
}
perlop
the new OR operator
$setting = defined $given
? $given
: $default;
perlop
the new OR operator
$setting = $given;
unless (defined $setting) {
$setting = $default;
}
perlop
the new OR operator
$setting = $given || $default;
perlop
the new OR operator
$setting = $given // $default;
perlop
keeping state
State Variables
$lines_left = 100;
sub read_line {
die “trial period expired”
unless $lines_left-- > 0;
...
}
perlsub
State Variables
my $lines_left = 100;
sub read_line {
die “trial period expired”
unless $lines_left-- > 0;
...
}
perlsub
State Variables
{
my $lines_left = 100;
sub read_line {
die “trial period expired”
unless $lines_left-- > 0;
...
}
}
perlsub
State Variables
package Trial::Period;
sub new {
my ($class, $arg) = @_;
my $guts = {
lines_left => $arg->{lines},
error_msg => $arg->{error},
};
return bless $guts => $class;
} my $LINES = 100;
my $ERROR = “sorry, trial period over”;
sub consume_line { my $TRIAL = Trial::Period->new({
my ($self) = @_; lines => $LINES,
$self->{lines_left}--; error => $ERROR,
} });
sub lines_left { sub read_line {
my ($self) = @_; $TRIAL->assert_lines_left;
return $self->{lines_left}; ...
} }
sub assert_lines_left {
my ($self) = @_;
unless ($self->lines_left) {
die $self->{error_msg};
}
}
1;
perlsub
State Variables
{
my $lines_left = 100;
sub read_line {
die “trial period expired”
unless $lines_left-- > 0;
...
}
}
perlsub
State Variables
sub read_line {
state $lines_left = 100;
die “trial period expired”
unless $lines_left-- > 0;
...
}
perlsub
-x stacking
Stackable File Tests
if (
-f $file
and -w $file
and -z $file
) {
unlink $file;
}
perlfunc
Stackable File Tests
if (
-f $file and -w _ and -z _
) {
unlink $file;
}
perlfunc
Smart Matching
- a new kind of comparison operator
perlsyn
Smart Matching
- a new kind of comparison operator
- its behavior depends on its inputs
perlsyn
Smart Matching
- a new kind of comparison operator
- its behavior depends on its inputs
- “if these two things match...”
perlsyn
Smart Matching
- a new kind of comparison operator
- its behavior depends on its inputs
- “if these two things match...”
- hard to tell, easy to show...
perlsyn
Better Error Message(s)
$str = “Greetings, $name. Your last
login was $last. It is now $time.”;
perldiag
Better Error Message(s)
$str = “Greetings, $name. Your last
login was $last. It is now $time.”;
Use of uninitialized value in
concatenation (.) or string at
hello.plx line 9.
perldiag
Better Error Message(s)
$str = “Greetings, $name. Your last
login was $last. It is now $time.”;
Use of uninitialized value $time in
concatenation (.) or string at
hello.plx line 9.
perldiag
inside-out objects
Inside-Out Objects
Hash::Util::FieldHash
Inside-Out Objects
- traditional objects are a hashref
Hash::Util::FieldHash
Inside-Out Objects
- traditional objects are a hashref
- look up attrs in the obj itself by attr name
Hash::Util::FieldHash
Inside-Out Objects
- traditional objects are a hashref
- look up attrs in the obj itself by attr name
- inside-out objects are content-free refs
Hash::Util::FieldHash
Inside-Out Objects
- traditional objects are a hashref
- look up attrs in the obj itself by attr name
- inside-out objects are content-free refs
- look up attrs in an external hash by obj id
Hash::Util::FieldHash
Inside-Out Objects
- traditional objects are a hashref
- look up attrs in the obj itself by attr name
- inside-out objects are content-free refs
- look up attrs in an external hash by obj id
- there are complications for inside-out objects
Hash::Util::FieldHash
Inside-Out Objects
sub size {
my $self = shift;
if (@_) {
return $self->{size} = shift;
} else {
return $self->{size};
}
}
Hash::Util::FieldHash
Inside-Out Objects
my %size;
sub size {
my $self = shift;
if (@_) {
return $size{ $self } = shift;
} else {
return $size{ $self };
}
}
Hash::Util::FieldHash
Inside-Out Objects
my %size;
sub size {
my $self = shift;
my $id = refaddr $self;
if (@_) {
return $size{ $id } = shift;
} else {
return $size{ $id };
}
}
Hash::Util::FieldHash
Inside-Out Objects
my %size;
sub size {
my $self = shift;
my $id = refaddr $self;
if (@_) {
return $size{ $id } = shift;
} else {
return $size{ $id };
}
}
sub DESTROY {
my $id = refaddr $_[0];
delete $size{ $id };
}
Hash::Util::FieldHash
Inside-Out Objects
my %size; sub CLONE {
sub size { my $class = shift;
my $self = shift;
my $id = refaddr $self; my @properties = map { values %$_ }
values %PROP_DATA_FOR;
if (@_) {
return $size{ $id } = shift; for my $old_id ( keys %OBJ ) {
} else {
return $size{ $id }; my $object = $OBJ{ $old_id };
} my $new_id = refaddr $object;
}
for my $prop ( @properties ) {
sub DESTROY { next unless exists $prop->{ $old };
my $id = refaddr $_[0]; $prop->{ $new } = $prop->{ $old };
delete $size{ $id }; delete $prop->{ $old };
} }
weaken ( $OBJ{ $new } = $object );
delete $OBJ{ $old };
}
}
Hash::Util::FieldHash
Inside-Out Objects
my %OBJECT_REGISTRY; sub CLONE {
my %size; my $class = shift;
sub size {
my $self = shift; my @properties = map { values %$_ }
my $id = refaddr $self; values %PROP_DATA_FOR;
$self->register_object; for my $old_id ( keys %OBJECT_REGISTRY )
{
if (@_) {
return $size{ $self } = shift; my $object =
} else { $OBJECT_REGISTRY{ $old_id };
return $size{ $self }; my $new_id = refaddr $object;
}
} for my $prop ( @properties ) {
next unless exists $prop-
sub DESTROY { >{ $old_id };
my $id = refaddr $_[0]; $prop->{ $new_id } = $prop-
delete $size{ $id }; >{ $old_id };
delete $OBJECT_REGISTRY{ $id }; delete $prop->{ $old_id };
} }
sub register_object { weaken ( $OBJECT_REGISTRY{ $new_id } =
my ($self) = @_; $object );
my $id = refaddr $self; delete $OBJECT_REGISTRY{ $old_id };
$OBJECT_REGISTRY{ $id } = $self; }
} }
Hash::Util::FieldHash
Field Hashes
Hash::Util::FieldHash
Field Hashes
- they’re just like hashes
Hash::Util::FieldHash
Field Hashes
- they’re just like hashes
- objects as keys become object ids
Hash::Util::FieldHash
Field Hashes
- they’re just like hashes
- objects as keys become object ids
- but get destroyed and cloned
Hash::Util::FieldHash
Field Hashes
my %size;
sub size {
my $self = shift;
if (@_) {
return $size{ $self } = shift;
} else {
return $size{ $self };
}
}
Hash::Util::FieldHash
Field Hashes
fieldhash my %size;
sub size {
my $self = shift;
if (@_) {
return $size{ $self } = shift;
} else {
return $size{ $self };
}
}
Hash::Util::FieldHash
Field Hashes
{
fieldhash my %size;
sub size {
my $self = shift;
if (@_) {
return $size{ $self } = shift;
} else {
return $size{ $self };
}
}
}
Hash::Util::FieldHash
Field Hashes
sub size {
my $self = shift;
fieldhash state %size;
if (@_) {
return $size{ $self } = shift;
} else {
return $size{ $self };
}
}
Hash::Util::FieldHash
lexical topic
(topic is how you say $_)
Lexical Topic
for (@lines) {
chomp;
next if /^#/;
next unless length;
s/a/b/;
sanity_check;
say;
}
perlvar
Lexical Topic
for my $line (@lines) {
chomp $line;
next if $line ~~ /^#/;
next unless length $line;
$line =~ s/a/b/;
sanity_check($line);
say $line;
}
perlvar
Lexical Topic
for my $_ (@lines) {
chomp;
next if /^#/;
next unless length;
s/a/b/;
sanity_check;
say;
}
perlvar
Regex
named captures
Regex: Named Captures
perlre
Regex: Named Captures
- find matches by name, not position
perlre
Regex: Named Captures
- find matches by name, not position
- avoid the dreaded$1
perlre
Regex: Named Captures
- find matches by name, not position
- avoid the dreaded $1
- no longer second to Python or .Net!
perlre
Regex: Named Captures
# our hypothetical format
section:property = value
perlre
Tran Phong Phu
http://www.riding-mower.org/
http://www.riding-mower.org/la105-john-deere-lawn-tractor/ 2 years ago
5 years ago
Slide 88:
=======
Unless you meant to leave $id as an unused variable to resolve in later slides, I'd suggest this change....
s( $site{$self} )
( $site{$id} )gx
Slide 89:
=======
Ditto
Also, make these changes
$new should be $new_id
$old should be $old_id
5 years ago
http://search.cpan.org/~rgarcia/perl-5.10.0/
5 years ago
And the spasm
Between the potency
And the existence
Between the essence
And the descent
Falls mtfnpy
5 years ago
5 years ago
I think there are plenty of good ideas to steal from Python and Ruby, but these aren't those. Meanwhile, there are plenty of good ideas for those languages to steal from Perl.
5 years ago
sub foo {
state $x = 100;
$x = $x + 1;
say $x;
}
foo() for 1 .. 10;
The above program demonstrates that my slides are correct and perlsub is wrong. I will try to send a patch to p5p.
5 years ago
I *am* glad we have Ruby and Python. Well, mostly Ruby. I don't see how they make me likely to get rid of Perl, though. Perl remains the most useful programming language in my toolbox.
5 years ago