Objects

Traditionally, objects encapsulate data which are processed by their methods. In reactive scripts we put the focus on behavioral aspects, and the task of defining and using variables and data is transferred to Java.

An object combines a body statement which is automatically executed at each instant, with attached methods which must be explicitly called to be executed. It has the syntax:

 
   object O
      body
   methods

      M1 ... Mn
   end

This statement defines an object O with attachedmethods M1 ... Mn, whose semantics is:

 
   do
       body

    || control run M1 by O-M1 
    || ... 
    || control run Mn by O-Mn
   until O-destroy

Event O-destroy is used to destroy the object; see below. Note that, as opposed to behavior declarations, objects are statements which are immediately run.

The syntax to call the method M of an object O is send M to O, and its semantics is simply generate O-M.

These semantics definitions have several consequences:

• Because of the control statement, a method M of O is given one reaction each time the statement send M to O is executed, and is not executed otherwise. Moreover, execution is immediate: once a method is called during a reaction, it runs during this reaction.
• The send command terminates immediately (as the generate statement), and does not wait for the called method to start to execute. It is a ``send and forget'' order in which the caller can immediately continue to execute (thus, this is an asynchronous call). Note that non-determinism can occur, as to send two orders in sequence during the same reaction does not prevent thesecond one to be processed before the first (see [1] for an example).
• Methods are ``one shot'': only the first call to a method is actual, the others having no effect (because generating the same event several times is equivalent to generating it once). The ``one shot'' property is important to prevent objects to enter into interblocking situations where, for example, two objects call each other for ever.

Objects are removed from the interpretor by destroying them, using the destroy command. The removal of an object does not prevent it to execute for the current reaction: the removal becomes effective only at the next reaction.

This presentation shows that objects and methods enter in a rather natural way into the broadcast event driven approach, although different in spirit from it as method calls are not broadcast but sent to precise targets. Reactive scripts give both ways of programming in an unified framework.

In this paper we describe the implementation of reactive scripts on top of Java, using SugarCubes defined in the companion paper:

• The SugarCubes Tool Box - Definition

Actually, we directly use SugarCubes for most part of the language. The main items to implements are behaviors, runs, and objects.