Hiding behind the concrete syntax there is an abstract syntax which embodies all the important concepts without being distracted by sugar. A core concept is object method calling. The actual function is determined from the concrete type of the first argument. So the method call takes a list of objects from local names and returns a list of objects which are associated with local names. (a,b,c) = z.Function(x,y,z) The formal args of the function may end in @rest which causes extra args to be placed in a vector. Alternately a vector can be passed as @v. Maybe the list is just part of the concrete syntax. A function (like an object) has a set of internal names. A function call involves: Setting some internal names Executing the code retrieving some internal names. So it is like fn = New obj.method fn.a=b; fn.b=a; ... Call fn; p=fn.z; q=fn.y; Note that 'fn' is a concrete object and we know how to access the various feels directly - they are not accessor function. if/while/switch/etc become if/goto. If the given name is not false, control is tranferred to the label. A distinguished label effects 'return' Constants... get assigned names in the function preamble. Objects can be: refcounted - freed when refcount hits zero 'once' - copied when refcount would become 2. Also, objects can be dependant on some other object. In that case, references within the dependancy group are not counted, and references from outside effect the whole group. This is particularly useful when objects are attached to function calls