Rummaging in the clOOset

RUMMAGING IN THE CLOOSET
Curtis “Ovid” Poe
http://allaroundtheworld.fr/
9 juin 2021 Copyright 2020, http://www.allaroundtheworld.fr/

All Around The World
• Curtis “Ovid” Poe
• https://allaroundtheworld.fr/
• https://twitter.com/OvidPerl
• ovid@allroundtheworld.fr
↓

OO Trivia Night
• No grand proposals
• No serious points
• Miscellaneous OO trivia

Simula 67
Class Rectangle (Width, Height); Real Width, Height;
! Class with two parameters;
Begin
Real Area, Perimeter; ! Attributes;
Procedure Update; ! Methods (Can be Virtual);
Begin
Area := Width * Height;
Perimeter := 2*(Width + Height)
End of Update;
Boolean Procedure IsSquare;
IsSquare := Width=Height;
Update; ! Life of rectangle started at creation;
OutText("Rectangle created: "); OutFix(Width,2,6);
OutFix(Height,2,6); OutImage
End of Rectangle;
! http://staff.um.edu.mt/jskl1/talk.html#Classes

Simula 67
• Classes
• Polymorphism
• Encapsulation
• Inheritance

Smalltalk!

Smalltalk
“Making simple things very simple and complex
things very possible”— Alan Kay
Via Dr. Stéphane Ducasse
http://scg.unibe.ch/archive/lectures/DucasseLectures/Duca00y1SmalltalkLectures.pdf

Syntax on a Postcard
exampleWithNumber: x
|y|
true & false not & (nil isNil) ifFalse: [self halt].
y := self size + super size.
#($a #a 'a' 1 1.0)
do: [:each | Transcript
show: (each class name);
show: (each printString);
show: ' '].
^ x < y

Smalltalk-80
• true
• false
• nil
• self
• super
• thisContext

Side Note: Lisp defined in Lisp
apply[fn;x;a] =
[atom[fn] → [eq[fn;CAR] → caar[x];
eq[fn;CDR] → cdar[x];
eq[fn;CONS] → cons[car[x];cadr[x]];
eq[fn;ATOM] → atom[car[x]];
eq[fn;EQ] → eq[car[x];cadr[x]];
T → apply[eval[fn;a];x;a]];
eq[car[fn];LAMBDA] → eval[caddr[fn]; pairlis[cadr[fn];x;a]];
eq[car[fn];LABEL] →
apply[caddr[fn];x;cons[cons[cadr[fn];caddr[fn]];a]]]
Lisp 1.5 Programmer's Manual, 1962. From page 13
http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf

No “if” in Smalltalk
result := a > b
ifTrue:[ 'greater' ]
ifFalse:[ 'less or equal' ]

Remember This Slide!
abstract class Boolean {
method ifTrue ($code) {}
method ifFalse ($code) {}
}
class True isa Boolean {
method ifTrue ($code) {$code->()}
}
class False isa Boolean {
method ifFalse ($code) {$code->()}
}

When I get bored writing slides …
class SuperPosition isa Boolean {
has $observed;
method ifTrue ($code) {
$observed //= 'true';
$code->() if 'true' eq $observed;
}
method ifFalse ($code) {
$observed //= 'false';
$code->() if 'false' eq $observed;
}
}

Inheritance!
Enough of the sideshow …

Inheritance
• class Customer isa Person {…}
• A more specialized version of the parent
• Liskov!

Barbara Liskov
Liskov Substitution Principle
Subtype Requirement: Let ϕ(x)
be a property provable about
objects x of type T.
Then ϕ(y) should be true for
objects y of type S where S is a
subtype of T.
Photo by Kenneth C. Zirkel
🤷🤷

Barbara Liskov
Liskov Substitution Principle
Any place you use a class, you
should be able to use its
subclasses.
Photo by Kenneth C. Zirkel
👍🤷

Liskov
# Assuming
class Customer isa Person { … }
# If this works
if ( $person->age('years') >= VOTING_AGE ) { … }
# The following must work
if ( $customer->age('years') >= VOTING_AGE ) { … }

INHERITANCE
What's Really Wrong With It?

Alan Kay
You're Doing It Wrong
• Invented the term “Object-
Oriented”
• Biological systems
• Inheritance was interesting
• Until the problem …
By Marcin Wichary from SF, U.S.A. -
Alan Kay, CC BY 2.0

Inheritance
class Invoice isa Person {
…
}

Inheritance (sucks)
• Software doesn’t understand intent
• We can’t enforce “subclass as specialization”
• Design by Contract (sort of) helps

Design by Contract
• Formal declaration of a class "contract"
• Preconditions
• Postconditions
• Invariants
• Subclasses can weaken preconditions
• Subclasses can strengthen postconditions and
invariants

DbC in Eiffel
put (x: ELEMENT; key: STRING) is
-- Insert x so that it can be retrieved via key.
require
count <= capacity
not key.empty
do
... Some insertion algorithm ...
ensure
has (x)
item (key) = x
count = old count + 1
end

DbC In Perl (many CPAN modules)
package ClassName
use Class::Contract;
contract {
inherits 'BaseClass';
attr 'data1';
attr 'data2' => HASH;
class attr 'shared' => SCALAR;
ctor 'new';
method 'methodname';
pre { ... }; failmsg 'Error message';
post { ... }; failmsg 'Error message';
impl { ... };
method 'nextmethod';
impl { ... };
class method 'sharedmeth';
impl { ... };
};

BETA Programming Language
Employee: (#
name: @ Text;
birthday: @ Date;
dept: ^ Department;
totalHours: @ Integer;
RegisterWork: (#
noOfHours: @ Integer
enter noOfHours
do noOfHours + totalhours → totalHours
#);
ComputeSalary:< (#
salary: @ integer
do inner
exit salary
#);
#)
https://beta.cs.au.dk/Papers/BetaOverview/BetaOverview.pdf

BETA Programming Language
Worker: Employee (#
seniority: @ integer;
ComputeSalary::< (#
do noOfHours * 80 + seniority * 4 → salary;
0 → totalHours
#)
#);
Salesperson: Employee (#
noOfSoldUnits: @ integer;
ComputeSalary::< (#
do noOfHours*80 + noOfSoldUnits * 6 → salary;
0 → noOfSoldUnits → totalHours
#)
#)

Beta Programming Language
Employee:(#
…
ComputeSalary:< (#
salary: @ integer
do inner
exit salary
#);
#)
Salesperson: Employee (#
noOfSoldUnits: @ integer;
ComputeSalary::< (#
do noOfHours * 80 + noOfSoldUnits * 6 → salary;
0 → noOfSoldUnits → totalHours
#)
#)

Moose
package Employee {
use Moose;
sub ComputeSalary {
my $salary = inner();
croak(…) if $salary < 0;
return $salary;
}
}
package Salesman {
use Moose;
extends 'Employee';
augment ComputeSalary => sub {
my $self = shift;
…
return $salary;
};
}

Back to Inheritance
• Multiple inheritance
• Single single inheritance
• Composition and delegation
• Interfaces
• Mixins
• Whatever the BETA designers were smoking …

Mixins
module Bomb
def explode
puts "Bomb Explode"
end
def fuse
puts "Bomb Fuse"
end
end
module Toddler
def explode
puts "Toddler Explode"
end
def fuse
puts "Toddler Fuse"
end
end

Mixins
class PracticalJoke
include Toddler
include Bomb
end
joke = PracticalJoke.new()
joke.fuse
joke.explode

Mixins
class PracticalJoke
include Toddler
include Bomb
end
joke = PracticalJoke.new()
joke.fuse
joke.explode
Bomb fuse
Bomb explode

Mixins
irb(main):026:0> PracticalJoke.ancestors
=> [PracticalJoke, Bomb, Toddler, Object, Kernel,
BasicObject]

Mixins
class Car < Vehicle
include Robot
…
end
• What happens if Vehicle and Robot both have a driver method?
• Robot wins (same is true of roles since we can't declare overrides)
• Is Robot really a more specialized version of Vehicle?

Mixins
• Should not make composition assumptions
• Thus, super should not be called (but it is)
• Should next::method be used in roles?

Computer Science
• Computer scientists argue
• Computer programmers rant

But Ovid …
• “It mostly works”
• “Easy to fix when it doesn’t”
• “Devs should know their code base”
(That last one really ticks me off)

Alan Kay
Human body has ~ 40 trillion cells

A Perfect Object

Web Browsers and Web Servers
• Browsers send messages
• Browser doesn't crash if server crashes
• Isolation, not encapsulation
• Well-defined, fault-tolerant protocol

Corinna v Perl v Python

InventoryItem (mutable!)
class InventoryItem:
def __init__(self, name, price, quantity):
self.name = name
self.unit_price = price
self.quantity_on_hand = quantity
def total_cost(self):
return self.unit_price * self.quantity_on_hand

InventoryItem (immutable)
package InventoryItem;
use strict;
use warnings;
sub new {
my ( $class, $name, $unit_price, $quantity_on_hand ) = @_;
return bless {
name => $name,
unit_price => $unit_price,
quantity_on_hand => $quantity_on_hand,
} => $class;
}
sub name { $_[0]->{name} }
sub unit_price { $_[0]->{unit_price} }
sub quantity_on_hand { $_[0]->{quantity_on_hand} }
sub total_cost {
my $self = shift;
return $self->{unit_price} * $self->{quantity_on_hand};
}
1;

class InventoryItem {
has $name :new :reader;
has $unit_price :new :reader;
has $quantity_on_hand :new :reader;
method total_cost() {
return $unit_price * $quantity_on_hand;
}
}

def __init__(self, name, price, quantity):
self.name = name
self.unit_price = price
self.quantity_on_hand = quantity
def total_cost(self):
item = InventoryItem('Foo', 3.5, 3)
print(item.total_cost())
item.price = 'bob'

from dataclasses import dataclass
@dataclass
name: str
unit_price: float
quantity_on_hand: int = 0
def total_cost(self) -> float:

@dataclass
name: str
unit_price: float
item = InventoryItem('Widget', 3.5, 3)
item.unit_price = 'bob'

@dataclass
name: str
unit_price: float
def assert_valid(self):
is_valid = True
for field_name, field_def in self.__dataclass_fields__.items():
actual_type = type(getattr(self, field_name))
if actual_type != field_def.type:
print(f"t{field_name}: '{actual_type}' instead of
'{field_def.type}'")
is_valid = False
if not is_valid:
raise ValueError("Type assertion failed");
self.assert_valid()

@dataclass(frozen=True)
name: str
unit_price: float
def __postinit__(self):
self.assert_valid
def assert_valid(self):
is_valid = True
for field_name, field_def in self.__dataclass_fields__.items():
actual_type = type(getattr(self, field_name))
if actual_type != field_def.type:
print(f"t{field_name}: '{actual_type}' instead of '{field_def.type}'")
is_valid = False
if not is_valid:
raise ValueError("Type assertion failed");

Solving This
• Pydantic—Runtime type validation
• mypy—Static type checker
• Pyright—Static type checker
https://pydantic-docs.helpmanual.io/
http://mypy-lang.org/
https://github.com/microsoft/pyright

Why Types?
•Correctness
• Performance
• Documentation

InventoryItem ☹️
class InventoryItem {
has $name :new :reader :isa(Str);
has $unit_price :new :reader :isa(Num);
has $quantity_on_hand :new :reader :isa(Int);
method total_cost() {
return $unit_price * $quantity_on_hand;
}
}

Why Not Types?
• Variable declarations
• Slot declarations
• Signatures

Why Not Types?
• my Int $foo;
• my $foo :Int;
• my $foo :isa(Int);
• has $foo :isa(Int);
• sub foo (Int $bar) {…}
• sub foo ($bar Int) {…}
• sub foo ($bar :isa(Int)) {…}
• sub foo ($bar :isa(Int)) :isa(Num) {…}

Lessons Learned
• Inheritance is a mess
• We need (but won't get) optional types
• Simple is beautiful
• "Good enough" isn't good enough

Changes to Corinna
• No :builder
• No CONSTRUCT/BUILDARGS
• ADJUST and DESTRUCT are phasers

:builder
class SomeClass {
has $x :builder;
method _build_x () { return rand; }
}
class AnotherClass {
method _build_x () { return "Surprise!" }
}

Possible Fixes?
# painful if your builder is complex
class SomeClass {
has $x :builder { return rand };
}
# we don't yet have private methods
class SomeClass {
has $x :builder;
private method _build_x () { return "Surprise" }
}

For now …
class SomeClass {
has $x;
ADJUST {
$x = rand;
}
}

For now …
class SomeClass {
has $x;
ADJUST {
$x = $self->_build_x;
}
method _build_x () { return rand; }
}

Phasers
class SomeClass {
my $num_instances = 0;
ADJUST { $num_instances++ }
DESTRUCT { $num_instances-- }
}

Phasers?
class SomeClass {
has $name :new;
CONSTRUCT ($class, @args) {
if (1 == @args) { unshift @args => 'name' }
return @args;
}
}

Alternate Constructors
class SomeClass {
has $name :new;
method from_name ($this_name) {
return $class->new( name => $this_name );
}
}
my $thing = SomeClass->from_name('Ovid');

Speaking of Constructors …
class Person {
has $name :new;
has $title :new(optional);
has $answer = 42;
method name () {
return defined $title
? "$title $name" : $name;
}
}

Ugly!
class Person {
has $name :new;
has $title :new(optional);
has $answer = 42;
method name () {
}
}

Simplified by Reusing Syntax
class Person {
has $name :new;
has $title :new = undef;
has $answer = 42;
method name () {
}
}

Abstract Methods
abstract method foo ();
• Less useful without types
• Compile-time or runtime?

How can we simplify this?
abstract class Shape {
abstract method area ();
abstract method perimeter ();
}

Abstract Methods == Abstract Class
class Shape {
abstract method area ();
abstract method perimeter ();
}

Forward Declarations!
class Shape {
method area ();
method perimeter ();
}

Roles!
role Shape {
method area ();
}
# versus
role Shape {
requires qw(area perimeter);
}

The Future?
class Shape {
method area ();
}
# later
my $foo = Shape->any_method; # boom

Remember Me?
abstract class Boolean {
method ifTrue ($code) {}
method ifFalse ($code) {}
}
class True isa Boolean {
method ifTrue ($code) {$code->()}
}
class False isa Boolean {
method ifFalse ($code) {$code->()}
}

$self and $class
common method baz () {
$class->quux;
}
method foo () {
$self->bar;
$class->baz;
}

Compile-Time Failure!
$self->quux;
}

Redefined Warnings
method foo () {
my $class = ref ($self) || $self;
$self->quux;
}
"my" variable $class masks earlier declaration in
same scope at …

And in the future?
$class->foo;
}
method foo () {
$self->bar;
$class->baz;
}

Quick Note On V1 Roles
• Might not have exclusion or aliasing
• Might not have method modifiers

Role Example
role Role::ToJSON {
use Cpanel::JSON::XS;
private method marshall_data ();
method to_json () {
my $data = $self->marshall_data;
return encode_json $data;
}
}

When?
• Curtis Poe—Ovid
• Corinna design
• Will create an RFC
• https://github.com/Perl/RFCs

When?
• Paul Evans—LeoNerd
• Object::Pad
• Future::AsyncAwait
• Syntax::Keyword::Try
• Much more

Summary
• This was trivia, not really informative
• What can we remove?
• What must we add?
• Lack of types is a problem

Thank You!

Rummaging in the clOOset

Recommended

Recommended

More Related Content

Similar to Rummaging in the clOOset

Similar to Rummaging in the clOOset (20)

More from Curtis Poe

More from Curtis Poe (17)

Recently uploaded

Recently uploaded (20)

Rummaging in the clOOset

Editor's Notes