Perl 6 is just a

Document Sample
Perl 6 is just a Powered By Docstoc
					     Perl 6 is just a SMOP


      Small Matter of Programming


    Simple Meta Object Programming




                   
    What is SMOP?




            
    Perl 6 is a pure OO language




          Everything is an object




                     
     SMOP is a pure OO runtime




     No special integers and string registers.
    No special vtables entries, just method calls




                          
       The ultimate truth in Perl 6
        Something is what
           it says it is
               Int $a = something()

    something might return a lowlevel optimized 
    object that implements some funky things, as 
         long as this object answers true to:

                   $a.^does(Int)
                         
              In the Low­Level



        Perl 6 doesn't assume the low­level 
    representation of the object, it always talks to 
      the object using the Meta­Object­Protocol




                           
    What is the Meta Object Protocol?




                    
    How is OO usually done?




     And why we don't do it that way




                    
         Usually, OO in the Low Level

    Method Call Arguments Structure:       Object Private Storage:
              positional 0                       Attributes:
              positional 1                           foo
              positional 2                           bar
                                                  Methods:
                                                     baz
                                                     buz




                      Invocation




                                        
         Usually, OO in the Low Level

    Method Call Arguments Structure:       Object Private Storage:
              positional 0                       Attributes:
              positional 1                           foo
              positional 2                           bar
                                                  Methods:
                                                     baz
                                                     buz




                      Invocation                 This structure is assumed
                                                 to be static.




                                        
         Usually, OO in the Low Level
This structure is assumed
to be static.

    Method Call Arguments Structure:       Object Private Storage:
              positional 0                       Attributes:
              positional 1                           foo
              positional 2                           bar
                                                  Methods:
                                                     baz
                                                     buz




                       Invocation                This structure is assumed
                                                 to be static.




                                        
         Usually, OO in the Low Level
This structure is assumed
to be static.

    Method Call Arguments Structure:              Object Private Storage:
              positional 0                              Attributes:
              positional 1                                  foo
              positional 2                                  bar
                                                         Methods:
                                                            baz
                                                            buz




                       Invocation                       This structure is assumed
                                                        to be static.



                            This process is assumed
                            to be static.    
    How do we do it then?


               
             This is the default




    object     RI    repr   metaclass




                       
             Responder interface




    An object has to be able to have methods called 
                on it, the rest is optional.




                            
        The representation object



    It decides what your objects are underneath.
    The representation objects can be the RI but 
            thats's an implementation detail.




                          
        The metaclass instance




       It desides how your object behaves.
    You like set_foo methods? It's your choice.




                         
                      In the Low­Level
                                          P5
                                                        P5
    P6Opaque           Glib             Blessed
                                                        SV*
                                        Hashref


                              Std                 P5          P5
               Java
                              C++                 HV*         AV*




                        META OBJECT PROTOCOL




                              INVOCATION


                                     
    Why do we do it that way?




                 
                    Flexibilty




    You can use the next cool OO thing, even if we 
                don't know about it yet




                           
                Interoperability




    Your objects can be Python ones underneath
     It should help with runtimes which aren't as 
                   tolerant as we are



                            
        my $candidate = $class.CREATE(:repr<PyDict>);
        $object = $class.bless($candidate, :k1($v1), :k2($v2))




                                 
                  Performance




    The optimiser may decide to make some of your 
      objects C structs or anything else it wants to




                            
    The gritty details


              
                     The Data Structures

                    A SMOP__Object has a SMOP__ResponderInterface


                                                 struct SMOP__ResponderInterface {
                                                          SMOP__ResponderInterface* RI,
    struct SMOP__Object {
                                                           void* data;
             SMOP__ResponderInterface* RI,
                                                           SMOP__Object* (*MESSAGE)...
              void* data;
                                                           SMOP__Object* (*REFERENCE)...
    }
                                                           SMOP__Object* (*RELEASE)...
                                                 }


                     A SMOP__ResponderInterface is a SMOP__Object




                                              
         The Message Dispatch



    SMOP_DISPATCH(interpreter,
                                 object,
                                  identifier,
                                  capture)



                               
                The Message Dispatch

    SMOP__Object*
                                                      SMOP__Object*

                                                          SMOP__Object*
          SMOP_DISPATCH(interpreter,
                                       object,             SMOP__Object*

                                        identifier,
                                                        SMOP__Object*
                                        capture)



                                     
            The Message Dispatch


    This is actually just a macro to a callback on the 
     Object's Responder Interface, passing all that 
                       as parameters.
    SMOP__Object* (*MESSAGE)   (SMOP__Object* interpreter,
                                SMOP__ResponderInterface* self,
                                SMOP__Object* identifier,
                                SMOP__Object* capture);




                                   
    Everything else builds on it




                  
      Polymorphic Eval




    We have multiple interpreters




                  
                           


    “My language is CPAN, the rest is just syntax”
                          ­­ audreyt

      Why would I want to interact with another 
       language if I couldn't interact with that 
             language's extensions?


                           
       How are we using it now?




    Switching the first quick and dirty interpreter 
     implementation to a quick and clean one 




                           
                  Mold




    Our newest interpreter implementation




                      
                  m0ld




    The DSL we use to represent bytecode, 
             something like PIR




                       
             Registers




    You can have as many as you like
      (they store SMOP__Object*)




                    
              Constants?




    Registers can have predefined values




                       
      Opcodes




    We have 4 of them




            
          Method Call




    $r4 = $r5.$r6($r7,$r8,:$r9($r10));




                     
          In bytecode




    1 4 5 6 2 7 8 1 9 10

                
    Call with explicit responder and capture




                $r4 = $r5.$r6(|$r7)




                         
     Goto




     goto label;




          
                     Br




     if $r1 {goto label2} else {goto label1}




                        
    We have 4, remember ;)




                
    As always the optimizer can cheat




                    
    What's the state of SMOP?




                 
    Questions?




          
        Perl 6 is just a 
           SMOP!
    We just need more 
        hands... :)
     http://www.perlfoundation.org/perl6/index.cgi?smop