Simple Meta Object Programming / Simple Matter Of Programming

If you want to help SMOP, you can just take on one of the lowlevel S1P implementations and write it. If you have any questions ask ruoso or pmurias at #perl6 @ irc.freenode.org.

The Slides for the talk Perl 6 is just a SMOP are available, it introduces a bit of the reasoning behind SMOP. A newer version of the talk presented at YAPC::EU 2008 is available

SMOP is an alternative implementation of a C engine to run Perl 6. It is focused in getting the most pragmatic approach possible, but still focusing in being able to support all Perl 6 features. Its core resembles Perl 5 in some ways, and it differs from Parrot in many ways, including the fact that SMOP is not a Virtual Machine. SMOP is simply a runtime engine that happens to have a interpreter run loop.

The main difference between SMOP and Parrot (besides the not-being-a-vm thing), is that SMOP is from bottom-up an implementation of the Perl 6 OO features, in a way that SMOP should be able to do a full bootstrap of the Perl 6 type system. Parrot on the other hand have a much more static low-level implementation (the PMC)

The same way PGE is a project on top of Parrot, SMOP will need a grammar engine for itself.
SMOP is the implementation that is stressing the meta object protocol more than any other implementation, and so far that has been a very fruitful exercise, with Larry making many clarifications on the object system thanks to SMOP.

Important topics on SMOP

SMOP doesn't recurse in the C stack, and it doesn't actually define a mandatory paradigm (stack-based or register-based). SMOP has a Polymorphic Eval, that allows you to switch from one interpreter loop to another using Continuation Passing Style. See SMOP Stackless.

SMOP doesn't define a object system in its own. The only thing it defines is the concept of SMOP Responder Interface, which then encapsulates whatever object system. This feature is fundamental to implement the SMOP Native Types.

SMOP is intended to bootstrap itself from the low-level to the high-level. This is achieved by the fact that everything in SMOP is an Object. This way, even the low-level objects can be exposed to the high level runtime. See SMOP OO Bootstrap.

SMOP won't implement a parser in its own, it will use KindaPerl6 parser or whatever parser gets ported to its runtime first.

2008-09-07 - Daniel Ruoso

2008-09-01 - Daniel Ruoso

x.x.x - native int postfix:<++>

2008-08-27 - Daniel Ruoso

x.x.x - BindCaptureSignature implemented. This special signature should be used in s1p to simplify signature usage. The signature is :(|$_) and allows the actual signature to be generated as a prefixed code on the mold block....

2008-08-22 - Daniel Ruoso

x.x.x - pure prototype metaclass instance

2008-08-20 - Daniel Ruoso

x.x.x - Port code to Mold and use the defaultblocksignature.

2008-08-16 - Daniel Ruoso

x.x.x - Signature object.

x.x.x - Default block signature binds the capture to the inner scope.

2008-08-11 - Daniel Ruoso

x.x.x - LexicalScope is finished! Lookup works as expected, the tests pass. This is the first use of a singleton mold code that is reused several times in the same execution...

2008-08-07 - Daniel Ruoso

x.x.x - LexicalScope implementation, almost all features working only lookup is missing.

2008-08-04 - Daniel Ruoso

x.x.x - Make lowlevel method use a code object instead of a c callback function

2008-08-02 - Daniel Ruoso

0.2.3 - Low-level Attribute implementation (test passing)

2008-07-31 - Daniel Ruoso

x.x.x - Low-level attribute implemented (tests still failing)

x.x.x - Scalar no longer delegates the calls (that causes unexpected results with containers that supports other methods), the language operators should do the implicit FETCH calls when the value is used. This means that every object should support FETCH, even if it returns the object itself. STORE however is not mandatory, as you have read-only containers, and therefore read-only values.

2008-07-26 - Daniel Ruoso

x.x.x - Low-level Code implementation

2008-07-25 - Paweł Murias

x.x.x - Low-level Array implementation

x.x.x - Low-level Hash implementation

2008-07-25 - Daniel Ruoso

2008-07-24 - Daniel Ruoso

x.x.x - p6opaque refactoring almost finished. After much debate the final p6opaque format is documented in SMOP p6opaque Implementation. Metaclass delegation is already working again. Now p6opaque uses directly Scalars, Hashes and Arrays instead of a lowlevel implementation of that. This is indeed much simpler (pmurias++ for pushing in that direction)

x.x.x - ___NATIVE_CAPTURE_ONLY___, ___CONST_IDENTIFIER_ONLY___ and ___INVOCANT_RI_SHOULD_MATCH___ are C macros that do some sanity checking on the lowlevel invocation.

x.x.x - p6opaque_proto_storage completed!

x.x.x - accessor for every member of p6opaque implemented.

2008-07-18 - Daniel Ruoso

x.x.x - Define yet another phase into the boot sequence for things that need a interpreter instance