ViCE is a visual computing environment for building and executing
scientific workflows. ViCE leverages industry standard technologies,
such as XML, Web Services and Grid Services, to increase the
reliability and reduce the difficulty of building and executing
workflows. Workflows are built from actor components
which are connected by typed communication pipes.
Actor components encapsulate the behavior of individual tasks in the
workflow, and communication pipes encapsulate the behavior of
communication between tasks.
Here is a trivial workflow to give you a basic idea of what they look
like. This workflow simply iterates a range of numbers (from 30 to
50). This is a common scenario and would typically be used to initial
a parameter sweep over a range of integers.
This example demonstrates an archetypal workflow in the life sciences:
annotation of a novel gene using an existing protein database, and the creation
of a multiple sequence alignment combining the gene with its nearest relatives.
For a reasonably good although business oriented introduction to the
BPEL4WS standard, there is a IBM DeveloperWorks article Business
processes in a Web Services world.
For a comprehensive review of workflow tools see the excellent Survey of Scientific
Workflows.
Goals
ViCE was created to simplify the task of designing, building, and
monitoring execution of computational workflows by domain scientists.
Scientists from many different domains frequently assemble commonly
executed tasks using ad-hoc scripts to carry out their workflows.
Many of these workflows contain complex dependencies, and often parts
of the workflow have to be executed on different back-end compute
resources which are tuned to the particular sub-task being executed.
We are developing an environment that provides scientists easy to use
tools to assemble their workflows visually, and to receive
instantaneous visual indications of the progress of their workflow as
it executes. Further, the execution engine, CBEI, handles the
tedious aspects of distribution of jobs to back-end compute resources,
handling failure cases to ensure that the workflow continues to
execute even when back-end resources fail, and allows users to
compensate when failures cannot be handled autonomously.
Requirements
We are building ViCE to support the three most commonly used
workstation platforms (Mac OS X, Windows XP, and Linux). We use the following software to build ViCE:
Although ViCE is built using Python, it interoperates with practically
all standard web services platforms. We recognize that modern
computing enviroments are highly heterogenous and that you don't want
to be constrained to a particular language when implementing services
and components. We believe you should be able to build your services
and components in any language that supports standard web services.
We also provide a tool called PythonCLServiceTool
that makes it easy to "wrap" and deploy legacy command-line
applications as wgrid services.
Similar Programs and How ViCE is different
There are a number of similar scientific workflow applications; many
of which adopt a design similar to ViCE. We will not list them all
but list some of the better-known/more-established ones. These all
provide a graphical user interace based on a "visual programming"
interface in which networks are built from
actors and pipes, although they may
use different terms for them, and all have slightly different
semantics:
The big way that ViCE is different is that ViCE is only a front-end
for editing workflows and monitoring their execution. It delegates
the workflow execution to an external grid service, CBEI. ViCE could
be an editor for Triana, Taverna, Kepler, or other workflows, because
it is written as a generic framework. ViCE is designed with a simple
core with a powerful extension mechanism where users can write their
own actors and GUIs that "plug in" to the workflows. This extension
mechanism will allow us to add Collaboratory functionality like shared
chat, multiple users editing/monitoring a workflow at the same time,
and to add other features to enhance user productivity. CBEI,
likewise, is written as a generic framework and can be extended in a
number of ways.
We provide a
number of actors which implement common workflow patterns and document
how to write new actors that implement previously unacticipated
patterns.
