Designing a document-centric coordination application over the Internet
Identifieur interne : 002429 ( Istex/Corpus ); précédent : 002428; suivant : 002430Designing a document-centric coordination application over the Internet
Auteurs : Paolo Ciancarini ; Davide Rossi ; Fabio VitaliSource :
- Interacting with Computers [ 0953-5438 ] ; 2001-08.
Abstract
In this paper we describe an experience in designing a groupware application distributed over the WWW to solve a conference management problem. The system we design coordinates the activities of several people engaged in reviewing and selecting papers submitted for a scientific conference. We discuss why such an application is interesting and describe how we designed it. The architecture we suggest implements what we call an active Web, because it includes entities which we are able to use and provide services offered through WWW infrastructures. Users, agents, and active documents can interoperate using a set of basic services for communication and synchronization. The active Web infrastructure we describe here is based on coordination technology integrated with Java.
Url:
DOI: 10.1016/S0953-5438(01)00037-6
Links to Exploration step
ISTEX:8C5E7EC4B48C7CFF58C9307FD72802B47258BDBCLe document en format XML
<record><TEI wicri:istexFullTextTei="biblStruct"><teiHeader><fileDesc><titleStmt><title>Designing a document-centric coordination application over the Internet</title><author><name sortKey="Ciancarini, Paolo" sort="Ciancarini, Paolo" uniqKey="Ciancarini P" first="Paolo" last="Ciancarini">Paolo Ciancarini</name><affiliation><mods:affiliation>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</mods:affiliation></affiliation><affiliation><mods:affiliation>Corresponding author. Tel.: +3951-351506; fax: +3951-354510</mods:affiliation></affiliation></author><author><name sortKey="Rossi, Davide" sort="Rossi, Davide" uniqKey="Rossi D" first="Davide" last="Rossi">Davide Rossi</name><affiliation><mods:affiliation>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</mods:affiliation></affiliation><affiliation><mods:affiliation>RossiDavide</mods:affiliation></affiliation></author><author><name sortKey="Vitali, Fabio" sort="Vitali, Fabio" uniqKey="Vitali F" first="Fabio" last="Vitali">Fabio Vitali</name><affiliation><mods:affiliation>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</mods:affiliation></affiliation><affiliation><mods:affiliation>VitaliFabio</mods:affiliation></affiliation></author></titleStmt><publicationStmt><idno type="wicri:source">ISTEX</idno><idno type="RBID">ISTEX:8C5E7EC4B48C7CFF58C9307FD72802B47258BDBC</idno><date when="2001" year="2001">2001</date><idno type="doi">10.1016/S0953-5438(01)00037-6</idno><idno type="url">https://api.istex.fr/ark:/67375/HXZ-LFJM2JKP-7/fulltext.pdf</idno><idno type="wicri:Area/Istex/Corpus">002429</idno><idno type="wicri:explorRef" wicri:stream="Istex" wicri:step="Corpus" wicri:corpus="ISTEX">002429</idno></publicationStmt><sourceDesc><biblStruct><analytic><title level="a">Designing a document-centric coordination application over the Internet</title><author><name sortKey="Ciancarini, Paolo" sort="Ciancarini, Paolo" uniqKey="Ciancarini P" first="Paolo" last="Ciancarini">Paolo Ciancarini</name><affiliation><mods:affiliation>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</mods:affiliation></affiliation><affiliation><mods:affiliation>Corresponding author. Tel.: +3951-351506; fax: +3951-354510</mods:affiliation></affiliation></author><author><name sortKey="Rossi, Davide" sort="Rossi, Davide" uniqKey="Rossi D" first="Davide" last="Rossi">Davide Rossi</name><affiliation><mods:affiliation>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</mods:affiliation></affiliation><affiliation><mods:affiliation>RossiDavide</mods:affiliation></affiliation></author><author><name sortKey="Vitali, Fabio" sort="Vitali, Fabio" uniqKey="Vitali F" first="Fabio" last="Vitali">Fabio Vitali</name><affiliation><mods:affiliation>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</mods:affiliation></affiliation><affiliation><mods:affiliation>VitaliFabio</mods:affiliation></affiliation></author></analytic><monogr></monogr><series><title level="j">Interacting with Computers</title><idno type="ISSN">0953-5438</idno><idno type="eISSN">1873-7951</idno><imprint><publisher>Oxford University Press</publisher><pubPlace>Oxford, UK</pubPlace><date type="published" when="2001-08">2001-08</date><biblScope unit="volume">13</biblScope><biblScope unit="issue">6</biblScope><biblScope unit="page" from="677">677</biblScope><biblScope unit="page" to="693">693</biblScope></imprint><idno type="ISSN">0953-5438</idno></series></biblStruct></sourceDesc><seriesStmt><idno type="ISSN">0953-5438</idno></seriesStmt></fileDesc><profileDesc><textClass></textClass></profileDesc></teiHeader><front><div type="abstract">In this paper we describe an experience in designing a groupware application distributed over the WWW to solve a conference management problem. The system we design coordinates the activities of several people engaged in reviewing and selecting papers submitted for a scientific conference. We discuss why such an application is interesting and describe how we designed it. The architecture we suggest implements what we call an active Web, because it includes entities which we are able to use and provide services offered through WWW infrastructures. Users, agents, and active documents can interoperate using a set of basic services for communication and synchronization. The active Web infrastructure we describe here is based on coordination technology integrated with Java.</div></front></TEI><istex><corpusName>oup</corpusName><author><json:item><name>Paolo Ciancarini</name><affiliations><json:string>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</json:string><json:string>Corresponding author. Tel.: +3951-351506; fax: +3951-354510</json:string></affiliations></json:item><json:item><name>Davide Rossi</name><affiliations><json:string>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</json:string><json:string>RossiDavide</json:string></affiliations></json:item><json:item><name>Fabio Vitali</name><affiliations><json:string>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</json:string><json:string>VitaliFabio</json:string></affiliations></json:item></author><subject><json:item><value>Coordination</value></json:item><json:item><value>WWW architectures</value></json:item><json:item><value>Collaborative platforms</value></json:item><json:item><value>CSCW</value></json:item></subject><arkIstex>ark:/67375/HXZ-LFJM2JKP-7</arkIstex><language><json:string>unknown</json:string></language><originalGenre><json:string>research-article</json:string></originalGenre><abstract>In this paper we describe an experience in designing a groupware application distributed over the WWW to solve a conference management problem. The system we design coordinates the activities of several people engaged in reviewing and selecting papers submitted for a scientific conference. We discuss why such an application is interesting and describe how we designed it. The architecture we suggest implements what we call an active Web, because it includes entities which we are able to use and provide services offered through WWW infrastructures. Users, agents, and active documents can interoperate using a set of basic services for communication and synchronization. The active Web infrastructure we describe here is based on coordination technology integrated with Java.</abstract><qualityIndicators><score>8.404</score><pdfWordCount>6730</pdfWordCount><pdfCharCount>39982</pdfCharCount><pdfVersion>1.2</pdfVersion><pdfPageCount>17</pdfPageCount><pdfPageSize>468 x 680 pts</pdfPageSize><refBibsNative>true</refBibsNative><abstractWordCount>117</abstractWordCount><abstractCharCount>779</abstractCharCount><keywordCount>4</keywordCount></qualityIndicators><title>Designing a document-centric coordination application over the Internet</title><genre><json:string>research-article</json:string></genre><host><title>Interacting with Computers</title><language><json:string>unknown</json:string></language><issn><json:string>0953-5438</json:string></issn><eissn><json:string>1873-7951</json:string></eissn><publisherId><json:string>iwc</json:string></publisherId><volume>13</volume><issue>6</issue><pages><first>677</first><last>693</last></pages><genre><json:string>journal</json:string></genre></host><namedEntities><unitex><date><json:string>2001</json:string></date><geogName></geogName><orgName><json:string>Microsoft Research Europe and a</json:string><json:string>Italy Abstract In</json:string></orgName><orgName_funder></orgName_funder><orgName_provider></orgName_provider><persName><json:string>Fabio Vitali</json:string><json:string>P. Ciancarini</json:string><json:string>Jada Jada</json:string><json:string>CORBA World</json:string><json:string>The</json:string><json:string>F. Vitali</json:string><json:string>Lotus Notes</json:string><json:string>Davide Rossi</json:string><json:string>D. Rossi</json:string></persName><placeName><json:string>Java</json:string><json:string>Tolksdorf</json:string></placeName><ref_url></ref_url><ref_bibl><json:string>Mathews and Jacobs (1996)</json:string><json:string>Sassone (1996)</json:string><json:string>Matskin et al. (1998)</json:string><json:string>Ciancarini and Rossi, 1997</json:string><json:string>Ciancarini and Rossi (1997)</json:string><json:string>Gamma et al., 1995</json:string><json:string>Ciancarini et al., 1999</json:string><json:string>Wyckoff et al., 1998</json:string><json:string>Malone and Crowstone, 1994</json:string><json:string>Ciancarini et al., 1998</json:string><json:string>Workshop Session of the ACM CSCW, 1996</json:string><json:string>Bray et al., 1997</json:string><json:string>Doppke et al. 1998</json:string><json:string>Ciancarini et al.</json:string><json:string>SUN Microsystems, 1999</json:string><json:string>Carriero and Gelernter, 1992</json:string><json:string>Dix et al. (2000)</json:string><json:string>Munson and Dewan, 1997</json:string><json:string>P. Ciancarini et al.</json:string><json:string>Das et al. 1997</json:string></ref_bibl><bibl></bibl></unitex></namedEntities><ark><json:string>ark:/67375/HXZ-LFJM2JKP-7</json:string></ark><categories><wos><json:string>social science</json:string><json:string>ergonomics</json:string><json:string>science</json:string><json:string>computer science, cybernetics</json:string></wos><scienceMetrix><json:string>health sciences</json:string><json:string>psychology & cognitive sciences</json:string><json:string>human factors</json:string></scienceMetrix><scopus><json:string>1 - Physical Sciences</json:string><json:string>2 - Computer Science</json:string><json:string>3 - Human-Computer Interaction</json:string><json:string>1 - Physical Sciences</json:string><json:string>2 - Computer Science</json:string><json:string>3 - Software</json:string></scopus><inist><json:string>sciences appliquees, technologies et medecines</json:string><json:string>sciences exactes et technologie</json:string><json:string>sciences et techniques communes</json:string><json:string>sciences de l'information. documentation</json:string></inist></categories><publicationDate>2001</publicationDate><copyrightDate>2001</copyrightDate><doi><json:string>10.1016/S0953-5438(01)00037-6</json:string></doi><id>8C5E7EC4B48C7CFF58C9307FD72802B47258BDBC</id><score>1</score><fulltext><json:item><extension>pdf</extension><original>true</original><mimetype>application/pdf</mimetype><uri>https://api.istex.fr/ark:/67375/HXZ-LFJM2JKP-7/fulltext.pdf</uri></json:item><json:item><extension>zip</extension><original>false</original><mimetype>application/zip</mimetype><uri>https://api.istex.fr/ark:/67375/HXZ-LFJM2JKP-7/bundle.zip</uri></json:item><istex:fulltextTEI uri="https://api.istex.fr/ark:/67375/HXZ-LFJM2JKP-7/fulltext.tei"><teiHeader><fileDesc><titleStmt><title level="a">Designing a document-centric coordination application over the Internet</title></titleStmt><publicationStmt><authority>ISTEX</authority><publisher scheme="https://publisher-list.data.istex.fr">Oxford University Press</publisher><pubPlace>Oxford, UK</pubPlace><availability><licence><p>© 2001 Elsevier Science B.V. All rights reserved.</p></licence><p scheme="https://loaded-corpus.data.istex.fr/ark:/67375/XBH-GTWS0RDP-M">oup</p></availability><date>2001</date></publicationStmt><notesStmt><note type="research-article" scheme="https://content-type.data.istex.fr/ark:/67375/XTP-1JC4F85T-7">research-article</note><note type="journal" scheme="https://publication-type.data.istex.fr/ark:/67375/JMC-0GLKJH51-B">journal</note><note>*Corresponding author. Tel.: +3951-351506; fax: +3951-354510</note></notesStmt><sourceDesc><biblStruct type="inbook"><analytic><title level="a">Designing a document-centric coordination application over the Internet</title><author xml:id="author-0000"><persName><forename type="first">Paolo</forename><surname>Ciancarini</surname></persName><affiliation>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</affiliation><affiliation>Corresponding author. Tel.: +3951-351506; fax: +3951-354510</affiliation></author><author xml:id="author-0001"><persName><forename type="first">Davide</forename><surname>Rossi</surname></persName><affiliation>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</affiliation><affiliation>RossiDavide</affiliation></author><author xml:id="author-0002"><persName><forename type="first">Fabio</forename><surname>Vitali</surname></persName><affiliation>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</affiliation><affiliation>VitaliFabio</affiliation></author><idno type="istex">8C5E7EC4B48C7CFF58C9307FD72802B47258BDBC</idno><idno type="ark">ark:/67375/HXZ-LFJM2JKP-7</idno><idno type="DOI">10.1016/S0953-5438(01)00037-6</idno></analytic><monogr><title level="j">Interacting with Computers</title><idno type="pISSN">0953-5438</idno><idno type="eISSN">1873-7951</idno><idno type="publisher-id">iwc</idno><idno type="PublisherID-hwp">iwc</idno><imprint><publisher>Oxford University Press</publisher><pubPlace>Oxford, UK</pubPlace><date type="published" when="2001-08"></date><biblScope unit="volume">13</biblScope><biblScope unit="issue">6</biblScope><biblScope unit="page" from="677">677</biblScope><biblScope unit="page" to="693">693</biblScope></imprint></monogr></biblStruct></sourceDesc></fileDesc><profileDesc><creation><date>2001</date></creation><abstract><p>In this paper we describe an experience in designing a groupware application distributed over the WWW to solve a conference management problem. The system we design coordinates the activities of several people engaged in reviewing and selecting papers submitted for a scientific conference. We discuss why such an application is interesting and describe how we designed it. The architecture we suggest implements what we call an active Web, because it includes entities which we are able to use and provide services offered through WWW infrastructures. Users, agents, and active documents can interoperate using a set of basic services for communication and synchronization. The active Web infrastructure we describe here is based on coordination technology integrated with Java.</p></abstract><textClass><keywords scheme="keyword"><list><head>keywords</head><item><term>Coordination</term></item><item><term>WWW architectures</term></item><item><term>Collaborative platforms</term></item><item><term>CSCW</term></item></list></keywords></textClass></profileDesc><revisionDesc><change when="2001-08">Published</change></revisionDesc></teiHeader></istex:fulltextTEI><json:item><extension>txt</extension><original>false</original><mimetype>text/plain</mimetype><uri>https://api.istex.fr/ark:/67375/HXZ-LFJM2JKP-7/fulltext.txt</uri></json:item></fulltext><metadata><istex:metadataXml wicri:clean="corpus oup, element #text not found" wicri:toSee="no header"><istex:xmlDeclaration>version="1.0" encoding="utf-8"</istex:xmlDeclaration><istex:docType PUBLIC="-//NLM//DTD Journal Publishing DTD v2.3 20070202//EN" URI="journalpublishing.dtd" name="istex:docType"></istex:docType><istex:document><article article-type="research-article">
<front>
<journal-meta>
<journal-id journal-id-type="hwp">iwc</journal-id>
<journal-id journal-id-type="publisher-id">iwc</journal-id>
<journal-title>Interacting with Computers</journal-title>
<issn pub-type="ppub">0953-5438</issn>
<issn pub-type="epub">1873-7951</issn>
<publisher>
<publisher-name>Oxford University Press</publisher-name>
<publisher-loc>Oxford, UK</publisher-loc>
</publisher>
</journal-meta>
<article-meta>
<article-id pub-id-type="doi">10.1016/S0953-5438(01)00037-6</article-id>
<article-categories>
<subj-group subj-group-type="heading">
<subject>Articles</subject>
</subj-group>
</article-categories>
<title-group>
<article-title>Designing a document-centric coordination application over the Internet</article-title>
</title-group>
<contrib-group>
<contrib contrib-type="author"><name><surname>Ciancarini</surname><given-names>Paolo</given-names></name><xref ref-type="corresp" rid="CORR1">*</xref><email>ciancarini@cs.unibo.it</email></contrib>
<contrib contrib-type="author"><name><surname>Rossi</surname><given-names>Davide</given-names></name><email>rossi@cs.unibo.it</email></contrib>
<contrib contrib-type="author"><name><surname>Vitali</surname><given-names>Fabio</given-names></name><email>vitali@cs.unibo.it</email></contrib>
<aff>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</aff></contrib-group>
<author-notes>
<corresp id="CORR1"><label>*</label>Corresponding author. Tel.: +3951-351506; fax: +3951-354510</corresp>
</author-notes>
<pub-date pub-type="ppub">
<month>8</month>
<year>2001</year>
</pub-date>
<volume>13</volume>
<issue>6</issue>
<fpage>677</fpage>
<lpage>693</lpage>
<copyright-statement>© 2001 Elsevier Science B.V. All rights reserved.</copyright-statement>
<copyright-year>2001</copyright-year>
<abstract>
<p>In this paper we describe an experience in designing a groupware application distributed over the WWW to solve a conference management problem. The system we design coordinates the activities of several people engaged in reviewing and selecting papers submitted for a scientific conference. We discuss why such an application is interesting and describe how we designed it. The architecture we suggest implements what we call an <italic>active Web</italic>, because it includes entities which we are able to use and provide services offered through WWW infrastructures. Users, agents, and active documents can interoperate using a set of basic services for communication and synchronization. The active Web infrastructure we describe here is based on coordination technology integrated with Java.</p>
</abstract>
<kwd-group>
<kwd>Coordination</kwd>
<kwd>WWW architectures</kwd>
<kwd>Collaborative platforms</kwd>
<kwd>CSCW</kwd>
</kwd-group>
</article-meta>
</front>
<body>
<sec>
<label>1</label>
<title>Introduction</title>
<p>In the current state, the World Wide Web does not provide enough support for document-centric applications based on agent-oriented ontologies, like group-ware or workflow, which require sophisticated agent role-playing and coordination.</p>
<p>In fact, most WWW applications are either server-centric (the HTTP server connects to an application through the CGI protocol or any similar method), client-centric (applets providing application services to users without a real distribution of efforts), or not integrated at all with the Web (applications whose user interface is implemented by applets or plug-ins connecting with some proprietary protocol to a proprietary server, and using the browser as a passive and irrelevant host for the applet). All these approaches do not really satisfy the idea of an active Web based on some structured configuration of (autonomous) agents: they are either not really distributed, or integrated with the Web.</p>
<p>The World Wide Web is now the most popular platform to access Internet services, so it has the potential to become the standard infrastructure to build integrated applications. In fact, most application domains are turning to the World Wide Web as the environment of choice for building innovative applications leveraging on the open standards, their diffusion, and the programmable nature of the available services.</p>
<p>Among such domains, there is a growing interest in document management systems based on the WWW infrastructure. Some of these applications exploit <italic>multiagent</italic> technologies, meaning that they are highly concurrent, distributed, and often based on mobile code (<xref ref-type="bibr" rid="BIB14">Munson and Dewan, 1997</xref>). The PageSpace reference architecture (<xref ref-type="bibr" rid="BIB4">Ciancarini et al., 1998</xref>) provides a reference framework for Web-based applications that are composed of autonomous agents performing their duties regardless of their physical positions. PageSpace provides clear-cut roles for agents, user interfaces and coordination paradigms in order to implement complex distributed applications on the World Wide Web.</p>
<p>In this paper we demonstrate the flexibility of PageSpace by describing an experience where this architecture has been tested. By relying on the coordination primitives of (<xref ref-type="bibr" rid="BIB3">Ciancarini and Rossi (1997</xref>) a coordination language for Java, we have implemented MUDWeb, a cooperative interactive environment sharable by several users and autonomous agents remindful of the cooperative gaming environments called Multi-User Dungeons (MUDs). Within MUDWeb, a conference management system has been implemented, allowing full support for all the activities connected to the organization of a scientific conference, such as the collection of papers, their distribution to reviewers, the collection of the reviews, and the selection of the accepted papers. ConfManager demonstrates the flexibility of the MUDWeb environment, which is a significant implementation of the PageSpace architecture.</p>
<p>The paper is structured as follows: in <xref ref-type="sec" rid="SEC2">Section 2</xref> we discuss the issues arising when creating distributed, interactive applications on the WWW. In <xref ref-type="sec" rid="SEC3">Section 3</xref> we discuss the case study of the design and implementation of a conference management system. We then introduce the PageSpace reference architecture in <xref ref-type="sec" rid="SEC5">Section 4</xref>. <xref ref-type="sec" rid="SEC7">Section 5</xref> introduces MUDWeb: an instance of PageSpace based on Jada. After discussing the requirements in <xref ref-type="sec" rid="SEC9">Section 6</xref> we describe ConfManager, the actual implementation of the system based on MUDWeb. <xref ref-type="sec" rid="SEC10">Section 7</xref> concludes the paper and provides some hints on possible evolution of our research, in particular regarding the XML markup language.</p>
</sec>
<sec id="SEC2"><label>2</label>
<title>The need for an active Web</title>
<p>The World Wide Web was originally born as a browsing system for hypertext documents working around a very simple set of common protocols and languages: the interactions among the WWW components are driven by the HTTP protocol, a very simple TCP/IP based client–server protocol used to retrieve documents stored under the control of an HTTP server. Often documents are in HTML format, a mark-up language based on SGML that allows the specification of hypertext links and simple formatting instructions for multimedia documents. An important characteristics of the WWW is that documents can be created on-the-fly by code activated by the HTTP server, as it happens with the CGI protocol, the servlet approach, or many server-side include languages such as PHP, Microsoft's ASP, etc. With these approaches a client requests a document as the output of a process run on the server. These simple mechanisms can be used in sophisticated ways in order to implement more complex forms of interaction among documents, clients, and servers.</p>
<p>According to its original design, the only activities that could be dynamically triggered in the WWW were associated to one such server-side mechanism. Soon users demanded more interaction than just browsing documents, and this brought about the development of a family of languages that can be embedded into an HTML document and executed within the user's browser. These languages (or even architectures to transfer executable code, as in the case of Microsoft's ActiveX) are very different in capabilities and target; some in fact are scripting languages intended to interact heavily with the document itself (as in the case of JavaScript), while others are complex and full-fledged languages that have little interaction with the document (as in the case of Java).</p>
<p>These technologies give us the ability to ‘activate’ two key components of the WWW architecture, servers and clients. However, we still lack standard and well-known techniques and protocols to allow these components to interoperate. Usually, in fact, projects aiming at the exploitation of the WWW as an active distributed platform locate computing components just on one side (either at the server or at the clients) or, if any more sophisticated need occurs, by inventing an ad hoc communication protocol between a specific client and a specific server-side application.</p>
<p>We propose a different approach to activate the Web, by redefining the coordination capabilities of the WWW middleware in which the activity takes place. An <italic>active Web</italic> is a system including some notion of agent performing some activity. These activities can take place at the client, server, middleware level, gateway with another active software system (e.g. an external database, a decision support system or an expert system) or even at the user level. An active Web includes several agents, all with well-defined behaviors. Each component of an active Web thus is an autonomous agent doing well-defined computations in a shared world providing coordination services: an agent should not only be just capable of computations but also be able to interact (in possibly complex ways) with other agents.</p>
<p>The interaction among agents is usually accomplished using client/server architectures (as in any RPC-based system, such as CORBA). However, the client–server framework misses its main goals (for instance, modular design and simple interaction behavior) whenever the interactions among the components is unusually complex, for instance when the components change with time, when the client/server relationship can be reversed, or when the designer needs a wider decoupling among components. These are issues we have to deal with in a worldwide-distributed system including heterogeneous networks. A solution to these problems consists in designing the distributed application as a world of agents in which agents are spatially scattered and act autonomously: this schema fits quite well into the distributed objects model.</p>
<p>In a coordination-based approach (<xref ref-type="bibr" rid="BIB2">Carriero and Gelernter, 1992</xref>), agents perform sequences of actions which are either method invocations or message deliveries. Synchronization actions (e.g. starting, blocking, unblocking, and terminating an activity) are the remaining mechanisms in object invocation. More precisely, we distinguish between <italic>agent computation</italic>, which is what concerns the internal behavior of an agent, and <italic>agent coordination</italic>, which is what concerns the relationship between an agent and its environment, such as synchronization, communication, and service provision and usage.</p>
<p>Coordination models separate coordination from computation, not as independent or dual concepts, but as orthogonal ones: they are two dimensional both necessary to design agent worlds. A coordination language should thus combine two languages: one for coordination (the inter-agent actions) and the other for computation (the intra-agent actions). The most famous example of coordination models is the one proposed in Linda (<xref ref-type="bibr" rid="BIB2">Carriero and Gelernter, 1992</xref>), which has been implemented on several hardware architectures and combined with different programming languages. Linda can be seen as a sort of assembly coordination language in two ways. First and foremost, it offers very simple <italic>coordinables</italic> (i.e. active and passive tuples, which can be used to, respectively, represent agents and messages), a unique <italic>coordination medium</italic> (the Tuple Space, in which all tuples reside), and a small number of coordination <italic>primitives</italic>. Second, Linda is a sort of coordination assembly because it can be used to implement higher-level coordination languages. For instance, we have used it to implement Jada, a coordination language for Java, briefly detailed in <xref ref-type="sec" rid="SEC6">Section 4.1</xref>.</p>
<p>Coordination models can be used to design an architecture that enables the active Web described in this section, Web activities are not constrained to be either client-side or server-side. For instance, the PageSpace architecture (<xref ref-type="bibr" rid="BIB4">Ciancarini et al., 1998</xref>) is a proposal for providing a general framework for active agents within a Web environment that will be briefly detailed in <xref ref-type="sec" rid="SEC5">Section 4</xref>.</p>
</sec>
<sec id="SEC3"><label>3</label>
<title>Designing a conference management system</title>
<p>As a case study for the usage of coordination technologies on the World Wide Web, we turned to a system to support the management on a scientific conference. The purpose of this section is to describe our experience: we intend to specify a system for supporting all the activities which typically have to be performed by a number of people widely distributed all over the world to submit, select, and prepare the set of papers which will be published in the proceedings of a scientific conference. The goal is to build the final version of conference proceedings, including a list of accepted papers.</p>
<p>This case study has been inspired by the personal experience of the authors of <xref ref-type="bibr" rid="BIB6">Ciancarini et al.</xref> as PC members and especially by ideas described in <xref ref-type="bibr" rid="BIB18 BIB13 BIB16 BIB21">Sassone (1996), Mathews and Jacobs (1996), Niestrasz, 1997 and Tolksdorf (1998)</xref>. In fact, there are already a number of Web-based conference management systems.</p>
<p>We have been inspired by some of these systems that provide support to electronic submissions, collection of referee reports, and PC meetings based on standard Internet technologies, such as e-mail and WWW.</p>
<p>In our experience the most robust and rich in features are the systems supporting the WWW and the AAAI conferences. Information on these systems is scarce; our description of informal requirements above is an attempt to summarize some existing systems. Interestingly all the systems we have examined support different conference organizational models. For instance, there are systems supporting conferences organized as a set of workshops; there are systems where papers are classified by authors according to some keyword systems, and then they are automatically assigned to PC members after they have selected a set of keywords representing their ‘reviewing ability’. Most interestingly, only the simplest systems assume a centralized repository of papers and reviews. The system used for the WWW conference allows the authors to submit only the URL of their paper, which is then directly accessed by the reviewers only when necessary.</p>
<p>We are interested in using an agent-based software architecture. Furthermore, we will look for solutions supporting and coordinating both e-mail and WWW, in order to support both asynchronous and synchronous collaboration. Ideally, PC chairs, PC members and reviewers all have a reliable Internet connection, and work using a standard WWW browser. However, situations exist where this cannot be assumed: for instance, scientists usually travel a lot, and may have problems in having a persistent connection to the Internet. Moreover, most of the tasks to be performed are boring, long, and repetitive — e.g. fetching the papers, or filling referee report forms — and are better performed off-line.</p>
<sec id="SEC4"><label>3.1</label>
<title>Detailing the requirements</title>
<p>Following the idea that ‘coordination is the management of dependencies’ (<xref ref-type="bibr" rid="BIB12">Malone and Crowstone, 1994</xref>), we can state that conference workflow management is concerned with managing the dependencies of activities (the workflow) necessary to produce the proceedings of a scientific conference (and of course the list of authors invited to present their papers).</p>
<p>Most scientific communities have established policies and mechanisms implementing some kind of conference management aiming at minimizing the organizational efforts but keeping high the quality of papers being accepted and the fairness of the selection process. It is a usual choice that a program committee is established to take decisions about which papers are accepted and which are rejected. Authors interested in presenting their work submit papers to such a committee for review. Within the committee, a group decision has to be taken according to some fair policy. The decision is usually reached by reaching a consensus or voting or ranking submissions with the help of several reviewers who help the PC members in evaluating each paper.</p>
<p>The system we intend to specify includes several agents. We take the term agent as primitive; intuitively, an agent is an entity that can act autonomously; an agent can send/receive messages according to some well-known protocol (not necessarily reliable): e.g. paper mail, e-mail, HTTP, or others. All agents have unique identities; for simplicity, we define these identities as unique URLs.</p>
<p>For instance, an agent is the conference site. Other agents can communicate with the conference site using HTTP and mail protocols. Some agents are roles, namely they represent human users who can perform some operations: authors, reviewers, editors, PC chair, PC member.</p>
<p>The dynamics of the workflow is detailed in a number of tasks which the conference management system has to support. In some of these tasks there are some security and authentication issues at stake. The confidentiality of information needs to be ensured by using passwords and unique address for each instance of each role (PC member, author, reviewer, etc.) to which any communication is directed. The tasks are listed below in some arbitrary order.
<list list-type="bullet">
<list-item><p><italic>Submission of papers</italic>. A submission form is available on request on the conference site. Authors submit papers to the conference site, attaching to the form all the required documents (including the paper, or the URL of the paper). The submission is immediately and automatically checked. If it is not conformant to the stated requirements, the sender is automatically invited to resubmit. If it is conformant it is stored in the conference site and the sender gets an acknowledgement.</p></list-item>
<list-item><p><italic>Bidding for papers</italic>. Each PC member examines the list of submissions and selects a subset of ‘interesting’ papers to review. The PC chair can alter each subset to balance the review load among PC members.</p></list-item>
<list-item><p><italic>Distribution of the papers to the referees</italic>. After the deadline for submissions is expired, an agent sends by e-mail another agent to each PC member who, when run on the PC member's local system, fetches from a given URL all the papers assigned to that member for refereeing, and on request generates the forms for reviews to be sent by e-mail. Unauthorized access to all submitted papers has to be prevented, so that the list of the submissions itself — not to mention the papers — remains confidential.</p></list-item>
<list-item><p><italic>Collection of the reports</italic>. A WWW form is provided for online input of referee reports into the conference site. Also, forms can be obtained by sending an e-mail message to the conference site, and forms filled offline can be submitted directly by e-mail. This phase is managed by an agent that answers to requests of forms and collects the incoming reports. The agent generates a document for each submitted paper in which it collects the relative reports.</p></list-item>
<list-item><p><italic>PC meeting</italic>. An agent scans all reports for quantitative values and fills up a table that is used to generate statistics and an initial ranking of all the papers. When the PC members meet, they need to be able to access the list, the abstracts, and the files of the submissions, the referee reports, the ranking table. Furthermore, they need to read or write comments about the papers, and reach a consensus on which papers to accept and reject. This is provided via (password protected) links to appropriate agents. In addition, all the features are available by e-mail, by sending messages with suitable subjects and content to the mail server agent. Appropriate steps need to be taken if PC members are allowed to submit papers, and thus need to the refrained from accessing the comments on their own submissions.</p></list-item>
<list-item><p><italic>Communication of results</italic>. Once the list of accepted papers is formed, an agent takes care of communicating the results and the referee reports to the authors. Other agents generate a list of the abstracts of the accepted papers, possibly extract a list of subreferees to evaluate the referee reports, and finally prepare a synopsis of the result for the PC Chair.</p></list-item>
<list-item><p><italic>Submission of camera-ready versions of the papers</italic>. Authors of accepted papers submit camera-ready versions of their papers to the site of the conference. An agent controls the compliance of the submissions with the standards for camera-ready submissions of the publisher. Furthermore, it warns late authors, if any exist. When all the accepted papers had arrived, an agent collects them all, plus a preface from the editor of proceedings, and prepares a draft of the proceedings. The editor and the PC chairs are informed by e-mail when the proceedings are done.</p></list-item>
</list></p>
</sec>
</sec>
<sec id="SEC5"><label>4</label>
<title>The PageSpace</title>
<p>PageSpace is a reference architecture for multiagent applications built on top of the World Wide Web (<xref ref-type="bibr" rid="BIB4">Ciancarini et al., 1998</xref>). Its purpose is to allow the deployment of distributed applications using a coordination model, the communication among the different modules, and the WWW as the underlying presentation platform. PageSpace applications consist of a number of distributed agents that have to be coordinated to accomplish some cooperative tasks.</p>
<p>PageSpace includes a number of agent types, as shown in <xref ref-type="fig" rid="FIG1">Fig. 1</xref>.
<list list-type="bullet">
<list-item><p><italic>User-agents</italic> are user interface agents. User-agents consist of applets, scripts, and HTML pages.</p>
</list-item>
<list-item><p><italic>Home agents</italic> or <italic>avatars</italic> are persistent representations of users on the PageSpace. They allow the users to access the application agents on the PageSpace by means of the appropriate user-agents, and collect the messages addressed to the user-agents in the absence of the user. Home agents exploit the disconnected nature of the World Wide Web by allowing the graceful disappearance of remote entities of the cooperative tasks (such as human users and agents running on transient nodes of the network).</p></list-item>
<list-item><p><italic>Application agents</italic> perform the computations of the applications. They offer services by interacting with the shared data. Some application agents have to interact with the user, and therefore must be able to produce an interface, usually in the form of a user-agent that is then downloaded to the client. Others do not directly interact with the user, and just offer services to other application agents.</p></list-item>
<list-item><p><italic>Coordination language</italic> used for the specific implementation of a PageSpace. One such language is Jada, described in <xref ref-type="sec" rid="SEC6">Section 4.1</xref>.</p></list-item>
<list-item><p><italic>Gateway agents</italic> allow a PageSpace to interact with external environments such as other coordination environments or distributed middleware and applications residing outside the PageSpace.</p></list-item>
</list></p>
<fig position="float" id="FIG1"><label>Fig. 1</label>
<caption><p>The PageSpace reference architecture.</p></caption>
<graphic xlink:href="iwc13-677-f1.tif"></graphic>
</fig><p>Every browser includes at least one user-agent, which is connected and interacts directly with an avatar, running on a PageSpace server. A set of application agents implement the coordination mechanisms necessary to an active Web application. Gateway agents provide access to external services, like e-mail or a CORBA ORB.</p>
<p>The PageSpace reference architecture provides us with a generic framework to design and evaluate distributed applications on the Web.</p>
<p>Its main value, in our view, is that it provides an easily implementable solution for the main problems of the WWW in creating a distributed application, that is:
<list list-type="bullet">
<list-item><p>the directionality of the HTTP protocol;</p></list-item>
<list-item><p>the possibility of all the parts acting as clients of the HTTP connection to retract or disappear for some time from the shared coordination environment.</p></list-item>
</list></p>
<p>The concept of the avatar, a persistent representation of the disappearing agents that receives messages and in some ways act in place of the original agent, makes it possible to create a reliable distributed application even in the absence of some agents.</p>
<sec id="SEC6"><label>4.1</label>
<title>Jada</title>
<p>Jada (<xref ref-type="bibr" rid="BIB3">Ciancarini and Rossi, 1997</xref>) is a coordination language for Java. Using Jada we can coordinate parallel/distributed components using a set of operations introduced by the coordination language Linda. The main idea is to have a basic set of primitives that allow the user to implement both data exchange and synchronization using shared, structured, data spaces.</p>
<p>Jada extends Linda's basic concepts replacing tuple spaces with object spaces (i.e. specialized object containers) and allowing the creation of multiple spaces.</p>
<p>The basic entity in Jada is a Space. Agents can access the space by using a small set of simple primitives:
<list list-type="bullet">
<list-item><p>out(): put an object into the space;</p></list-item>
<list-item><p>read(): associatively retrieve an object from the space; if more objects can be retrieved the one returned is chosen non deterministically; if no object is available at the time of the call the calling thread is blocked until the operation can be successfully performed;</p></list-item>
<list-item><p>in(): works just like read but the returned object is removed from the space;</p></list-item>
</list></p>
<p>Non-blocking and time-out aware versions of the read() and in() operations are also available.</p>
<p>The associative access to the object space performed by the in() and read() operations is explained in detail in <xref ref-type="sec" rid="SEC8">Section 5.1</xref> where we will also see how Jada can provide a system based on PageSpace with a coordination kernel to deploy coordination-based multi-agent applications.</p>
<p>Note that after Java many other projects aiming at merging Java with various coordination technologies have been proposed. The most popular are probably JavaSpaces (<xref ref-type="bibr" rid="BIB20">SUN Microsystems, 1999</xref>) and TSpaces (<xref ref-type="bibr" rid="BIB23">Wyckoff et al., 1998</xref>) from SUN and IBM, respectively, but, while the general concepts applied are the same, they present many differences in practical development and design.</p>
</sec>
</sec>
<sec id="SEC7"><label>5</label>
<title>MUDWeb</title>
<p>We decided to use a MUD environment for implementing the conference management system. We used MUDWeb, an actual software architecture designed instantiating the PageSpace reference architecture on the MUD paradigm, and using Jada to provide the system with coordination facilities.</p>
<p>A MUD is a cooperative interactive environment shared by several people that use it to socialize and interact; MUDs have been proposed as enabling technologies for some kinds of groupware applications (<xref ref-type="bibr" rid="BIB22 BIB7 BIB10">Workshop Session of the ACM CSCW, 1996; Das et al. 1997; Doppke et al. 1998</xref>). A MUD usually represents the infrastructure of a role-playing game (hence the name) where human and robot players interact, visit dark and magical places, fight monsters or other players, and seek treasures. More generally, a MUD is an abstract platform that creates shared virtual realities. Thus, a MUD is a very powerful abstraction to describe a general platform for cooperative work (possibly on the WWW) that provides a general framework for users to interact with each other, and with resources such as documents.</p>
<p>MUDs are generally based on the concepts of rooms, items and players (or users). The whole virtual space inside a MUD is partitioned into rooms. Each room can contain several players and items. Each player can move from room to room, and can interact only with the items in the room he/she is in. Even interactions among users can take place only if the users are in the same room. In this context, the word room does not necessarily mean a closed place: a room in a MUD might virtually represent a cave in a dungeon or a garden around an enchanted castle. A room is simply a partition of the virtual space in which interactions take place. Players navigate through the rooms to interact, collect items and execute their goals. Players are not just humans: robot players behave just like other players but there is no human counterpart deciding their actual moves. The actions of the robot players are driven by (possibly intelligent) programs.</p>
<p>Mapping a MUD onto a coordination system based on multiple tuple spaces (like Jada) is quite straightforward: we can use a tuple space for each room; an item contained in a room is rendered as an object stored in an object space. Each player is an agent. Robot players are programs that access the MUD using the coordination primitives. We can use robot players to provide simple services to other users (in fact we will often refer to robot player as <italic>server agents</italic>). By interacting with a server agent, the users can activate a service and, eventually, gather its output. Since the relationship among agents in Jada takes place by exchanging data, the same mechanism is used for all the exchanges within the MUD.</p>
<p>From a software architecture point of view, MUDWeb consists of a number of services which agents can use according to a number of protocols based on object exchanges. Services wait for command objects and perform services based on their content. Services are generally very simple and specialized agents that react to a limited list of commands. The functionalities of an application are thus implemented by a score of services cooperating among themselves.</p>
<p><xref ref-type="fig" rid="FIG2">Fig. 2</xref> shows the software architecture of MUDWeb.</p>
<fig position="float" id="FIG2"><label>Fig. 2</label>
<caption><p>A MUD-like active Web.</p></caption>
<graphic xlink:href="iwc13-677-f2.tif"></graphic>
</fig>
<p>According to the PageSpace framework, we can identify three kinds of agents in MUDWeb: the avatars, the services, and the mudshell. The <italic>mudshell</italic> is the user agent, the interface framework where the interaction with the user takes place: it is a sophisticated HTML page with several widgets to provide commands for the user to interact with the services by providing a MUD-like text box for direct commands, and displaying the most common commands on appropriate buttons. The <italic>avatars</italic> are the home agents, persistent representations of a human user. The avatars provide the user interface with commands that are displayed within a WWW browser, especially for moving from one shared space to another, and can accept commands and return data in a variety of methods, including e-mail messages. The <italic>services</italic> are the application agents, the modules on the shared space that provide the actual computations of the distributed application.</p>
<sec id="SEC8"><label>5.1</label>
<title>Coordination in MUDWeb</title>
<p>The coordination facilities available for the agents running in MUDWeb are provided by MUDWeb itself. The implementation of the coordination facilities inside MUDWeb is based on Jada; we can then say that Jada acts as a coordination kernel for MUDWeb. MUDWeb, like Linda, adopts tuple spaces for coordination purposes but, differently with respect to Linda, it supports the concept of <italic>multiple nested tuple spaces</italic>, which form a hierarchical coordination structure based on the TupleSpace object. Hence the TupleSpace object offers some methods to the agents to ‘navigate’ through the coordination structure, and to express ‘itineraries’ as sequences of names similar to UNIX paths.</p>
<p>After having created a TupleSpace object, an agent can connect to a tuple space with the method join(). For instance, after the following statement
<list list-type="simple">
<list-item><p>TupleSpace ts=new TupleSpace();</p></list-item>
<list-item><p>ts.join(“spacel”);</p></list-item>
</list>
all operations on ts will be relative to the tuple space called ‘spacel’. Tuple space names can be specified with either a relative or an absolute name. It is also possible to move to the encompassing space by specifying the relative name ‘..’ as the argument to the method join(). For additional flexibility, the method leave() is provided to move to the encompassing tuple space, and the method leaveAll() to move to the root tuple space.</p>
<p>A tuple is represented by the Tuple class and contains a set of Java objects. After having created a tuple, we can insert it in a tuple space with the method out(), as in the following:
<list list-type="simple">
<list-item><p>Tuple alpha=new Tuple(“Hello!”, new Integer(1));</p></list-item>
<list-item><p>ts.out(alpha);</p></list-item>
</list></p>
<p>The methods in() and read() are used to retrieve tuples from tuple spaces.
<list list-type="simple">
<list-item><p>Result read(Tuple formal);</p></list-item>
<list-item><p>Result in(Tuple formal);</p></list-item>
</list></p>
<p>Tuples are retrieved from a tuple space using an associative mechanism: when an agent calls the method in(), it has to provide as parameter a tuple to be used as a matching pattern. The method in() returns any one tuple (if any exists) that matches the given pattern. The same applies to the method read(), the only difference being that in() also removes the tuple from the tuple space.</p>
<p>Two tuples match if they include the same number of items and each item of the first tuple matches the corresponding item of the second tuple. In order to have a flexible matching operation we introduce the concepts of formal and actual tuple items: a formal item is an instance of the Class class (the meta-class used in Java). Any other object is an actual item.</p>
<p>Formal items are used to associatively access the contents of the tuple space by exposing a ‘template’ of the items we are looking for. For instance, the following is a template tuple with an actual field accepting only the string ‘Hello’, and a formal field accepting any integer:
<list list-type="simple">
<list-item><p>Tuple template=new Tuple(“Hello!”, Integer.class);</p></list-item>
</list></p>
<p>The template tuple would then match both the tuples alpha and beta, but not gamma:
<list list-type="simple">
<list-item><p>Tuple beta=new Tuple(“Hello!”, new Integer(3));</p></list-item>
<list-item><p>Tuple gamma=new Tuple(“Hi!”, new Integer(7));</p></list-item>
</list></p>
<p>Differently from Jada, disruptive MUDWeb operations do not directly return the matched item but a placeholder represented by an instance of the Result class. The placeholder can then be used to test the availability of a result, to fetch it or to kill the request. Trying to fetch a tuple that is not available will block the calling thread, thus giving us the same synchronization mechanism used in Linda.</p>
<p>Tuple spaces in MUDWeb can either be ‘local’ (shared among concurrent threads running in the same Java Virtual Machine), or ‘remote’ (contained on — possibly — remote host and accessed via a proxy class). The main feature of MUDWeb to support mobile agents coordination is the ability of transparently abort and resend a request for a pending in() or read() operation even from different network locations. Thus, if an agent performs an in() operation on a remote tuple space, and the requested tuple is not available at call time, the request can migrate to another place and the Result object will still refer to a valid in() operation performed on that remote tuple space. This feature provides the programmer with a tool to handle agent mobility and eases the implementation of distributed systems based on MUDWeb.</p>
<p>In addition to the previous basic tuple operations, MUDWeb introduces a new coordinative computing framework based on tuple collections. A tuple collection, represented by the TupleCollection class, defines a sequence of tuples having the same signature. In order to build a tuple collection we write
<list list-type="simple">
<list-item><p>TupleSpace space=new TupleSpace();</p></list-item>
<list-item><p>Tuple pattern=new Tuple(String.class, Integer.class);</p></list-item>
<list-item><p>TupleCollection tc=new TupleCollection(space, pattern);</p></list-item>
<list-item><p>tc.add(new Tuple(“Hello!”, new Integer(1)));</p></list-item>
</list>
where space is the tuple space where all the collected tuples reside and pattern is a formal tuple which defines the signature of the collected tuples. Actual tuples can then be inserted in a collection using the add() method. An exception is thrown when the tuple to be added has a different signature from the one of the collection.</p>
<p>The main feature of collections is that, through the use of iterator objects, the tuples of a collection can be read or withdrawn in the same order they were inserted. Two predefined iterators are provided, ReadIterator and InIterator, but more advanced iterators can be added to the framework, provided that they implement the method nextTuple(). For instance, the following code reads all tuples from the previous collection:
<list list-type="simple">
<list-item><p>TupleIterator iterator=tc.readIterator();</p></list-item>
<list-item><p>Tuple result;</p></list-item>
<list-item><p>While(…){
<list list-type="simple">
<list-item><p>//get next tuple in this collection</p></list-item>
<list-item><p>result=iterator.nextTuple();</p></list-item>
<list-item><p>//use tuple items</p></list-item>
<list-item><p>…</p></list-item>
</list></p></list-item>
<list-item><p>}</p></list-item>
</list></p>
<p>The main feature of ReadIterator and InIterator is that the nextTuple() method is blocking. This way we can define an iterator that reads all tuples already inserted in the collection, but also all tuples that will be inserted in the future. The same result is obtained in other coordination languages such as Linda only by using an index as a tuple field; we believe iterators offer a more elegant solution.</p>
<p>Tuple collections and iterators capture a recurrent pattern of coordinative programming, the consummation of a sequence of tuples, and noticeably simplify the corresponding source code. Iterators are not built using a constructor, but with a factory method of the TupleCollection class. The main advantage is the possibility to develop extended collection classes that use the same factory method to create iterators. Iterators are also a well-known design pattern (<xref ref-type="bibr" rid="BIB11">Gamma et al., 1995</xref>) used to encapsulate access and traversal logic of an object container. Thus different iterators implements different access policies, leading to an improved design of the system.</p>
<p>To summarize: the coordination facilities available in MUDWeb are based on the Linda model (and are implemented using Jada as a coordination kernel) but extend it in various ways to better address the needs of open distributed collaborative applications like multiple distributed spaces, mobility support and bulk operations.</p>
<p>It should be noted that the differences between our system and other based on similar technologies but more focused on CSCW systems (such as the one presented in <xref ref-type="bibr" rid="BIB15">Matskin et al. (1998)</xref> have mostly to deal with the fact that we propose a generic infrastructure based on the MUD metaphore.</p>
</sec>
</sec>
<sec id="SEC9"><label>6</label>
<title>ConfManager</title>
<p>ConfManager is a conference management system based on MUDWeb that fulfills the requirements in <xref ref-type="sec" rid="SEC4">Section 3.1</xref>.</p>
<p>To better understand the relationships between PageSpace, MUDWeb and ConfManager we recall that PageSpace is a reference architecture, MUDWeb is an actual software platform that instatiates PageSpace and ConfManager is an application built on top of MUDWeb.</p>
<p>In ConfManagers submitted papers are stored in rooms; authors, reviewers, and program committee members are all represented by avatars in order to support both synchronous (HTTP) and asynchronous (e-mail) interactions.</p>
<p>Other ad hoc coordination-based conference management systems have been proposed (see, for example <xref ref-type="bibr" rid="BIB19">Scutella (1999)</xref>) but are not directly aimed for the WWW.</p>
<p>ConfManager includes the following rooms:
<list list-type="simple">
<list-item><p><italic>SubmittedPaper</italic>. Every paper is stored in one such room that is dynamically created when the paper is submitted. The room will also store the reviews when they are ready. The room also contains an avatar representing the corresponding author. The avatar can answer simple questions on the status of the submission.</p></list-item>
<list-item><p>ReviewRoom is used by reviewers to store drafts of their reviews.</p></list-item>
<list-item><p>SelectRoom is a room storing the scores assigned to papers. It is accessible to the program committee members only. The SubmittedPaper room temporarily contains the reviews for the paper it holds. After the reviews have been confirmed by the PC members, they are moved to this room.</p></list-item>
<list-item><p>Papers is a room containing organizational data, such as the full list of submitted papers and the addresses of the authors. It is reserved to the conference organizers.</p></list-item>
</list></p>
<p>All the services come in two flavors, synchronous and asynchronous. For instance, the synchronous service Services. Submitter accepts reviews coming from HTML forms displayed on the user's browser, while the asynchronous service Services.Announcer accepts reviews coming by e-mail. Asynchronous services rely upon avatars, which have to be programmed to perform the necessary tasks. For instance the PC Chair could program an avatar so that it forwards to his/her e-mail address each newly submitted paper (<xref ref-type="fig" rid="FIG3">Fig. 3</xref>).</p>
<fig position="float" id="FIG3"><label>Fig. 3</label>
<caption><p>Conference management mapped onto MUDWeb.</p></caption>
<graphic xlink:href="iwc13-677-f3.tif"></graphic>
</fig>
<p><xref ref-type="fig" rid="FIG4">Fig. 4</xref> shows the interface of a reviewer in the process of evaluating a paper. The interface is dynamically created by a MUDWeb agent that integrates with the HTTP server and act as a CGI entry-point.</p>
<fig position="float" id="FIG4"><label>Fig. 4</label>
<caption><p>The reviewer interface.</p></caption>
<graphic xlink:href="iwc13-677-f4.tif"></graphic>
</fig>
<p>While MUDWeb directly supports mobility we have not addressed this feature in the actual architecture. Distributing services around a LAN is in fact possible but space and location issues must be dealt with (see, for example <xref ref-type="bibr" rid="BIB9">Dix et al. (2000)</xref>).</p>
</sec>
<sec id="SEC10"><label>7</label>
<title>Conclusions and future work</title>
<p>The integration of this kind of documents, that are active like agents, into the active items of a MUD environment based on PageSpace, is very easy and opens new and interesting opportunities to design a document management system based on the MUD metaphor, the PageSpace architecture, and a technology like Java. MUD's robot players can be seen either as synthetic users or as active items. We pursued only the first approach. It is however evident that there are classes of applications in which the documents we have to deal with can be really ‘active’; i.e. are subject to auto-modifications.</p>
<p>A document that represents a stock exchange's portfolio, for example, should periodically update its own value. A document that represents a contract should change its own state (and may also warn its owner) when its expiration data is reached. We refer to this class of documents as <italic>active documents</italic>. Inside a MUD the conceptual operation of mapping active documents into synthetic players is not natural and not correct: players and active documents are different concepts. It seems evident that active documents should be mapped into active items. The problem we face, using this approach, is that we need a standard framework that enables us to represent both the contents of the document and its semantics.</p>
<p>XML (<xref ref-type="bibr" rid="BIB1">Bray et al., 1997</xref>) is an extensible markup language that provides a unified framework for describing in an orthogonal way a document's content, structure, and rendering. Introducing a technique that we call ‘displets’ (<xref ref-type="bibr" rid="BIB5">Ciancarini et al., 1999</xref>), our workgroup has integrated XML with a Turing-equivalent language, like Java or C-sharp, for manipulating the elements of an XML document. Displets allows us to produce active documents that can render themselves, or in general activate any arbitrary behavior based on their content: we are planning to use this concept to implement some general-purpose active documents.</p>
<p>We have presented in this paper an experience in document-centric groupware. We know that several systems exist which support conference management; some of them work over the WWW or over proprietary platforms like Lotus Notes. We have sketched a solution using PageSpace, an agent-based reference architecture used to design an actual software architecture based on the MUD metaphor. The case study we have exposed is intended as a benchmark to compare modern object oriented middleware infrastructures: for instance, we are developing a similar conference management system based on Lotus Notes and in a future paper we intend to compare it with the present solution based on PageSpace.</p>
<p>We have already noted that an interesting feature of the case study is that there exist several ‘conference models’, and that a truly flexible system should be able to support all of them. An issue that we have not discussed in this paper is what happens if documents to be managed are ‘active’, i.e. when they include not only some contents but also some code. In fact, possibly the most interesting issue we are exploring is the integration in a coordination environment of active documents written in XML integrated with Java. We expect that coordination technology offers further degrees of integration and flexibility.</p>
</sec>
</body>
<back>
<ack>
<title>Acknowledgements</title>
<p>This work had partial support from a grant of Microsoft Research Europe and a grant MURST 40% project SALADIN.</p></ack>
<ref-list>
<title>References</title>
<ref id="BIB1"><label>Bray et al., 1997</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Bray</surname><given-names>T</given-names></name><name><surname>Paoli</surname><given-names>J</given-names></name><name><surname>Sperberg-McQueen</surname><given-names>C</given-names></name></person-group>, <article-title>Extensible markup language (XML)</article-title>, <source>The World Wide Web Journal</source> <volume>2</volume> (<issue>4</issue>) <year>1997</year></citation>
</ref>
<ref id="BIB2"><label>Carriero and Gelernter, 1992</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Carriero</surname><given-names>N</given-names></name><name><surname>Gelernter</surname><given-names>D</given-names></name></person-group>, <article-title>Coordination languages and their significance</article-title>, <source>Communications of the ACM</source> <volume>35</volume> (<issue>2</issue>) <year>1992</year>) <fpage>xx</fpage></citation>
</ref>
<ref id="BIB3"><label>Ciancarini and Rossi, 1997</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Ciancarini</surname><given-names>P</given-names></name><name><surname>Rossi</surname><given-names>D</given-names></name></person-group>, <article-title>Jada: coordination and communication for Java agents</article-title>
<person-group person-group-type="editor"><name><surname>Vitek</surname><given-names>J</given-names></name><name><surname>Tschudin</surname><given-names>C</given-names></name></person-group> <article-title>Mobile Object Systems: Towards the Programmable Internet</article-title>
<source>Lecture Notes in Computer Science</source> <volume>vol. 1222</volume>
<year>1997</year> <publisher-name>Springer</publisher-name>, <publisher-loc>Berlin</publisher-loc><fpage>213</fpage>–<lpage>228</lpage></citation>
</ref>
<ref id="BIB4"><label>Ciancarini et al., 1998</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Ciancarini</surname><given-names>P</given-names></name><name><surname>Tolksdorf</surname><given-names>R</given-names></name><name><surname>Vitali</surname><given-names>F</given-names></name><name><surname>Rossi</surname><given-names>D</given-names></name><name><surname>Knoche</surname><given-names>A</given-names></name></person-group>, <article-title>Coordinating multiagent applications on the WWW: a reference architecture</article-title>, <source>IEEE Transactions on Software Engineering</source> <volume>24</volume> (<issue>5</issue>) <year>1998</year>) <fpage>362</fpage>–<lpage>375</lpage></citation>
</ref>
<ref id="BIB5"><label>Ciancarini et al., 1999</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Ciancarini</surname><given-names>P</given-names></name><name><surname>Vitali</surname><given-names>F</given-names></name><name><surname>Mascolo</surname><given-names>C</given-names></name></person-group>, <article-title>Managing complex documents over the WWW: a case study for XML</article-title>, <source>IEEE Transactions on Knowledge and Data Engineering</source> <volume>11</volume> (<issue>4</issue>) <year>1999</year>) <fpage>629</fpage>–<lpage>638</lpage></citation>
</ref>
<ref id="BIB6"><label>Ciancarini et al.</label>
<citation citation-type="other">P. Ciancarini, O. Niestrasz, R. Tolksdorf. A case study in coordination: conference Management on the Internet. <ext-link ext-link-type="uri" xlink:href="ftp://cs.unibo.it/pub/cianca/coordina.ps.gz">ftp://cs.unibo.it/pub/cianca/coordina.ps.gz</ext-link>.</citation>
</ref>
<ref id="BIB7"><label>Das et al., 1997</label>
<citation citation-type="other">T. Das et al., 1997. Developing social virtual worlds using NetEffect. In: Proceedings of the Sixth IEEE Workshops on Enabling Technologies: Infrastructure for Collaborative Enterprises (WETICE), Boston, IEEE Computer Soc. Press, Silver Spring, MD, June 1997, pp. 148–154,.</citation>
</ref>
<ref id="BIB9"><label>Dix et al., 2000</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Dix</surname><given-names>A</given-names></name><name><surname>Rodden</surname><given-names>T</given-names></name><name><surname>Davies</surname><given-names>N</given-names></name><name><surname>Trevor</surname><given-names>J</given-names></name><name><surname>Friday</surname><given-names>A</given-names></name><name><surname>Palfreyman</surname><given-names>K</given-names></name></person-group>, <article-title>Exploiting space and location as a design framework for interactive mobile systems</article-title>, <source>ACM Transactions on Computer–Human Interaction</source> <volume>7</volume> (<issue>3</issue>) <year>2000</year>) <fpage>285</fpage>–<lpage>321</lpage></citation>
</ref>
<ref id="BIB10"><label>Doppke et al., 1998</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Doppke</surname><given-names>J</given-names></name><name><surname>Heimbigner</surname><given-names>D</given-names></name><name><surname>Wolf</surname><given-names>A</given-names></name></person-group>, <article-title>Software process modeling and execution within virtual environments</article-title>, <source>ACM Transactions on Software Engineering and Methodology</source> <volume>7</volume> (<issue>1</issue>) <year>1998</year>) <fpage>1</fpage>–<lpage>40</lpage></citation>
</ref>
<ref id="BIB11"><label>Gamma et al., 1995</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Gamma</surname><given-names>E</given-names></name><name><surname>Helm</surname><given-names>R</given-names></name><name><surname>Johnson</surname><given-names>R</given-names></name><name><surname>Vlissides</surname><given-names>J</given-names></name></person-group>, <source>Design Patterns</source> <year>1995</year> <publisher-name>Addison-Wesley</publisher-name>, <publisher-loc>Reading, MA</publisher-loc></citation>
</ref>
<ref id="BIB12"><label>Malone and Crowstone, 1994</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Malone</surname><given-names>T</given-names></name><name><surname>Crowstone</surname><given-names>K</given-names></name></person-group>, <article-title>The interdisciplinary study of coordination</article-title>, <source>ACM Computing Surveys</source> <volume>26</volume> (<issue>1</issue>) <year>1994</year>) <fpage>87</fpage>–<lpage>119</lpage></citation>
</ref>
<ref id="BIB13"><label>Mathews and Jacobs, 1996</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Mathews</surname><given-names>G</given-names></name><name><surname>Jacobs</surname><given-names>B</given-names></name></person-group>, <article-title>Electronic management of the peer review process</article-title>, <source>Computer Networks and ISDN Systems</source> <volume>28</volume> (<issue>7–11</issue>) <year>1996</year>) <fpage>1523</fpage></citation>
</ref>
<ref id="BIB14"><label>Munson and Dewan, 1997</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Munson</surname><given-names>J</given-names></name><name><surname>Dewan</surname><given-names>P</given-names></name></person-group>, <article-title>Sync: a Java framework for mobile collaborative applications</article-title>, <source>IEEE Computer</source> <volume>30</volume> (<issue>6</issue>) <year>1997</year>) <fpage>59</fpage>–<lpage>66</lpage></citation>
</ref>
<ref id="BIB15"><label>Matskin et al., 1998</label>
<citation citation-type="other">Matskin, M., Divitini, M., Petersen, S., 1998. An architecture for multi-agent support in a distributed information technology application. In: Proceedings of the Workshop on Intelligent Agents in Information and Process Management, KI'98, TZI-Bericht no. 9, 1998, pp. 47–58.</citation>
</ref>
<ref id="BIB16"><label>Niestrasz, 1997</label>
<citation citation-type="other">O. Niestrasz, 1997. Identify the champion. <ext-link ext-link-type="uri" xlink:href="www.iam.unibe.ch/oscar/PDF/champion.fm.ps">www.iam.unibe.ch/oscar/PDF/champion.fm.ps</ext-link>.</citation>
</ref>
<ref id="BIB18"><label>Sassone, 1996</label>
<citation citation-type="other">V. Sassone, 1996. Management of electronic submission, refereeing, and PC meeting. Manual of a WWW system, November 1996.</citation>
</ref>
<ref id="BIB19"><label>Scutella, 1999</label>
<citation citation-type="other">Scutella, A., 1999. Simulation of conference management using an event-driven coordination language. In: Proceedings of the Third International Conference on Coordination Models and Languages, LNCS vol. 1594, Springer, Berlin, pp. 243–258.</citation>
</ref>
<ref id="BIB20"><label>SUN Microsystems, 1999</label>
<citation citation-type="other">SUN Microsystems, 1999. JavaSpaces specifications. White paper, January 1999.</citation>
</ref>
<ref id="BIB21"><label>Tolksdorf, 1998</label>
<citation citation-type="other">R. Tolksdorf, 1998. Conference reviewing. <ext-link ext-link-type="uri" xlink:href="grunge.cs.tu-berlin.de/~tolk/reviewing.html">grunge.cs.tu-berlin.de/~tolk/reviewing.html</ext-link>.</citation>
</ref>
<ref id="BIB22"><label>Workshop Session of the ACM CSCW, 1996</label>
<citation citation-type="other">Workshop Session of the ACM CSCW, 1996. Design and use of MUDs for serious purposes. In: Proceedings of the ACM 1996 conference on Computer Supported Cooperative Work.</citation>
</ref>
<ref id="BIB23"><label>Wyckoff et al., 1998</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Wyckoff</surname><given-names>P</given-names></name><name><surname>McLaughry</surname><given-names>S</given-names></name><name><surname>Lehman</surname><given-names>T</given-names></name><name><surname>Ford</surname><given-names>D</given-names></name><name><surname>Spaces</surname><given-names>T</given-names></name></person-group>, <source>IBM Systems Journal</source> <volume>37</volume> (<issue>3</issue>) <year>1998</year>) <fpage>454</fpage>–<lpage>474</lpage></citation>
</ref>
</ref-list>
<ref-list>
<title>Further reading</title>
<ref id="BIB8"><label>Divitini and Simone, 2000</label>
<citation citation-type="journal"><person-group person-group-type="author"><name><surname>Divitini</surname><given-names>M</given-names></name><name><surname>Simone</surname><given-names>C</given-names></name></person-group>, <article-title>Supporting different dimension of adaptability in workflow modeling. Computer supported cooperative work</article-title>, <source>The Journal of Collaborative Computing</source> <volume>9</volume> (<issue>3</issue>) <year>2000</year>
<fpage>365</fpage>–<lpage>397</lpage><comment>(special issues on Adaptive Workflow)</comment></citation>
</ref>
<ref id="BIB17"><label>Petersen et al., 2001</label>
<citation citation-type="other">S. Petersen, M. Divitini, M. Matskin, 2001. An agent-based approach to modeling Virtual Enterprises accepted for publication in International Journal of Production, Planning and Control, special issue on Enterprise Modelling, Taylor & Francis, London (in press).</citation>
</ref></ref-list>
</back>
</article></istex:document></istex:metadataXml><mods version="3.6"><titleInfo><title>Designing a document-centric coordination application over the Internet</title></titleInfo><titleInfo type="alternative" contentType="CDATA"><title>Designing a document-centric coordination application over the Internet</title></titleInfo><name type="personal"><namePart type="given">Paolo</namePart><namePart type="family">Ciancarini</namePart><affiliation>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</affiliation><affiliation>Corresponding author. Tel.: +3951-351506; fax: +3951-354510</affiliation><role><roleTerm type="text">author</roleTerm></role></name><name type="personal"><namePart type="given">Davide</namePart><namePart type="family">Rossi</namePart><affiliation>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</affiliation><affiliation>RossiDavide</affiliation><role><roleTerm type="text">author</roleTerm></role></name><name type="personal"><namePart type="given">Fabio</namePart><namePart type="family">Vitali</namePart><affiliation>Dipartimento di Scienze dell'Informazione, University of Bologna, Mura Anteo Zamboni 7, I-40127 Bologna, Italy</affiliation><affiliation>VitaliFabio</affiliation><role><roleTerm type="text">author</roleTerm></role></name><typeOfResource>text</typeOfResource><genre type="research-article" displayLabel="research-article" authority="ISTEX" authorityURI="https://content-type.data.istex.fr" valueURI="https://content-type.data.istex.fr/ark:/67375/XTP-1JC4F85T-7">research-article</genre><originInfo><publisher>Oxford University Press</publisher><place><placeTerm type="text">Oxford, UK</placeTerm></place><dateIssued encoding="w3cdtf">2001-08</dateIssued><copyrightDate encoding="w3cdtf">2001</copyrightDate></originInfo><abstract>In this paper we describe an experience in designing a groupware application distributed over the WWW to solve a conference management problem. The system we design coordinates the activities of several people engaged in reviewing and selecting papers submitted for a scientific conference. We discuss why such an application is interesting and describe how we designed it. The architecture we suggest implements what we call an active Web, because it includes entities which we are able to use and provide services offered through WWW infrastructures. Users, agents, and active documents can interoperate using a set of basic services for communication and synchronization. The active Web infrastructure we describe here is based on coordination technology integrated with Java.</abstract><note type="author-notes">*Corresponding author. Tel.: +3951-351506; fax: +3951-354510</note><subject><genre>keywords</genre><topic>Coordination</topic><topic>WWW architectures</topic><topic>Collaborative platforms</topic><topic>CSCW</topic></subject><relatedItem type="host"><titleInfo><title>Interacting with Computers</title></titleInfo><genre type="journal" authority="ISTEX" authorityURI="https://publication-type.data.istex.fr" valueURI="https://publication-type.data.istex.fr/ark:/67375/JMC-0GLKJH51-B">journal</genre><identifier type="ISSN">0953-5438</identifier><identifier type="eISSN">1873-7951</identifier><identifier type="PublisherID">iwc</identifier><identifier type="PublisherID-hwp">iwc</identifier><part><date>2001</date><detail type="volume"><caption>vol.</caption><number>13</number></detail><detail type="issue"><caption>no.</caption><number>6</number></detail><extent unit="pages"><start>677</start><end>693</end></extent></part></relatedItem><identifier type="istex">8C5E7EC4B48C7CFF58C9307FD72802B47258BDBC</identifier><identifier type="DOI">10.1016/S0953-5438(01)00037-6</identifier><accessCondition type="use and reproduction" contentType="copyright">© 2001 Elsevier Science B.V. All rights reserved.</accessCondition><recordInfo><recordContentSource authority="ISTEX" authorityURI="https://loaded-corpus.data.istex.fr" valueURI="https://loaded-corpus.data.istex.fr/ark:/67375/XBH-GTWS0RDP-M">oup</recordContentSource><recordOrigin>© 2001 Elsevier Science B.V. All rights reserved.</recordOrigin></recordInfo></mods><json:item><extension>json</extension><original>false</original><mimetype>application/json</mimetype><uri>https://api.istex.fr/ark:/67375/HXZ-LFJM2JKP-7/record.json</uri></json:item></metadata><serie></serie></istex></record>Pour manipuler ce document sous Unix (Dilib)
EXPLOR_STEP=$WICRI_ROOT/Wicri/Informatique/explor/SgmlV1/Data/Istex/Corpus
HfdSelect -h $EXPLOR_STEP/biblio.hfd -nk 002429 | SxmlIndent | more
Ou
HfdSelect -h $EXPLOR_AREA/Data/Istex/Corpus/biblio.hfd -nk 002429 | SxmlIndent | more
Pour mettre un lien sur cette page dans le réseau Wicri
{{Explor lien
|wiki= Wicri/Informatique
|area= SgmlV1
|flux= Istex
|étape= Corpus
|type= RBID
|clé= ISTEX:8C5E7EC4B48C7CFF58C9307FD72802B47258BDBC
|texte= Designing a document-centric coordination application over the Internet
}}
| This area was generated with Dilib version V0.6.33. |  |