Object Meta Programming

YAPC::EU::2007

Aug 29, 2007

HAI FRENDS

My name is Yuval

Meta Programming

Introduction

Introduction

• Meta programming

Introduction

• Meta programming
• writing code which outputs or manipulates code

Many forms

Many forms

• string eval

Many forms

• string eval
• %::

Many forms

• string eval
• %::
• closure generators

Many forms

• string eval
• %::
• closure generators
• macros

Many forms

• string eval
• %::
• closure generators
• macros
• real macros

Many forms

• string eval
• %::
• closure generators
• macros
• real macros
• compilers

Many forms

Many forms

• Home grown snippets

Many forms

• Home grown snippets
• Home grown packages

Many forms

• Home grown snippets
• Home grown packages
• Stuff on the CPAN (e.g. Class::Accessor, Code::Perl)

Many forms

• Home grown snippets
• Home grown packages
• Stuff on the CPAN (e.g. Class::Accessor, Code::Perl)
• Large systems (Template::Toolkit)

Summary

• You should already know it
• You probably do it

Summary

• You should already know it
• You probably do it
• That's the intended audience anyway ;-)

Object Meta Programming

Object Meta Programming

Object Meta Programming

• Code that outputs or manipulates object oriented code

Object Meta Programming

• Code that outputs or manipulates object oriented code
• Often written in OO

Simple Examples

Simple Examples

• Class::Accessor, Class::InsideOut

Simple Examples

• Class::Accessor, Class::InsideOut
• Generates accessor methods

Simple Examples

• Class::Accessor, Class::InsideOut
• Generates accessor methods
• Class::Prototyped

Simple Examples

• Class::Accessor, Class::InsideOut
• Generates accessor methods
• Class::Prototyped
• Prototype object support in Perl

Simple Examples

• Class::Accessor, Class::InsideOut
• Generates accessor methods
• Class::Prototyped
• Prototype object support in Perl
• Lots of stuff on the CPAN

Modeling OO

Modeling OO

• High level object meta programming

Modeling OO

• High level object meta programming
• The current trend

Modeling OO

• High level object meta programming
• The current trend
• The picture illustrates an object modelling with class =)

Modeling OO

• High level object meta programming
• The current trend
• The picture illustrates an object modelling with class =)
• Seriously though...

Modeling OO

• High level object meta programming
• What is a class?

Modeling OO

• High level object meta programming
• What is a class?

  class Class {
    has @isa;
    has %methods;
    has %attributes;

    ...
  }

Modeling OO

Modeling OO

• Implementing OO

Modeling OO

• Implementing OO
• In OO

Modeling OO

• Implementing OO
• In OO
• Meta objects:

Modeling OO

• Implementing OO
• In OO
• Meta objects:
• Class

Modeling OO

• Implementing OO
• In OO
• Meta objects:
• Class
• Method

Modeling OO

• Implementing OO
• In OO
• Meta objects:
• Class
• Method
• Attribute

Example class

  class Point {
    has $x;
    has $y;

    method distance_to { ... }
  }

Modeled with objects

  Class->new(
    attributes => [
      Attribute->new( name => '$x' ),
      Attribute->new( name => '$y' ),
    ],
    methods => [
      Method->new(
        name       => "distance_to",
        definition => sub { ... }
      ),
    ],
  );

Metamodel Services

Metamodel Services

• Form

Metamodel Services

• Form
• Introspection/Reflection

Metamodel Services

• Form
• Introspection/Reflection
• Function

Metamodel Services

• Form
• Introspection/Reflection
• Function
• Class generation

Metamodel Services

• Form
• Introspection/Reflection
• Function
• Class generation
• Class transformation

Metamodel Services

• Form
• Introspection/Reflection
• Function
• Class generation
• Class transformation
• Pattern packaging

Case Study

Moose

Case Study

Moose

• A deep meta object system

Case Study

Moose

• A deep meta object system
• 4 layers deep

Case Study

Moose

• A deep meta object system
• 4 layers deep
• Syntactic sugar

Case Study

Moose

• A deep meta object system
• 4 layers deep
• Syntactic sugar
• Custom metaclasses

Case Study

Moose

• A deep meta object system
• 4 layers deep
• Syntactic sugar
• Custom metaclasses
• Class::MOP

Case Study

Moose

• A deep meta object system
• 4 layers deep
• Syntactic sugar
• Custom metaclasses
• Class::MOP
• Perl's native OO

Perl's native OO

Perl's native OO

• Minimalistic

Perl's native OO

• Minimalistic
• Class = Package = Symbol table hash
• Inheritence tree embedded in @ISA entry
• bless links data to a class
• ->

Perl's native OO

• Minimalistic
• Class = Package = Symbol table hash
• Inheritence tree embedded in @ISA entry
• bless links data to a class
• ->
• Insanely flexible

Perl's native OO

• Minimalistic
• Class = Package = Symbol table hash
• Inheritence tree embedded in @ISA entry
• bless links data to a class
• ->
• Insanely flexible
• Pretty klunky

Perl's native OO

• Minimalistic
• Class = Package = Symbol table hash
• Inheritence tree embedded in @ISA entry
• bless links data to a class
• ->
• Insanely flexible
• Pretty klunky
• Written in C (not very accessible)

Class::MOP

Class::MOP

• port of CLOS, more or less

Class::MOP

• port of CLOS, more or less
• MOP = Meta Object Protocol

Class::MOP

Class::MOP

• Model

Class::MOP

• Model
• Class::MOP::Class
• Class::MOP::Method
• Class::MOP::Attribute

Class::MOP

• Model
• Class::MOP::Class
• Class::MOP::Method
• Class::MOP::Attribute
• Easy interface

Class::MOP

• Model
• Class::MOP::Class
• Class::MOP::Method
• Class::MOP::Attribute
• Easy interface
• Introspection

Class::MOP

• Model
• Class::MOP::Class
• Class::MOP::Method
• Class::MOP::Attribute
• Easy interface
• Introspection
• Transformation

Class::MOP

Class::MOP

• Can "parse" packages into meta objects

Class::MOP

• Can "parse" packages into meta objects
• Modifying the objects writes back to packages

Class::MOP

• Can "parse" packages into meta objects
• Modifying the objects writes back to packages
• Code generation

Class::MOP

• Can "parse" packages into meta objects
• Modifying the objects writes back to packages
• Code generation
• Accessors from attributes

Class::MOP

• Can "parse" packages into meta objects
• Modifying the objects writes back to packages
• Code generation
• Accessors from attributes
• Constructor from attributes

Class::MOP

• Can "parse" packages into meta objects
• Modifying the objects writes back to packages
• Code generation
• Accessors from attributes
• Constructor from attributes
• Method modifiers

Moose's custom metaclasses

Moose's custom metaclasses

• Subclasses of Class::MOP::Class et al

Moose's custom metaclasses

• Subclasses of Class::MOP::Class et al
• More fun features

Moose's custom metaclasses

• Subclasses of Class::MOP::Class et al
• More fun features
• Roles

Moose's custom metaclasses

• Subclasses of Class::MOP::Class et al
• More fun features
• Roles
• BUILD etc a la Perl 6

Moose's custom metaclasses

• Subclasses of Class::MOP::Class et al
• More fun features
• Roles
• BUILD etc a la Perl 6
• Type constraints

Moose sugar layer

Moose sugar layer

• Pseudo-declarative syntax

Moose sugar layer

• Pseudo-declarative syntax
• Maps to metaclass manipulations

Moose sugar layer

• Pseudo-declarative syntax
• Maps to metaclass manipulations

  has foo => ( is => "rw" );

Moose sugar layer

• Pseudo-declarative syntax
• Maps to metaclass manipulations

  has foo => ( is => "rw" );

• becomes

Moose sugar layer

• Pseudo-declarative syntax
• Maps to metaclass manipulations

  has foo => ( is => "rw" );

• becomes

  $metaclass->add_attribute(
    Moose::Meta::Attribute->new(
      foo => ( is => "rw" ),
    )
  );

Moose vs. Class::Accessor

Moose vs. Class::Accessor

• All that bloat just for the has syntax?

Moose vs. Class::Accessor

• All that bloat just for the has syntax?
• NO!

Moose vs. Class::Accessor

• All that bloat just for the has syntax?
• NO!
• Pattern packaging

MooseX::

MooseX::

• Packaged meta code

MooseX::

• Packaged meta code
• Pretty clean

MooseX::

• Packaged meta code
• Pretty clean
• Mostly composable

MooseX::

MooseX::

• MooseX::Storage

MooseX::

• MooseX::Storage
• Customizable serialization through metaprogramming

MooseX::

• MooseX::Storage
• Customizable serialization through metaprogramming
• MooseX::AttributeHelpers

MooseX::

• MooseX::Storage
• Customizable serialization through metaprogramming
• MooseX::AttributeHelpers
• Additional methods for collection type attributes

MooseX::

• MooseX::Storage
• Customizable serialization through metaprogramming
• MooseX::AttributeHelpers
• Additional methods for collection type attributes
• MooseX::Getopt

MooseX::

• MooseX::Storage
• Customizable serialization through metaprogramming
• MooseX::AttributeHelpers
• Additional methods for collection type attributes
• MooseX::Getopt
• Additional constructor compiles attributes into a Getopt spec

MooseX::

• MooseX::Storage
• Customizable serialization through metaprogramming
• MooseX::AttributeHelpers
• Additional methods for collection type attributes
• MooseX::Getopt
• Additional constructor compiles attributes into a Getopt spec
• MooseX::IOC

MooseX::

• MooseX::Storage
• Customizable serialization through metaprogramming
• MooseX::AttributeHelpers
• Additional methods for collection type attributes
• MooseX::Getopt
• Additional constructor compiles attributes into a Getopt spec
• MooseX::IOC
• Inversion of control integrated into the object system

The point of Moose

The point of Moose

• OO is less tedious

The point of Moose

• OO is less tedious
• Helps you write meta code

The point of Moose

• OO is less tedious
• Helps you write meta code
• Good APIs promote clean code

The point of Moose

• OO is less tedious
• Helps you write meta code
• Good APIs promote clean code
• Easier to build on existing base

The point of Moose

• OO is less tedious
• Helps you write meta code
• Good APIs promote clean code
• Easier to build on existing base
• Conventions and structure let you play well with others (MooseX::)

The point of Moose

• OO is less tedious
• Helps you write meta code
• Good APIs promote clean code
• Easier to build on existing base
• Conventions and structure let you play well with others (MooseX::)
• Introspectable & tranformable metamodel

Another Case Study

ORMs

Another Case Study

ORMs

• Are HARD

Another Case Study

ORMs

• Are HARD
• Not even fun like the picture

ORMs

ORMs

• Modeling

ORMs

• Modeling
• Tables <-> Classes

ORMs

• Modeling
• Tables <-> Classes
• Fields <-> Attributes

ORMs

• Modeling
• Tables <-> Classes
• Fields <-> Attributes
• Code Generation

ORMs

• Modeling
• Tables <-> Classes
• Fields <-> Attributes
• Code Generation
• SQL

ORMs

• Modeling
• Tables <-> Classes
• Fields <-> Attributes
• Code Generation
• SQL
• Accessors

ORMs

• Modeling
• Tables <-> Classes
• Fields <-> Attributes
• Code Generation
• SQL
• Accessors
• Relationship fetchers

Class::DBI

Class::DBI

• Meta code is in the base class

Class::DBI

• Meta code is in the base class
• No clear schema modelling

Class::DBI

• Meta code is in the base class
• No clear schema modelling
• No separation between regular & meta code

Class::DBI

• Meta code is in the base class
• No clear schema modelling
• No separation between regular & meta code
• Lots of hacks

Class::DBI

• Meta code is in the base class
• No clear schema modelling
• No separation between regular & meta code
• Lots of hacks
• Don't go there

DBIx::Class

DBIx::Class

• Meta enlightened

DBIx::Class

• Meta enlightened
• Schema objects fully model the SQL side

DBIx::Class

• Meta enlightened
• Schema objects fully model the SQL side
• ResultSource etc partially model the OO side

DBIx::Class

• Meta enlightened
• Schema objects fully model the SQL side
• ResultSource etc partially model the OO side
• Components for everything

DBIx::Class

DBIx::Class

• Meta code:

DBIx::Class

• Meta code:
• Proxy objects

DBIx::Class

• Meta code:
• Proxy objects
• Accessors

DBIx::Class

• Meta code:
• Proxy objects
• Accessors
• Code generation (SQL, Perl)

ORM related meta programming

ORM related meta programming

• Complex

ORM related meta programming

• Complex
• But manageable

Vaporware

MO

MO

• My baby

MO

• My baby
• Moose spinoff

MO

• My baby
• Moose spinoff
• Stevan says it's Moose 2.0's

MO

• My baby
• Moose spinoff
• Stevan says it's Moose 2.0's
• Perl 5 & Haskell (in pugs)

MO Sucks

MO Sucks

• Experimental code

MO Sucks

• Experimental code
• Boring parts messy or unwritten

MO Sucks

• Experimental code
• Boring parts messy or unwritten
• Lacking integration, sugar layer

MO Sucks

• Experimental code
• Boring parts messy or unwritten
• Lacking integration, sugar layer
• mst promised to help ;-)

MO Sucks

• Experimental code
• Boring parts messy or unwritten
• Lacking integration, sugar layer
• mst promised to help ;-)
• Some parts slow as $*!&%

MO Rocks

MO Rocks

• Purely functional

MO Rocks

• Purely functional
• Very suited for meta transformations

MO Rocks

• Purely functional
• Very suited for meta transformations
• Fine grained control over everything

MO Rocks

• Purely functional
• Very suited for meta transformations
• Fine grained control over everything
• Can introduce entirely new conceptions of OO

MO Architechture

MO Architechture

• Modeling layer

MO Architechture

• Modeling layer
• Corresponds to compilation

MO Architechture

• Modeling layer
• Corresponds to compilation
• Responder layer

MO Architechture

• Modeling layer
• Corresponds to compilation
• Responder layer
• Corresponds to runtime

MO Architechture

MO Architechture

• Compiler/sugar layer creates the modeling layer

MO Architechture

• Compiler/sugar layer creates the modeling layer
• Class objects are constructed, with all the details

MO Architechture

• Compiler/sugar layer creates the modeling layer
• Class objects are constructed, with all the details
• No meta calculations happen yet

MO Architechture

• Compiler/sugar layer creates the modeling layer
• Class objects are constructed, with all the details
• No meta calculations happen yet
• Modeling layer is "compiled" into responder layer

MO Architechture

• Compiler/sugar layer creates the modeling layer
• Class objects are constructed, with all the details
• No meta calculations happen yet
• Modeling layer is "compiled" into responder layer
• Can be done on demand or upfront

MO Architechture

• Compiler/sugar layer creates the modeling layer
• Class objects are constructed, with all the details
• No meta calculations happen yet
• Modeling layer is "compiled" into responder layer
• Can be done on demand or upfront
• Obscurely named objects

MO Architechture

• Compiler/sugar layer creates the modeling layer
• Class objects are constructed, with all the details
• No meta calculations happen yet
• Modeling layer is "compiled" into responder layer
• Can be done on demand or upfront
• Obscurely named objects
• Bear with me

"Concepts"

"Concepts"

• The purest form of OO is prototypes

"Concepts"

• The purest form of OO is prototypes
• prototype OO can implement class OO

"Concepts"

• The purest form of OO is prototypes
• prototype OO can implement class OO
• Concepts are new ways to express objects

"Concepts"

• The purest form of OO is prototypes
• prototype OO can implement class OO
• Concepts are new ways to express objects
• A class is a concept

"Concepts"

• The purest form of OO is prototypes
• prototype OO can implement class OO
• Concepts are new ways to express objects
• A class is a concept
• A role is a concept

"Responder Interfaces"

"Responder Interfaces"

• $ri->dispatch( $responder, $invocation )

"Responder Interfaces"

• $ri->dispatch( $responder, $invocation )
• Generated from concepts

"Responder Interfaces"

• $ri->dispatch( $responder, $invocation )
• Generated from concepts
• Abstract VTable

"Responder Interfaces"

• $ri->dispatch( $responder, $invocation )
• Generated from concepts
• Abstract VTable
• The flattened method hierarchy

"Responder Interfaces"

• $ri->dispatch( $responder, $invocation )
• Generated from concepts
• Abstract VTable
• The flattened method hierarchy
• ... or something completely different

"Responder Interfaces"

• $ri->dispatch( $responder, $invocation )
• Generated from concepts
• Abstract VTable
• The flattened method hierarchy
• ... or something completely different
• Performance

"Responder Interfaces"

• $ri->dispatch( $responder, $invocation )
• Generated from concepts
• Abstract VTable
• The flattened method hierarchy
• ... or something completely different
• Performance
• Flexibility

"Responders"

"Responders"

• Something that is the subject of invocations

"Responders"

• Something that is the subject of invocations
• An object instance

"Responders"

• Something that is the subject of invocations
• An object instance
• A class (class methods)

"Responders"

• Something that is the subject of invocations
• An object instance
• A class (class methods)
• A simple tuple ( $data, $ri )

"Invocations"

"Invocations"

• A method call, multimethod, message... whatever

"Invocations"

• A method call, multimethod, message... whatever
• Arguments, too

"Invocations"

• A method call, multimethod, message... whatever
• Arguments, too
• Whatever an RI will put up with

"Invocations"

• A method call, multimethod, message... whatever
• Arguments, too
• Whatever an RI will put up with
• Extensible calling semantics

MO compilation flow

MO compilation flow

• Instantiate a Class object

MO compilation flow

• Instantiate a Class object
• Specify members (methods, attributes)

MO compilation flow

• Instantiate a Class object
• Specify members (methods, attributes)
• ... and ancestor classes & roles

MO compilation flow

• Instantiate a Class object
• Specify members (methods, attributes)
• ... and ancestor classes & roles
• Compile class

MO compilation flow

• Instantiate a Class object
• Specify members (methods, attributes)
• ... and ancestor classes & roles
• Compile class
• my $class_methods_ri = $class->class_interface()

MO compilation flow

• Instantiate a Class object
• Specify members (methods, attributes)
• ... and ancestor classes & roles
• Compile class
• my $class_methods_ri = $class->class_interface()
• Instance method RI closed in the constructor, within $ri

MO compilation flow

• Instantiate a Class object
• Specify members (methods, attributes)
• ... and ancestor classes & roles
• Compile class
• my $class_methods_ri = $class->class_interface()
• Instance method RI closed in the constructor, within $ri
• Purely functional operation

RI composition

RI composition

• Compute instance methods and attributes from ancestry

RI composition

• Compute instance methods and attributes from ancestry
• Compute instance slots from attributes

RI composition

• Compute instance methods and attributes from ancestry
• Compute instance slots from attributes
• Generate accessors

RI composition

• Compute instance methods and attributes from ancestry
• Compute instance slots from attributes
• Generate accessors

  MO::Run::ResponderInterface::MethodTable->new(
    methods => %methods
  );

RI composition

• Compute instance methods and attributes from ancestry
• Compute instance slots from attributes
• Generate accessors

  MO::Run::ResponderInterface::MethodTable->new(
    methods => %methods
  );

• Generate constructor

RI composition

• Compute instance methods and attributes from ancestry
• Compute instance slots from attributes
• Generate accessors

  MO::Run::ResponderInterface::MethodTable->new(
    methods => %methods
  );

• Generate constructor

  sub {
    my $data = process_params(@_);
    return box( $data, $instance_ri );
  }

Instantiation

Instantiation

• Lookup RI using class name

Instantiation

• Lookup RI using class name
• Dispatch constructor class method

Instantiation

• Lookup RI using class name
• Dispatch constructor class method
• Compose data from params

Instantiation

• Lookup RI using class name
• Dispatch constructor class method
• Compose data from params
• Slightly complicated

Instantiation

• Lookup RI using class name
• Dispatch constructor class method
• Compose data from params
• Slightly complicated
• Link data with closed $instance_ri

Instantiation

• Lookup RI using class name
• Dispatch constructor class method
• Compose data from params
• Slightly complicated
• Link data with closed $instance_ri
• Responder == ( Data, RI )

Instantiation

• Lookup RI using class name
• Dispatch constructor class method
• Compose data from params
• Slightly complicated
• Link data with closed $instance_ri
• Responder == ( Data, RI )
• Like bless

Method calls

Method calls

• How to talk with your new object?

Method calls

• How to talk with your new object?

  my $ri = $responder->responder_interface;

Method calls

• How to talk with your new object?

  my $ri = $responder->responder_interface;


  my $method = MO::Run::Invocation::Method->new(
    name      => "foo"
    arguments => \@blah,
  );

Method calls

• How to talk with your new object?

  my $ri = $responder->responder_interface;


  my $method = MO::Run::Invocation::Method->new(
    name      => "foo"
    arguments => \@blah,
  );


  $ri->dispatch( $responder, $method );

Method calls

• How to talk with your new object?

  my $ri = $responder->responder_interface;


  my $method = MO::Run::Invocation::Method->new(
    name      => "foo"
    arguments => \@blah,
  );


  $ri->dispatch( $responder, $method );

• Arbitrary responder interfaces also allowed

Method calls

• How to talk with your new object?

  my $ri = $responder->responder_interface;


  my $method = MO::Run::Invocation::Method->new(
    name      => "foo"
    arguments => \@blah,
  );


  $ri->dispatch( $responder, $method );

• Arbitrary responder interfaces also allowed
• Doesn't have to be $responder->responder_interface

OH NOES!!!

OH NOES!!!

• What's wrong with the previous slide?

OH NOES!!!

• What's wrong with the previous slide?
• RIs are objects too!

OH NOES!!!

• What's wrong with the previous slide?
• RIs are objects too!
• Need to bootstrap method calls

OH NOES!!!

• What's wrong with the previous slide?
• RIs are objects too!
• Need to bootstrap method calls
• Runtime must bootstrap low level OO

OH NOES!!!

• What's wrong with the previous slide?
• RIs are objects too!
• Need to bootstrap method calls
• Runtime must bootstrap low level OO
• More on this soon

Meta level polymorphism

Meta level polymorphism

• An important point

Meta level polymorphism

• An important point
• In fact, the point of MO

Meta level polymorphism

• An important point
• In fact, the point of MO
• Responder interfaces are polymorphic

Meta level polymorphism

• An important point
• In fact, the point of MO
• Responder interfaces are polymorphic
• Method table, network proxy, whatever

Meta level polymorphism

• An important point
• In fact, the point of MO
• Responder interfaces are polymorphic
• Method table, network proxy, whatever
• Easy to specialize

Meta level polymorphism

• An important point
• In fact, the point of MO
• Responder interfaces are polymorphic
• Method table, network proxy, whatever
• Easy to specialize
• Optimizations

Meta level polymorphism

• An important point
• In fact, the point of MO
• Responder interfaces are polymorphic
• Method table, network proxy, whatever
• Easy to specialize
• Optimizations
• Strange features

Meta level polymorphism

• An important point
• In fact, the point of MO
• Responder interfaces are polymorphic
• Method table, network proxy, whatever
• Easy to specialize
• Optimizations
• Strange features
• Easy to mix several OO systems

Meta level polymorphism

• An important point
• In fact, the point of MO
• Responder interfaces are polymorphic
• Method table, network proxy, whatever
• Easy to specialize
• Optimizations
• Strange features
• Easy to mix several OO systems
• Just compile to separate RIs

MO in Perl 5

MO in Perl 5

• Two runtimes

MO in Perl 5

• Two runtimes
• Very different

MO in Perl 5

• Two runtimes
• Very different
• MO::Run::Aux wraps both

MO in Perl 5

• Two runtimes
• Very different
• MO::Run::Aux wraps both
• Share tests by running with different %ENV var

Hosted runtime

Hosted runtime

• Nested object system

Hosted runtime

• Nested object system
• Bootstraps with Perl 5

Hosted runtime

• Nested object system
• Bootstraps with Perl 5
• Native Perl OO == Low level, like VM opcodes

Hosted runtime

• Nested object system
• Bootstraps with Perl 5
• Native Perl OO == Low level, like VM opcodes
• Virtualized MO == High Level

Hosted runtime

• Nested object system
• Bootstraps with Perl 5
• Native Perl OO == Low level, like VM opcodes
• Virtualized MO == High Level
• Completely separate levels

Hosted runtime

• Nested object system
• Bootstraps with Perl 5
• Native Perl OO == Low level, like VM opcodes
• Virtualized MO == High Level
• Completely separate levels
• $ri->dispatch( $responder, $method )

Hosted runtime

• Nested object system
• Bootstraps with Perl 5
• Native Perl OO == Low level, like VM opcodes
• Virtualized MO == High Level
• Completely separate levels
• $ri->dispatch( $responder, $method )
• not $responder->$method()

Hosted runtime

• Nested object system
• Bootstraps with Perl 5
• Native Perl OO == Low level, like VM opcodes
• Virtualized MO == High Level
• Completely separate levels
• $ri->dispatch( $responder, $method )
• not $responder->$method()
• Full expressiveness

Hosted runtime

• Nested object system
• Bootstraps with Perl 5
• Native Perl OO == Low level, like VM opcodes
• Virtualized MO == High Level
• Completely separate levels
• $ri->dispatch( $responder, $method )
• not $responder->$method()
• Full expressiveness
• Slow, verbose

Native runtime

Native runtime

• Integrated object system

Native runtime

• Integrated object system
• RIs are compiled into packages

Native runtime

• Integrated object system
• RIs are compiled into packages
• Simple RIs are dissassembled and stuffed into the stash

Native runtime

• Integrated object system
• RIs are compiled into packages
• Simple RIs are dissassembled and stuffed into the stash
• Complex RIs use AUTOLOAD, delegating to the RI meta object

Native runtime

• Integrated object system
• RIs are compiled into packages
• Simple RIs are dissassembled and stuffed into the stash
• Complex RIs use AUTOLOAD, delegating to the RI meta object
• Only named method calls

Native runtime

• Integrated object system
• RIs are compiled into packages
• Simple RIs are dissassembled and stuffed into the stash
• Complex RIs use AUTOLOAD, delegating to the RI meta object
• Only named method calls
• No arbitrary call concepts

Native runtime

• Integrated object system
• RIs are compiled into packages
• Simple RIs are dissassembled and stuffed into the stash
• Complex RIs use AUTOLOAD, delegating to the RI meta object
• Only named method calls
• No arbitrary call concepts
• -> doesn't support anything else

Native runtime

• Integrated object system
• RIs are compiled into packages
• Simple RIs are dissassembled and stuffed into the stash
• Complex RIs use AUTOLOAD, delegating to the RI meta object
• Only named method calls
• No arbitrary call concepts
• -> doesn't support anything else
• As fast as "regular" Perl OO

Native runtime

• Integrated object system
• RIs are compiled into packages
• Simple RIs are dissassembled and stuffed into the stash
• Complex RIs use AUTOLOAD, delegating to the RI meta object
• Only named method calls
• No arbitrary call concepts
• -> doesn't support anything else
• As fast as "regular" Perl OO
• Even makes simple, standalone `.pmc`s

Perl 5 Runtimes

Perl 5 Runtimes

• Native

Perl 5 Runtimes

• Native
• Usable with regular Perl OO ☺

Perl 5 Runtimes

• Native
• Usable with regular Perl OO ☺
• Lacks arbitrary invocations ☹

Perl 5 Runtimes

• Native
• Usable with regular Perl OO ☺
• Lacks arbitrary invocations ☹
• Virtualized

Perl 5 Runtimes

• Native
• Usable with regular Perl OO ☺
• Lacks arbitrary invocations ☹
• Virtualized
• Feature complete ☺

Perl 5 Runtimes

• Native
• Usable with regular Perl OO ☺
• Lacks arbitrary invocations ☹
• Virtualized
• Feature complete ☺
• Doesn't integrate ☹

Perl 5 Runtimes

• Native
• Usable with regular Perl OO ☺
• Lacks arbitrary invocations ☹
• Virtualized
• Feature complete ☺
• Doesn't integrate ☹
• Slow ☹

Idealized MO toolchain

Idealized MO toolchain

• Compiler handles modeling

Idealized MO toolchain

• Compiler handles modeling
• Constructs meta objects at compile time

Idealized MO toolchain

• Compiler handles modeling
• Constructs meta objects at compile time
• VM Opcodes support standard RI

Idealized MO toolchain

• Compiler handles modeling
• Constructs meta objects at compile time
• VM Opcodes support standard RI
• Custom RIs are just objects

Idealized MO toolchain

• Compiler handles modeling
• Constructs meta objects at compile time
• VM Opcodes support standard RI
• Custom RIs are just objects
• Bootstrapped using standard runtime objects

Idealized MO toolchain

• Compiler handles modeling
• Constructs meta objects at compile time
• VM Opcodes support standard RI
• Custom RIs are just objects
• Bootstrapped using standard runtime objects
• Method table RI

Idealized MO toolchain

• Compiler handles modeling
• Constructs meta objects at compile time
• VM Opcodes support standard RI
• Custom RIs are just objects
• Bootstrapped using standard runtime objects
• Method table RI
• Named method invocation

Perl 6

Perl 6

• Perl 6 is the idealized MO toolchain

Perl 6

• Perl 6 is the idealized MO toolchain
• Can introduce syntax

Perl 6

• Perl 6 is the idealized MO toolchain
• Can introduce syntax
• Invocation types

Perl 6

• Perl 6 is the idealized MO toolchain
• Can introduce syntax
• Invocation types
• Concept declarations

Perl 6

• Perl 6 is the idealized MO toolchain
• Can introduce syntax
• Invocation types
• Concept declarations
• Implement bootstrap RIs in VM opcodes

Perl 6

• Perl 6 is the idealized MO toolchain
• Can introduce syntax
• Invocation types
• Concept declarations
• Implement bootstrap RIs in VM opcodes
• Pugs might be using MO

Perl 6

• Perl 6 is the idealized MO toolchain
• Can introduce syntax
• Invocation types
• Concept declarations
• Implement bootstrap RIs in VM opcodes
• Pugs might be using MO
• I'm not really sure

Perl 6

• Perl 6 is the idealized MO toolchain
• Can introduce syntax
• Invocation types
• Concept declarations
• Implement bootstrap RIs in VM opcodes
• Pugs might be using MO
• I'm not really sure
• It was ported a while ago

Introducing new concepts

Introducing new concepts

• Roles are the shit

Introducing new concepts

• Roles are the shit
• But what about next week's fad?

Introducing new concepts

• Roles are the shit
• But what about next week's fad?
• MO lets you introduce a new concept

Introducing new concepts

• Roles are the shit
• But what about next week's fad?
• MO lets you introduce a new concept
• Arbitrary at compile time

Introducing new concepts

• Roles are the shit
• But what about next week's fad?
• MO lets you introduce a new concept
• Arbitrary at compile time
• RI protocol at runtime

Example - Prototype Objects

Example - Prototype Objects

• One shared RI

  sub dispatch {
    my ( $object, $invocation ) = @_;

    my $method = $object->{ $invocation->name };

    $object->$method( $invocation->arguments );
  }

Example - Attribute Grammars

Example - Attribute Grammars

• Crazy stuff from the 1970s

Example - Attribute Grammars

• Crazy stuff from the 1970s
• Renewed interest in λ land

Example - Attribute Grammars

• Crazy stuff from the 1970s
• Renewed interest in λ land
• Was pretty easy in MO

Attribute Grammer Implementation

Attribute Grammer Implementation

• Introduce new concept objects

Attribute Grammer Implementation

• Introduce new concept objects
• Attribute Grammar

Attribute Grammer Implementation

• Introduce new concept objects
• Attribute Grammar
• Attribute Grammer Instance - one per AG per class

Attribute Grammer Implementation

• Introduce new concept objects
• Attribute Grammar
• Attribute Grammer Instance - one per AG per class
• Runtime specialized RI

Attribute Grammer Implementation

• Introduce new concept objects
• Attribute Grammar
• Attribute Grammer Instance - one per AG per class
• Runtime specialized RI
• Shadows any RI with additional context sensitive methods

Attribute Grammer Implementation

• Introduce new concept objects
• Attribute Grammar
• Attribute Grammer Instance - one per AG per class
• Runtime specialized RI
• Shadows any RI with additional context sensitive methods
• Additional runtime support code

MO TODO

MO TODO

• Write a sugar layer

MO TODO

• Write a sugar layer
• Make it fun to use

MO TODO

• Write a sugar layer
• Make it fun to use
• Tests

MO TODO

• Write a sugar layer
• Make it fun to use
• Tests
• Refactor the Class objects

MO TODO

• Write a sugar layer
• Make it fun to use
• Tests
• Refactor the Class objects
• Bloated example code

MO TODO

• Write a sugar layer
• Make it fun to use
• Tests
• Refactor the Class objects
• Bloated example code
• There are some patterns to extract

MO TODO

• Write a sugar layer
• Make it fun to use
• Tests
• Refactor the Class objects
• Bloated example code
• There are some patterns to extract
• Self hosting

Self Hosting

Self Hosting

• Easier to maintain MO written in Moose

Self Hosting

• Easier to maintain MO written in Moose
• Need to have clean syntax

Self Hosting

• Easier to maintain MO written in Moose
• Need to have clean syntax
• Stable .pmc compilation

Conclusion

Conclusion

• Meta code is awesome code

Conclusion

• Meta code is awesome code
• Especially my meta code ;-)

Conclusion

• Meta code is awesome code

Conclusion

• Meta code is awesome code
• Lets you program in new ways

Conclusion

• Meta code is awesome code
• Lets you program in new ways
• Helps you take care of your other code

Conclusion

• Meta code is awesome code
• Lets you program in new ways
• Helps you take care of your other code
• Meta code is important code

Conclusion

• Meta code is awesome code
• Lets you program in new ways
• Helps you take care of your other code
• Meta code is important code
• It can affect anything

Conclusion

• Meta code is awesome code
• Lets you program in new ways
• Helps you take care of your other code
• Meta code is important code
• It can affect anything
• Keep it minimalistic, and clearly defined

Conclusion

• Meta code is awesome code
• Lets you program in new ways
• Helps you take care of your other code
• Meta code is important code
• It can affect anything
• Keep it minimalistic, and clearly defined
• No spaghetti monsters

Conclusion

• Meta code is awesome code
• Lets you program in new ways
• Helps you take care of your other code
• Meta code is important code
• It can affect anything
• Keep it minimalistic, and clearly defined
• No spaghetti monsters
• Meta code can be simple

Conclusion

• Meta code is awesome code
• Lets you program in new ways
• Helps you take care of your other code
• Meta code is important code
• It can affect anything
• Keep it minimalistic, and clearly defined
• No spaghetti monsters
• Meta code can be simple
• Only complicated if you aren't careful

BIE FRENDS