Computational tasks are increasingly split across many devices and involve multiple, non-coordinating participants. Current architectural techniques are struggling with this: they implicitly assume a model in which a single user, uses a single (albeit networked) machine and a single application to work on local, isolated data. Applications built in this style are seldom concerned about concurrency issues unless the developer makes a special effort to the contrary.

Large organisations are finding it increasingly difficult to work with such applications. Co-ordinating the administration of the applications, for example the installation and update of the binary executables, takes a disproportionate share of an IT department's resources. The alternative - leaving applications un-patched and potentially insecure - is untenable. The result is that, even as workstations become more powerful by the year, IT departments are forced to "lock them down" and prevent their users taking full advantage of the organisation's computational resources.

Moreover, recent trends have been toward a mutli-device computational environment: a workstation, laptop and mobile phone may all be used to interact with the same data. Finally, the growth of the internet, and particularly the growth of on-line collaboration, has also increased the number of people that may work concurrently on a shared artifact.

Recently, IT organisations have turned to web-based applications - client server applications delivered using HTML - to solve two of the problems manifest in this new environment:

• Global accessibility: web applications can be accessed from any machine with a web browser and a network connection.
• Transparent distribution and update: applications need only be installed and updated on a central server for those updates to be rolled out to all users.

These are compelling advantages for an IT department, however many problems remain and some new ones are introduced. The deficiencies of HTML as an application environment is being addressed with so-called rich internet application frameworks such as Flex, Laszlo and Silverlight as well as the W3C's own efforts. There are however, deeper systems problems that will be magnified by the shift to a multi-device, concurrent user environment:

• Mobility and multi-synchrony: a device or participant may join and leave a computational task at any time, either explicitly or due to varying connectivity conditions. Applications must have a concurrency model that does not assume complete knowledge of the participant population and does not rely on locking to enable concurrent access: i.e. a multi-synchronous concurrency model rather than the floor control concurrency model commonly employed.
• Continuity: computational tasks will exist independently of the participants engaged in them at any specific time. A participant must be able to situate herself within a task, which will require an intuitive model of current and historical activity. Further, since it is unlikely that a task will be rigidly compartmentalised, this representation must adapt to multiple applications, devices, and participants.

Many of these problems have been well explored in research. For example:

• P2P systems such as Pastry explored distributed storage and look-up along with efficient distributed group membership and communication.
• Bayou and others [ Edwards 97 ] explored multi-synchronous mobile applications.
• IceCube [ Preguica et al. 03 ]explored application-independent reconciliation.
• Joyce/Telex [ O'Brien et. al. 06 ] explored collaborative/nomadic application models.

The goal of this project is to apply the results from the project above to create a practical system for multi-synchronous web applications that is deployable in real-world environments.

We would expect a collaborative, nomadic web application to present the user experience below, we describe the experience of a browser-based application though an RIA experience would be similar:

1. The user opens some shared artefact by browsing to a local or remote URL.
2. If the user's device is online, the browser will securely join the collaborative group for the artefact and synchronise with the group activity.
3. An application is presented. The application represents both the shared artefact and the activity, past and present, surrounding the artefact (modulo filtering configured by the local user). The user can
4. The user changes his copy of the artefact by interacting with the application. These changes are recorded and distributed to the collaborative group.
5. Similarly, changes from the other participants are reflected in the user's local display. The user may control which updates she sees and when, and she can do this without losing any information. If she makes a change that conflicts with a remote participant, the application will display her change but highlight the conflict in the application display.
6. Interaction with the application is unaffected by connectivity changes on the user's device. When connectivity is re-established, the application automatically re-synchronises and highlights concurrent changes.
7. When the user browses away from the artefact or closes her browser window the application disengages from the collaborative group. All modifications have been automatically saved. The user is also able to make coarser-grained milestones of the artefact.