This demo illustrates the use of the new communication mechanism between parallel components introduced by SugarCubes v3.0: Valued occurences of event. This mechanism is fully compatible with the notion of event introduced since SugarCubes v1.0, but it allows now to communicate more informations (numerical values or objects) between parallel components.

When an event is generated, for example using the Generate primitive (SC.generate), a list of numerical values or objects can be associated to this generation. This list is memorized by the event structure as a new occurence during the instant. At each end of instant occurences of events are discarded.

This doesn't interfere with the classical pure event communication, as valued occurences are only handled by one special primitive called Callback (SC.callback). A Callback can scan every occurences of an event during one instant. All Callback primitives will be activated once for each occurences of an event during the instant they appear, and this in the same order as they are generated in the environment. So, every parallel components that have a Callback on the same event will see exactly the same occurences in the same order during one instant.

When activated a Callback receives a set of values associated to the occurence that has triggered the activation of the Callback. The Callback reacts by executing an atomic action which can handle those values. A Callback only terminates at the end of the instant, when no more generation of the event, to which it is bound to, can occure.

This demo makes an intensive use this powerfull broadcast communication mechanism. All reactive objects in this demo (spiders and workspaces) are parallel components (cubes) communicating together using this broadcast event mechanism. No one of those objects has any reference to the other objects in the system. So, by that way,objects are designed without having to take care of any other objects. The only point to be careful with, in order to acheive a good communication, is the event protocol and types of values associated to an occurence of event. This provide a great modularity in the design of applications.

In this demo one uses valued occurences to acheive these communications:

• To display things, a workspace generates at each instant an event "Display Here" with its graphical context as a value. As events are broadcast, the workspace doesn't have to take care about how many and which objects in the system have to be displayed. Spiders in this example have a Callback which scans the event "Display Here" and reacts to any occurence of this event by drawing their image in the associated graphical context. If their is no spiders in the system nothing will be displayed. If their is no workspace, spiders will not be displayed but they continue to be executed. If their is more than one workspace, spiders will be displayed during the same instant in each of them, so, one gets exactly the same picture in all workspaces (Coherence between the pictures is acheived naturally by the synchronous model - no need to implement synchronization protocol -).
• To handle collision with each other, a spider generates at each instant an event "I am Here" with associated values made of the current position of the spider and its current speed. Every spider also has in its behavior a Callback on the event "I am Here". This Callback scans every occurences of the event and reacts by executing an atomic action which handles the collision for this particular spider. This protocol is very heavy because you have an N^2 algorithm. But the symetry of the computation of a collision between two objects can rather be easilly split other a distributed system for example.

The jar file contains sources and compiled classes. So, you can directly execute the callback demo just by adding the SugarCubesv3.0.3.jar package and the callback.jar package directly in your CLASSPATH.

You access to source files just by typing jar xvf callback.jar

First, you have to extract the spider picture from the jar archive: just type jar xvf callback.jar Spider.gif

To execute the demo, just type java -cp callback.jar:SugarCubesv3.0.3.jar demos.callback2D.Main

• Two windows are created at startup: one indicates the number of instant computed per seconds and the other is a control panel.
• The first button of the control panel allows you to build new Icobjs which in this case are small spiders animated by an inertial behavior. Spiders bounce on borders of the workspace (windows named MainFrame x) and can collide together.
• The second button builds new workspace windows where spiders are displayed.
• by clicking on a workspace (MainFrame x) you bound future created spiders to this workspace.
• A spider is displayed with a red dot if it is bound to the current workspace or with a green dot if it is bound to another workspace.
• Closing a workspace causes the death of every spiders bound to it.
• While dying (because the workspace they are attached to has been closed) spiders still exist for a period of random duration. but they move no more and no more interract with other living spiders. Then they desappear for ever.

Note about multithreading

If your JVM doesn't support preemptive multithreading, this demo will not allow you to interact with it, as it doesn't explecitly release the control to give a chance to the graphical thread of the Java AWT system to be executed. To allow execution on a cooperatively scheduled JVM edit the source of the class Main (Main.java) and uncomment the line enabling the time reserve system of the SugarCubes:

        Program p = new Test().buildProgram();
        //m.enableTimeReserve(true,30);
        m.addProgram(p);

This will enable other threads to be executed as the react method will explicitly release the control in order to fit the timming constraints. The enableTimeReserve will enforce the react method to sleep (if needed) in order to have a duration of at least 1/30 milliseconds.
Of course, you can also edit the main loop (in the Main class) to explicitly release the control at some points using Thread.yield() or Thread.sleep().

You should obtain something like this: