Technical Overview
of XML Framework for Algorithm Innovation
- XFAI
The XML Framework for Algorithm Innovation
is a tool for researchers to create,
run and deploy scripts to simulate distributed
sensor networks. At its core is Water,
a general purpose programming language
using XML syntax. A general purpose
language is needed because complex networks
that may dynamically configure
themselves need arbitrary processing
capabilities. Without them too many
'good ideas' simply become unimplementable.
Since Water uses XML syntax, it meshes
better than other languages with data
in XML format allowing both dynamic
and static data to be interspersed for
complex knowledge representation. Water
has web services integrated in, facilitating
the sharing of data AND code across
Internet-connected computers.
XFAI is built on top of Water to create
an environment to help researchers develop
and share software. By making it easy
for researchers to see each other's
code,
make new versions of it, and incorporate
existing scripts within new scripts,
each researcher can easily leverage
the work of other researchers regardless
of their location.
The XFAI browser interface can be run
on any computer connected on the network
with the XFAI server. This can be a
private network or the Internet itself.
This server-browser pair of computers
can be physically on the same computer
or spilt between two different machines.
The simplest configuration is to run
the XFAI server on the same computer
that is running the browser user interface.
This allows you to run "stand-alone"
without a network connection.
The XFAI interface facilitates the running
of scripts in several ways. First, a
script may be selected from the menu
of scripts served by a particular XFAI
server. Second, the source of any script
deployed on any connected XFAI server
can be brought into the source code
pane, modified and executed. Third,
the 'view' of the source of a script
can be changed from textual 'code' into
'buttons', a GUI representation of the
script that hides code details while
exposing variables that can be modified
and
automatically inserted into the script
code. The button view allows an intermediate
functionality between a no-modifications
'just run it' mode and the full power
to edit all of the code.
Finally XFAI scripts can be run programmatically.
Data can be retrieved from a third computer,
that is, one other than those running
the server or browser, and that data
can be passed to a script on a fourth
computer. XFAI's 'execute' command allows
a script to come from one computer yet
run on another. Since XFAI employs a
general purpose language, any number
of 'execute' commands can be embedded
in a single script. Intervening 'glue'
code can be written to flexibly patch
a software network together to run a
complex simulation. Since 'execute'
is, syntactically, just another Water
method. There is no language barrier
to employ it in a wide variety of
situations within a script.
In addition to Water, XFAI can also
run MATLAB code via its embedded 'Octave
Server'. Octave is an open source version
of a MATLAB engine. MATLAB can be run
directly by typing it into the source
pane and clicking on the "Execute
MATLAB" button.
It can also be run programmatically
via the 'execute' method. Execute takes
a string of source code as its main
argument. That can either be a file
name containing source or the actual
source itself. In addition to the 'execute'
parameters that let you indicate which
computer the code lives on and which
computer it should be run on, there
is also a parameter to indicate the
language that the source is written
in. A present, XFAI supports two languages,
Water and MATLAB. the default value
of the Source_language parameter to
'execute' is "guess" meaning
let XFAI figure out from examining the
source, what language it is in. Usually
XFAI guesses right, but you can declare
the language to ensure success if you
like.
XFAI has three presentations of a script.
The shortest, is simply the name of
the script in the 'scripts' menu. This
menu is automatically populated with
the contents of the xfai_scripts folder
on the computer indicated in the 'Remote
server' field of the XFAI interface.
A selected script can either be run
by clicking the 'run' button, or edited,
to show the second presentation of a
script, as its textual source code in
the 'source' pane of XFAI. By clicking
on the 'Buttons' checkbox in the XFAI
interface, you can see another presentation
of a script. Buttons shows you GUI components
of buttons, check boxes, menus and radio
buttons that let you modify and run
top-level calls in the script. The 'Buttons'
view hides most of the details of the
script and allows you to modify only
a few parameters. It is great for demos
and tweaking code without giving you
the opportunity for creating a typo.
Modifications made in this GUI interface
are reflected back into the actual textual
source so they get saved when the script
is saved out to disk.
XFAI shows the results of a script in
two ways. The first is a native Water
printed representation of a Water object.
The second is an HTML presentation similar
to what a browser shows. Whatever can
be displayed by a normal browser can
also be displayed as the result of running
a script. The switch between Water output
and HTML-browser output happens automatically
based on the returned value.
Each script may have an associated documentation
file which can contain any HTML to describe
the script to a human. XFAI automatically
shows the documentation (if any) when
a script is edited. In addition there
is a link between XFAI and Traction
for collaboration on a finer grained
detail, allowing researchers to share
comments about a given script. The capability
to easily provide documentation, user
comments, code, and the running of that
code with multiple levels of running
& modification across multiple computers
AND coordinate all of this through a
web browser interface, increases the
productivity of researchers, their managers
and early adopters of
software innovations wherever the participants
may be.
|