What’s Marvin?

Marvin is a Self dialect which combines characteristics of Self 
programming language and Smalltalk-80.

What is the status of this project?

It’s bleeding edge. It’s not usable for practical use but there’s just 
a functional implementation which can compile end execute code.

Why new language?

Smalltalk isn’t suitable for prototype-based systems. It has no 
literals for objects and you have to use pseudo-variable "self" 
extremely frequently. Self programming language can be hardly 
integrated with Squeak.

In shortcut, Marvin is Self with Squeak literals and conventions. It’s 
integrated with Squeak environment.

Does Marvin have any special interpretation layer?

No, it is compiled directly to the native bytecodes of Squeak and 
executed by virtual machine.

Do I need any special version of virtual machine?

Yes, you need a virtual machine with enhanced sending mechanism.

What are the VM modifications?

Currently Marvin adds two new primitives for definition of prototype 
class and it modifies the sending and resending mechanism. If the 
receiver of message is the prototype class, VM uses another lookup 
algorithm based on delegation.

Is this special virtual machine slower?

Of course yes. This test consumes about 2% of speed now but after 
optimalization there may be only one additional comparison of two 
integer values. So there will be no relevant slowdown.

What’s the prototype class?

Instances of this class (MarvinPrototype) are prototypes – objects 
with slots. Prototypes have no instance variables.

How delegation works?

When you send a message to a prototype, it seeks through its slots and 
if it finds matching slot, it does due operation – read/write value of 
slot or calls compiled method stored in slot. If no matching slot is 
found, this process continues with objects referenced by parent slots.

What’s the physical structure of prototype?

In fact, prototype has indexable pointer variables (like Array). It 
has four sections of slots and every section is separated by nil. 
Every slot takes 1-3 elements in dependence on slot type:

method slot:

- take 2 elements
- the first element is a reference to method selector (like #method)
- the second element is reference to compiled method
- if sent message selector reference is same as the first element, the 
  compiled method is executed

writeable data slot

- take 3 elements
- the first element is reference to read message selector (like 
  #variable)
- the second element is reference to write message selector (like 
  #variable:)
- the third element is reference to slot value
- if sent message selector is same as the first element, the result of 
  message send is the third value
- if sent message selector is same as the second element, VM takes the 
  argument from stack and stores it into the third element

read-only data slot

- has the same structure as writable data slot.
- the second element refers the same object as the first element (read 
  message selector)

parent slot

- can be read-only or writeable
- has the same structure as data slots (3 elements)

The order of slots is:

- parent slots
- method slots
- data slots
- indexable slots

For example, the Selfs object

( |
parent* = lobby.
method = ( 3+4).
x <- 5.
y = nil.
| )

contains an array of references to this objects:

01: symbol #parent
02: symbol #parent
03: object lobby
04: nil (separator)
05: symbol #method
06: complied method
07: nil (separator)
08: symbol #x
09: symbol #x:
10: number 5
11: symbol #y
12: symbol #y
13: nil (value)
14: nil (separator)

Prototype with no slots is an array with three nils.

Why read-write data and parent slots contain both selectors and not 
only the slot name?

It’s speed optimalization. Virtual machine can simply compare only 
references to selectors and it doesn’t have to concatenate strings and 
compare them.

Why read-only data and parent slots don’t take only 2 elements - slot 
name and value?

We don’t have to establish next two types of slots and every type of 
slots has fixed size.

What are the indexable slots?

The delegation lookup stops at the third separator (nil). The rest of 
prototype can contain arbitrary references. Prototypes so can be used 
as collections. The only disadvantage is that we don’t know index of 
the first element and we have to sequentially find the position of the 
last separator.

Can we create prototypes without Marvin compiler?

Yes, it can be build directly from an array.

p := MarvinPrototype withAll: #( nil nil #x #x: 56 nil).
p x --> 56
p x: 42.
p x --> 42

Or you may use this way:

p := MarvinPrototype new.
p AddAssignSlot: #x value: 56.

Can prototypes refer standard Smalltalk methods?

Yes with one limitation. You may use something like:

lobby := MarvinPrototype new.

lobby AddMethodSlot: #slotNotFound: value: (MarvinPrototype class >> 
#lobbyDNU:).

but if this compiled method contains super send, you have to put 
reference to the method owner prototype as the last literal (it’s 
method holder class in Smalltalk).

Why I have to specify owner of the compiled method?

Because virtual machine modifies super sends too. When the receiver is 
the prototype class, the super send bytecodes are interpreted as 
resends.

What’s resend?

It’s modified delegation send. The lookup doesn’t start from the 
receiver slots but from parents of object in which the executed method 
is defined.

Does Marvin have temporary variables in methods and blocks?

No, it uses slots like Self, so if we have this Smalltalk method

sum
| a b |
a := 3.
b := 4.
^ a + b

Marvin’s equivalent method slot is:

sum = ( | a. b |
a: 3.
b: 4.
^ a + b )

However local slots of methods and blocks are simulated by temporary 
variables.

Self methods return result of the last expression implicitly. Why 
there’s an explicit return here?

That’s because Marvin uses Squeak conventions for methods and blocks. 
Methods return receiver implicitly and block return result of the last 
expression or nil (if they are empty).

Can you specify a value of local slots of blocks and methods in 
definition?

Yes, the previous example can look like:

sum = ( | a = [3]. b = [4] |
^ a + b )

Why this ugly square brackets?

If you specify slot value in Self, the assigned expression is 
evaluated in compile time in context of lobby so if you create this 
object:

( | slot = self | )

it contains one slot, named “slot” with object lobby! Square brackets 
separate it visually.

Square brackets also help to have unambiguous grammar.

In current version the slot can contain only a result of single 
expression (like in Self), but in the next versions it will be whole 
expression sequence (including slot definition).

Ok, but is it readable if you write object literals?

No. Look at this example (delegation demonstration, the result is 10).

(|
parent* = [ (|
a = [6]
|) ].
a = [3].
b = [4].
sum = ( ^ resend a + b)
|) sum

Maybe we will include some syntactical shortcut for sequence of three 
characters [ ( | .

Can I use a block in slot value?

Yes, you can. An example:

(|
sum = [[ |:a. :b | a + b ]].
test = ( ^ sum value: 3 value: 4 )
|) test

Notice that this construction fails in Self because the block in slot 
expires after compilation.

How methods with arguments are defined?

Unlike Self, Marvin has only one way how to define methods 
(Smalltalk’s way)

(|
a = [3].
sum: b = ( ^ a + b )
|) sum: 4

Can objects contain code?

No, only blocks and methods can contain code (like in Self)

Can methods use methods?

No, nested methods are forbidden (like in Self)

Can methods and blocks contain parent slots?

No, unlike Self. Marvin uses standard Squeak blocks and it has no 
activation objects (parent slots are added to activation objects in 
Self). But it’s not important limitation.

Are there any special naming conventions for slot names (methods)?

Marvin is fully integrated with Squeak so it has to use Squeak naming 
conventions. So it uses ifTrue:ifFalse and not ifTrue:False: etc. The 
only convention it uses is that names of primitive methods begin with 
capital letter.

Does Marvin have literals for characters, arrays etc.?

Yes, Marvin uses all Squeak literals except scaled decimals and 
expression arrays. Both will be added in next versions. Marvin creates 
these literals as standard Smalltalk objects.

Does Marvin have its own class for blocks?

No, even block are standard Smalltalk objects so you can use all its 
capabilities like multitasking.

(|
parent* = [ lobby ].
test = (
| number = [50]. result |
[
result: number factorial.
inform: result asString
] forkAt: Processor userBackgroundPriority )
|) test

Does Marvin have object and slots annotations like Self?

No, it hasn’t. It would be problematic for implementation and it may 
be simply replaced with more general annotation protocol analogous to 
class organizations. It’s not important to support it in grammar.

Does Marvin have primitive methods?

If there’s no matching slot found during delegation, virtual machine 
tries to find method in prototype class (like in any other Smalltalk 
object). That’s why prototypes are very familiar with Squeak and you 
can print them, explore them etc.

Marvin doesn’t need classical primitive methods like Smalltalk because 
it can use standard Squeak infrastructure.

Can I use Squeak classes in Marvin programs?

Yes, if you wish. If your object has lobby as its parent, it can 
access to global objects in Smalltalk system dictionary.

Can I use standard Smalltalk objects and classes as parents of 
prototypes.

It’s very problematic operation. We may theoretically delegate 
Smalltalk classes but only in case it has no instance variables. The 
current implementation tries only to resend messages to standard 
objects referred by parent slots, but this operation even doesn’t work 
well.

It’s maybe the most limiting aspect of Marvin’s design.

Are comments in Marvin the same as comments in Smalltalk and Self?

Marvin uses standard comments. Moreover its lexical analyzer supports 
line comments (something like // in C++). They start with doubled 
quotation marks.

(|
a = [3]. "" line comment
b <- [4]. "block comment"
|)

Can I use Unicode?

Yes, when you use Squeak 3.8 you can write non-ASCII characters in 
string literals, comments etc. You cannot use Unicode in identifiers 
(unlike Squeak).

Does Marvin full tree search during delegation?

No, it doesn’t. Unlike Self. Marvin doesn’t check ambiguous calls and 
use only simple Depth First Search algorithm. It depends on parent 
slots order. However thanks this property Marvin is more flexible in 
redefinition of namespaces.

What are the benefits of Marvin?

It brings the power of classless programming in Squeak in the form, 
which can be very familiar to current Squeakers and can combine the 
main advantages of Squeak and Self in one compact system.

Squeak gets multiple inheritance, dynamic inheritance, namespaces, 
mixins etc. It can be very useful especially for UI projects like 
eToys.

Is there any outliner?

No, still isn’t. Now you can only evaluate code (directly or using 
SmaCC GUI)

Is there any decompiler and debugger?

No, it isn’t.

Are examples in this document runable?

Yes, they are.

Can we see any more advanced example?

Yes, this example (http://www.comtalk.net/Squeak/95) shows how modules 
can be implemented in Marvin. There are two separated parts of 
demonstration system – application and kernel. Application asks kernel 
if it can load a module (the set of traits and globals) and the 
kernels loads a copy of module into the application’s lobby. So 
application has its own namespace and can make modifications of its 
modules without effect on the kernel or other applications. It’s a 
kind of sandbox.

Where can I find sources?

Here: http://www.comtalk.net/Squeak/95

Is there any prepared virtual machine?

Yes, but only for Windows, sorry. My attempts to build VM for Linux 
failed (I have Gentoo on amd64).

What if I want to build VM for Linux?

Use standard build process using VMMaker. Marvin’s VM for Windows uses 
older version of VMMaker than the Linux versions so be sure all 
Marvin’s modifications are compatible with your version. If you 
success, please publish binaries.

Known problems?

I don’t know any part of current implementation which isn’t 
problematic :-)

Your help is needed!

-- Pavel Krivanek