Coming Soon - All Around the World

Coming Soon …
COPYRIGHT 2023, CC BY 4.0. ALL AROUND THE WORLD.

All Around the World
Curtis “Ovid” Poe
https://allaroundtheworld.fr/
https://fosstodon.org/@ovid
https://bsky.app/profile/ovid.bsky.social
https://twitter.com/OvidPerl
ovid@allroundtheworld.fr
curtis.poe@gmail.com

Thank you!

Question Policy

Corinna is Coming
FULL-FEATURED NATIVE OOP IN PERL!

But first, a detour … TINY MISTAKES

The Journey’s Start
BASIC
6809 Assembler
C

Perl’s Lambda
my @fs = map { my $i = $_; sub ($arg) { $i + $arg } } 0 .. 9;
say $fs[3](4);
# 7

Python’s Lambda
fs = [(lambda n: i + n) for i in range(10)]
print(fs[3](4))

Python’s Lambda
fs = [(lambda n: i + n) for i in range(10)]
print(fs[3](4))
# 13
https://math.andrej.com/2009/04/09/pythons-lambda-is-broken/

Python’s Lambda
fs = [(lambda n, i=i: i + n) for i in range(10)]
print(fs[3](4))
# 7
https://math.andrej.com/2009/04/09/pythons-lambda-is-broken/

Perl’s Lambda
my @fs = map { sub ($arg) { $arg + $_ } } 0 .. 9;
say $fs[3](4);
# Use of uninitialized value $_ in addition (+) at …
# 4

Reversing a List in Prolog
reverse([],[]).
reverse([Head|Tail],Reversed) :-
reverse(Tail,ReversedTail),
append(ReversedTail,[Head],Reversed).

Reversing a List in Prolog—O(n2)
reverse([],[]).
reverse([Head|Tail],Reversed) :-
reverse(Tail,ReversedTail),
append(ReversedTail,[Head],Reversed).

Reversing a List in Prolog—O(n)
accRev([],Accumulator,Accumulator).
accRev([Head|Tail],Accumulator,Reversed):-
accRev(Tail,[Head|Accumulator],Reversed).
reverse(List,Reversed) :- accRev(List,[],Reversed).

HelloPain.java
public class HelloWorld {
public static void main(String[] args) {
JFrame frame = new JFrame("Hello, Verbosity!");
JLabel lblText = new JLabel("Hello World!", SwingConstants.CENTER);
frame.setMinimumSize(new Dimension(800, 400));
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.getContentPane().add(lblText);
frame.pack();
frame.setVisible(true);
}
}

HelloPain.java
public class HelloWorld {
public static void main(String[] args) {
JFrame frame = new JFrame("Hello, Verbosity!");
JLabel lblText = new JLabel("Hello World!", SwingConstants.CENTER);
frame.setMinimumSize(new Dimension(800, 400))
.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
.getContentPane().add(lblText);
frame.pack()
.setVisible(true);
}
}

HelloPain.java
I called this SwingChains
It actually worked
It actually was stupid

Try/Catch

Before try/catch
sub do_it {
my ($args) = @_;
my $result;
eval { $result = might_die($args) };
if ($@) { ... }; # wrong
return $result;
}

Before try/catch
sub do_it {
my ($args) = @_;
my $result;
eval { $result = might_die($args); 1 } or do { ... };
return $result;
}

try/catch
use Try::Tiny;
sub do_it($args) {
my $result;
try { $result = might_die($args) }
catch { ... }; <--- ARGH!
return $result;
}

We replaced …
sub do_it {
my ($args) = @_;
my $result;
eval { $result = might_die($args); 1 } or do { ... };
return $result;
}

Try::Tiny versus …
package Try::Tiny; use 5.006; our $VERSION = '0.31'; use strict; use warnings; use Exporter 5.57 'import'; our @EXPORT =
our @EXPORT_OK = qw(try catch finally); use Carp; $Carp::Internal{+__PACKAGE__}++; BEGIN { my $su = $INC{'Sub/Util.pm'}
&& defined &Sub::Util::set_subname; my $sn = $INC{'Sub/Name.pm'} && eval { Sub::Name->VERSION(0.08) }; unless ($su ||
$sn) { $su = eval { require Sub::Util; } && defined &Sub::Util::set_subname; unless ($su) { $sn = eval { require
Sub::Name; Sub::Name->VERSION(0.08) }; } } *_subname = $su ? &Sub::Util::set_subname : $sn ? &Sub::Name::subname : sub
{ $_[1] }; *_HAS_SUBNAME = ($su || $sn) ? sub(){1} : sub(){0}; } my %_finally_guards; sub try (&;@) { my ( $try,
@code_refs ) = @_; my $wantarray = wantarray; my ( $catch, @finally ) = (); foreach my $code_ref (@code_refs) { if (
ref($code_ref) eq 'Try::Tiny::Catch' ) { croak 'A try() may not be followed by multiple catch() blocks' if $catch;
$catch = ${$code_ref}; } elsif ( ref($code_ref) eq 'Try::Tiny::Finally' ) { push @finally, ${$code_ref}; } else { croak(
'try() encountered an unexpected argument (' . ( defined $code_ref ? $code_ref : 'undef' ) . ') - perhaps a missing
semi-colon before or'); } } _subname(caller().'::try {...} ' => $try) if _HAS_SUBNAME; local $_finally_guards{guards} =
[ map Try::Tiny::ScopeGuard->_new($_), @finally ]; my $prev_error = $@; my ( @ret, $error ); my $failed = not eval { $@
= $prev_error; if ( $wantarray ) { @ret = $try->(); } elsif ( defined $wantarray ) { $ret[0] = $try->(); } else {
$try->(); }; return 1; }; $error = $@; $@ = $prev_error; if ( $failed ) { push @$_, $error for
@{$_finally_guards{guards}}; if ( $catch ) { for ($error) { return $catch->($error); } } return; } else { return
$wantarray ? @ret : $ret[0]; } } sub catch (&;@) { my ( $block, @rest ) = @_; croak 'Useless bare catch()' unless
wantarray; _subname(caller().'::catch {...} ' => $block) if _HAS_SUBNAME; return ( bless($block, 'Try::Tiny::Catch'),
@rest,); } sub finally (&;@) { my ( $block, @rest ) = @_; croak 'Useless bare finally()' unless wantarray;
_subname(caller().'::finally {...} ' => $block) if _HAS_SUBNAME; return ( bless($block, 'Try::Tiny::Finally'), @rest,);
} { package Try::Tiny::ScopeGuard; use constant UNSTABLE_DOLLARAT => ("$]" < '5.013002') ? 1 : 0; sub _new { shift;
bless [ @_ ]; } sub DESTROY { my ($code, @args) = @{ $_[0] }; local $@ if UNSTABLE_DOLLARAT; eval { $code->(@args); 1; }
or do { warn "Execution of finally() block $code resulted in an exception, which " . '*CAN NOT BE PROPAGATED* due to
fundamental limitations of Perl. ' . 'Your program will continue as if this event never took place. ' . "Original
exception text follows:nn" . (defined $@ ? $@ : '$@ left undefined...') . "n" ; } } }
eval { ... }
or do { ... };

Try::Tiny issues
Can’t return from inside the code blocks
Clumsy to step into the code blocks
Forgetting the trailing semicolon
Error line number often misleading
Slow!

Try::Tiny issues
Can’t return from inside the code blocks
Clumsy to step into the code blocks
Forgetting the trailing semicolon
Error line number often misleading
Slow!
IT WAS EASIER
TO GET THE
CORRECT
BEHAVIOR

try/catch
use Try::Tiny;
sub do_it($args) {
my $result;
catch { ... };
return $result;
}

try/catch
use Feature::Compat::Try; # v5.14.0 and above
sub do_it($args) {
my $result;
catch ($error) { ... }
return $result;
}

try/catch
sub do_it($args) {
try { return might_die($args) }
catch ($error) { ... }
}

Go With The Flow
•Not about verbosity
•It’s about correctness
•Using a language/tool’s strengths

Corinna Status 2023

Corinna
Bringing modern OOP to Perl
Largest change to the language in three decades
Being implemented in the core now
leonerd++

Corinna Team/Influencers
(Incomplete list by first name)
Curtis “Ovid” Poe
Damian Conway
Dan Book
Graham Knop
Harald Jörg
Matt Trout
Paul Evans
Sawyer X
Stevan Little
13 août 2023 COPYRIGHT 2022, HTTP://WWW.ALLAROUNDTHEWORLD.FR/

Corinna Today
class Cache::LRU {
use Hash::Ordered;
field $cache = Hash::Ordered->new;
field $max_size :param = 20;
method exists ($key) {
return $cache->exists($value);
}
method set ( $key, $value ) {
$cache->unshift( $key, $value );
if ( $cache->keys >= $max_size ) {
$cache->pop;
}
}
method get($key) {
return unless $cache->exists($key);
my $value = $cache->get($key);
$self->set( $key, $value );
return $value;
}
}
Sanity-checking removed to reduce
code size.

Instead of …
1. bless
2. @ISA

Simplicity
1. class
2. role
3. method
4. field

KIM Syntax
KEYWORD, IDENTIFIER, MODIFIER

KIM Grammar
KEYWORD IDENTIFIER MODIFIERS? SETUP?

KIM Grammar
KEYWORD IDENTIFIER MODIFIERS? SETUP?
class Cache::LRU {
use Hash::Ordered;
field $max_size :param = 20;
…

The Seven
Stages
Perl v5.38.0
July 3rd, 2023
1.Classes (done)
2.Inheritance (done)
3.Roles
4.Convenience attributes*
5.Field initializer blocks (done)
6.MOP
7.Method modifiers
https://github.com/Ovid/Cor/blob/master/rfc/mvp.md

The Seven
Stages
Perl v5.38.0
July 3rd, 2023
We’re going to learn new idioms
We don’t (yet) know what they are
It’s going to be challenging
https://github.com/Ovid/Cor/blob/master/rfc/mvp.md

Rogue!
In Perl …
https://github.com/perigrin/perl-games-
rot

Chris Prather—Rogue
Setup — https://chris.prather.org/perl-roguelike-part-0.html
Movement — https://chris.prather.org/perl-roguelike-part-1.html
Entities and Obstacles — https://chris.prather.org/perl-roguelike-part-2.html
Generative Dungeon — https://chris.prather.org/perl-roguelike-part-3.html
Field of View — https://chris.prather.org/perl-roguelike-part-4.html
Enemies — https://chris.prather.org/perl-roguelike-part-5.html
Combat — https://chris.prather.org/perl-roguelike-part-6.html
And more!

Nice, clean code
class MeleeAttackAction :isa(Action) {
use Games::Dice qw(roll);
field $defender :param;
method perform() {
my $attacker = $self->entity;
my $attack_roll = roll('1d20') + $attacker->stats->attack;
my $defense_roll = roll('1d20') + $defender->stats->armor;
if ( $attack_roll > $defense_roll ) {
$defender->stats->change_hp($defense_roll - $attack_roll);
}
return;
}
}

Stevan Little-Actor
Event Loop Orchestra — https://github.com/stevan/ELO
Porting to Corinna — https://github.com/stevan/Stella
All in One Gist —
https://gist.github.com/stevan/06a091d8ce775181e8c023864
beba173

Nice, clean code
class PingPong :isa(Stella::Actor) {
use Stella::Util::Debug; # import LOG_LEVEL, INFO, WARN, etc.
field $name :param; # so I can identify myself in the logs
field $max :param; # the max number of ping/pong(s) to allow
# counters for ping/pong(s)
field $pings = 0;
field $pongs = 0;
field $logger;
ADJUST {
# create a logger if logging is enabled
$logger = Stella::Util::Debug->logger if LOG_LEVEL;
}
method Ping ($ctx, $message) {
if ($pings < $max) {
...

Nice, clean code
sub init ($ctx) {
# spawn 10 sets of Ping/Pong actors
foreach my $i ( 1 .. 10 ) {
# give them a random max-pings
my $max = int(rand(10));
my $Ping = $ctx->spawn( PingPong->new( name => "Ping($i)", max => $max ) );
my $Pong = $ctx->spawn( PingPong->new( name => "Pong($i)", max => $max ) );
# start up this pair ...
$Ping->send( $Pong, Stella::Event->new( symbol => *PingPong::Pong ) );
}
}
Stella::ActorSystem->new( init => &init )->loop;

Principle of Parsimony
We made mistakes
We don’t know what they are
We had to be conservative

Dr. Michel Koenig
michelkoenig06@gmail.com
Mathematician
Computer Scientist
Security and Privacy

Your Data is Not Yours
GDPR
PII
PCI-Compliance
“Right to be forgotten”
Numerous US state-level laws

Costs
Development—How much does it cost to remove your data?
Personnel—How many more people do you need to manage
that data?
Reputation—If you get it wrong, people get mad

Threats
Compliance Costs
GDPR bankruptcy
PCI Violations

What if you could
“loan” your data?
MADNESS!

Start Lies

Lattice-based
Cryptography
Developed in1996 by Miklós Ajtai
Cannot be decrypted quantum computers
2006, Craig Gentry, homomorphic encryption
This is not how he did it

End Lies

Perl?
The actual idea is simple
Could do it in Perl
Cannot afford to get wrong

Perl? No.

Perl? Not yet.

Why not Perl?
<secret>
Performance
Data integrity
Trust

His Prototype Works

Perl 5
OBJECTS
REFERENCES
LEXICALS
MODULES

Perl 7 CORINNA?

Perl 8 WHAT’S NEXT?

What do we want?
Concurrency
Multisubs/methods
Metaprogramming
Applications
Core Exceptions
Core Stack Traces
Graphics/GUIs
Data Types

What do we want?
Concurrency
Multisubs/methods
Metaprogramming
Applications***
Exceptions
Core Stack Traces
Graphics/GUIs
Data Types ← ← ← ← ← ← ←

perldoc –f my
my VARLIST
my TYPE VARLIST
my VARLIST : ATTRS
my TYPE VARLIST : ATTRS
A "my" declares the listed variables to be
local (lexically) to the enclosing block,
file, or "eval". If more than one variable
is listed, the list must be placed in …

Let’s Play
“Make
Believe”
… AND SEE WHAT
THAT GETS US.

Yes, please!
my INT @array = (4,5,6);
$array[1] = "foo"; # BOOM!

Cache::LRU
class Cache::LRU { # this example is NAÏVE!
use Hash::Ordered;
field $max_size :param :reader = 20;
method set( $key, $value ) {
$cache->unshift( $key, $value );
if ( $cache->keys > $max_size ) {
$cache->pop;
}
}
method get($key) {
return unless $cache->exists($key);
my $value = $cache->get($key);
return $value;
}
}
No data control

Cache::LRU
package Cache::LRU;
use Hash::Ordered;
sub new ( $class, $max_size ) {
bless {
cache => Hash::Ordered->new,
max_size => $max_size,
} => $class;
}
sub _cache ($self) { $self->{cache} }
sub max_size ($self) { $self->{max_size} }
sub set ( $self, $key, $value ) {
$self->_cache->unshift( $key, $value );
if ( $self->_cache->keys > $self->max_size ) {
$self->_cache->pop;
}
}
sub get ( $self, $key ) {
return unless $self->_cache->exists($key);
my $value = $self->_cache->get($key);
return $value;
}
No data control

Oops
What if we pass a reference for $max_size? if ($num_keys > $max_size) {...}
$cache->set( %value, $key ) silently succeeds.
$cache->get( %value ) fails for the wrong reasons

Boundaries
Fixed by checking your data.
You would never write code like that.
What about the people who use your code?

Let’s Dream
package Cache::LRU;
sub new (CLASS[Cache::LRU] $class, UINT $max_size) {
...
}
sub _cache ($self) { ... }
sub max_size (OBJ[Cache::LRU] $self) UINT { ... }
sub set (OBJ[Cache::LRU] $self, STR $key, DEF $value)
OBJ[Cache::LRU] | VOID
{
...
}
sub get(OBJ[Cache::LRU] $self, STR $key) !VOID {
...
}

Let’s Dream
package Cache::LRU;
sub new (CLASS[Cache::LRU] $class, PosInt $max_size) {
...
}
{
...
}
...
}

Let’s Dream
package Cache::LRU;
sub new (CLASS[Cache::LRU] $class, UINT $max_size) {
...
}
{
...
}
sub get(OBJ[Cache::LRU] $self, SRE $key) !VOID {
...
}

Let’s Dream
package Cache::LRU;
sub new (CLASS[Cache::LRU] $class, PosInt $max_size) {
...
}
sub max_size (OBJ[Cache::LRU] $self) PosInt { ... }
OBJ[Cache::LRU]|void
{
...
}
...
}

Let’s Dream
package Cache::LRU;
sub new ($class, UINT $max_size ) {
...
}
sub max_size ($self) { ... }
sub set ($self, STR $key, DEF $value){
...
}
sub get($self, STR $key) !VOID {
...
}

Let’s Dream
class Cache::LRU;
field $cache = HashOrdered->new;
field UINT $max_size :param = 20;
method set (STR $key, DEF $value){
...
}
method get(STR $key) !VOID {
...
}

Project Oshun WTF?

Oshun
Orisha (deity) of the Nigerian Yoruba
River deity. Fertility goddes:!s.
Depicted as protector, savior, or nurturer
https://www.britannica.com/topic/Oshun
Image CC by 3.0. Sailko, Candomblé nel Museu Afro-Brasileiro, Salvador

Oshun Will Protect Your Data

Ceçi n’est pas un type
“Computer scientists have discussions about type systems.
Computer programmers have screaming matches.”
–Ovid, 9 CE (±~2K years)

Rama, Cc-by-sa-2.0-fr

Oshun History
First pass was a December 23, 2022 gist
Followed by an email to Damian
“I am not competant to design a type system.” (Ovid)

PPC Process
Send pre-PPC email to P5P list
Summarize the problem
Present your solution
Get it summarily rejected with a “this should be a CPAN module
first.”

Oshun History
Damian’s first design arrived January 9, 2023
Months of discussion tweaking the design
Damian wrote Data::Checks

Data::Checks use Data::Checks;
sub total :returns(INT) ($times :of(UINT)) {
my $total :of(INT) = 0;
foreach my $i (1..$times) {
$total += get_result($i);
}
return $total;
}
Not on the CPAN!

Data::Checks
https://github.com/Ovid/oshun
Almost 200,000 tests
24 built-in types checks
User-defined checks specced but not implemented
Coercions specced but not implemented
Not on the CPAN!

Oshun Team
Branislav Zahradník (happy-barney)
Chris Prather (perigrin)
Curtis Poe (Ovid)
Dr. Damian Conway (thoughtstream)
Elvin Aslanov (rwp0)
Peter Mottram (syspete)
Dr. Ruud van Tol (druud)
Toby Inkster (tobyink)
Veesh Goldman (rabbiveesh)
Yves Orton (demerphq)
13 août 2023 COPYRIGHT 2022, HTTP://WWW.ALLAROUNDTHEWORLD.FR/

Why do we need this?
Safer code
Keep Perl 5.0’s Promise
Self-documenting

Summary
Corinna is partially implemented in Perl core
We’re going to have to relearn how we do OO
We might get data checks in the future

Questions?

Coming Soon - All Around the World

Recommended

Recommended

More Related Content

Similar to Coming Soon - All Around the World

Similar to Coming Soon - All Around the World (20)

More from Curtis Poe

More from Curtis Poe (20)

Recently uploaded

Recently uploaded (20)

Coming Soon - All Around the World

Editor's Notes