Go backward to 3 A Distributed Mathematica Environment
Go up to Top
Go forward to 5 Session Operation
Our original motivation stems from the desire to have the notebook frontend of the lecturer control all the notebook frontends of her audience. For this purpose, two requirements must be fulfilled:
Unfortunately, the standard Mathematica frontend fulfills the first demand only to a small extent:
Shift-Returnkey) creates an
EvaluatePacketsent to the kernel which responds to the frontend by a corresponding
After so many bad news, it is relieving to see that at least the second demand is essentially met:
NotebookObjectin the kernel.
NotebookGet) and vice versa (
NotebookPut). It may also determine the current selection in a notebook in the frontend (
Consequently, each user event that triggers a change in the state of a notebook can be in principle mirrored by a corresponding operation in the kernel which updates the notebook in the frontend. More specifically:
NotebookRead) and updated (
Of course, this still leaves the problem how to determine the control operations performed by the lecturer, for the frontend does not propagate this information to the outside. Since it is out of question to write a complete notebook frontend from scratch, we see three possibilities:
SelectionMovecommand to such a button, it may serve the same purpose as a link in hypertext documents.
The advantage of this solution is its technical simplicity, but it requires the corresponding modification of notebooks for distributed presentation.
This solution does not require modifications in the notebook; instead a Mathematica program running in the kernel must remember and update notebook states accordingly. Still only simple control events without additional arguments can be handled in this way.
This solution shifts the functionality of the control palette from the frontend to the interceptor process. By an appropriate user interface, arbitrary user input may be incorporated into messages to the kernel. Moreover, the control interface itself can encapsulate part of the notebook state (e.g. the current position) and forward this information to the kernel (thus relieving the kernel program from this task).
The ultimate solution will probably consist of a combination of these
possibilities; their appropriate mixture and area of application will be
subject of investigation. In any case, some care has to be taken to prevent
the individual session participants from modifying their notebook duplicates
during the lecturer's presentation. For this purpose, the interceptor process
may reset the state flag
Editable when it receives a new notebook. On
the other hand, the lecturer should not be allowed to perform operations via
the standard frontend that are not appropriately propagated to the
audience. There is no apparent technical solution to overcome this problem; as
a pragmatic remedy we may display on the lecturer's host in a separate window
the audience's view of the notebook such that the lecturer may detect
inappropriate actions early.