XML is a widespread W3C standard used by several kinds of applications for data representation and exchange over the web. In the context of a system that provides semantic integration of heterogeneous XML sources, the same information at a semantic level may have different representations in XML. However, the syntax of an XML query depends on the structure of the specific XML source. Therefore, in order to obtain the same query result, one must write a specific query for each XML source. To deal with such problem, a much better solution is to state queries against a global conceptual schema and then translate them into an XML query against each specific data source. This paper presents CXPath (Conceptual XPath), a language for querying XML sources at the conceptual level, as well as a translation mechanism that converts a CXPath query to an XPath query against a specific XML source.

This work presents an OO software production method that defines a systematic process for conceptual modelling of web applications. The paper discusses a set of minimum primitives to capture the essentials of dynamic web applications and it discusses how to introduce them in a classical model-centered OO method that provides systematic code generation. Finally, the paper presents some ideas to extend this generation process for developing web solutions taking as an input these web enhanced conceptual schemas.

While the Internet has facilitated access to information sources, the task of scalable integration of these heterogeneous data sources remains a challenge. The adoption of the eXtensible Markup Language (XML) as the standard for data representation and exchange has led to an increasing number of XML data sources, both native and non-native. Recent integration work has mainly focused on developing matching techniques to find equivalent elements and attributes among the different XML sources. In this paper, we introduce a semantic approach to resolve structural conflicts in the integration of XML schemas. We employ a data model called the ORA-SS (Object-Relationship-Attribute Model for Semi-Structured Data) to capture the implicit semantics in an XML schema. We present a comprehensive algorithm to integrate XML schemas. Compared to existing methods, our algorithm adopts an n-nary integration strategy that takes into account the data semantics, importance of a source, and how the majority of the sources model their data when resolving structural conflicts such as attribute/object class conflict and ancestor-descendant conflict. Further, redundant object classes and transitive relationship sets are removed to obtain a more concise integrated schema.

The availability of large amounts of heterogeneous distributed web data necessitates the integration and querying of XML data from multiple XML sources for many reasons. For example, currently many government agencies in US such as IRS, INS, FBI, CIA are integrating their system to deal with new security threats, and these different departments uses legacy database systems including relational data, flat files, spreadsheets, and html pages, and simple text data. Similarly, there are many e-commerce companies, which sell similar products but represent data using different XML schemas. When any two such companies merge, or make an effort to service customers in cooperation, there is a need for a uniform schema integration methodology. In some applications like comparison-shopping, there is a need for an illusionary centralized homogeneous information system. Such systems need a uniform data representation and access platform, which is provided by XML. However, the XML schema and data are still heterogeneous and represent their constraints differently. To avoid the overhead of system integration and system specific data access mechanisms, applications should be provided with data in an integrated form. The idea is to use XML as an intermediate medium to achieve date integration from heterogeneous data resources. There are many efforts currently on generating views or representing data in only XML format, but internally stored in legacy databases. Using wrappers, applications can view the data in XML, instead of moving the data from their original format to XML. However, wrappers fail if the structure of the data is dynamically changed. Our approach is two phase; the integration of the local XML schemas into a global schema, and the integration of the resultant XML data produced in response to the queries to the local XML data sources. A global schema eliminates data model differences by integrating local schemas. The heterogeneous XML data sources need not be represented in an integrated fashion. This is because integrating the XML data and storing it in the new integrated schema occupies extra resources, and may result in duplication, and thus, creates the problems of multiple updates and data inconsistencies. For this reason, we present a dynamic mechanism, which can interface the different XML data and can present an integrated representation of the XML sources, rather than physically integration of data.

The need for managing large repositories of data coming from XML documents is increasing; in fact, XML is emerging as the standard format for documents exchanged over the internet. At University of Bergamo, recently we developed the ERX Data Management System, to study issues concerning the management of data coming from XML documents; its data model, called ERX (Entity Relationship for XML), being an extension of the classical ER model, allows to deal with concepts coming from XML documents at the conceptual level, and allows to reason about integration of data coming from different XML document classes. This paper focuses on the problem of automatically deriving Entity-Relationship Schemas (ERX Schemas) from DTDs (Document Type Definition). In fact, the derivation of such schemas from DTDs might be a hard work to do by hand, since real DTDs are very complex and large.

Much research has been devoted over the years to investigating and advancing the techniques and tools used by analysts when they model. As opposed to what academics, software providers and their resellers promote as should be happening, the aim of this research was to determine whether practitioners still embraced conceptual modelling seriously. In addition, what are the most popular techniques and tools used for conceptual modelling? What are the major purposes for which conceptual modelling is used? The study found that the top six most frequently used modelling techniques and methods were ER diagramming, data flow diagramming, systems flowcharting, workflow modelling, RAD, and UML. However, the primary contribution of this study was the identification of the factors that uniquely influence the continued-use decision of analysts, viz., communication (using diagrams) to/from stakeholders, internal knowledge (lack of) of techniques, user expectations management, understanding models integration into the business, and tool/software deficiencies.

An open challenge is to integrate XML and conceptual modeling in order to satisfy large-scale enterprise needs. Because enterprises typically have many data sources using different assumptions, formats, and schemas, all expressed in — or soon to be expressed in — XML, it is easy to become lost in an avalanche of XML detail. This creates an opportunity for the conceptual modeling community to provide improved abstractions to help manage this detail. We present a vision for Conceptual XML (C-XML) that builds on the established work of the conceptual modeling community over the last several decades to bring improved modeling capabilities to XML-based development. Building on a framework such as C-XML will enable better management of enterprise-scale data and more rapid development of enterprise applications.

XML is an effective universal data-interchange format, and XML Schema has become the preeminent mechanism for describing valid XML document structures. Generalization/specialization and its constraints are fundamental concepts in system modeling and design, but are difficult to express and enforce with XML Schema. This mismatch leads to unnecessary complexity and uncertainty in XML-based models. In this paper we describe how to translate various aspects of generalization/specialization from a conceptual model into XML Schema. We also explore what needs to be added to XML Schema to handle the other aspects of this fundamental modeling construct. If XML Schema were to include our proposed constructs, it would be fully capable of faithfully representing generalization/specialization, thus reducing the complexity of the XML models that rely on generalization/specialization.

The Extensible Markup Language (XML) is based on the concept of schema languages, which are used for validation of XML documents. In most cases, the metamodeling view of XML-based application is rather simple, with XML documents being instances of some schema, which in turn is based on some schema language. In this paper, a metaschema layering approach for XML is presented, which is demonstrated in the context of various application scenarios. This approach is based on two generalizations of the standard XML schema language usage scenario: (1) it is assumed that one or more schema languages are acceptable as foundations for an XML scenario, but these schema languages should be customized by restricting, extending, or combining them; (2) for applications requiring application-specific schema languages, these schema languages can be implemented by reusing existing schema languages, thus introducing an additional metaschema layer. Metaschema layering can be used in a variety of application areas, and this paper shows some possible applications and mentions some more possibilities. XML is increasingly entering the modeling domain, since it is gradually moving from an exchange format for structured data into the applications as their inherent model. XML modeling still is in its infancy, and the metaschema layering approach presented in this paper is one contribution how to leverage the most important of XML feature's, which is the reuse of existing concepts and implementations.

Today, XML is primarily regarded as a syntax for exchanging structured data, and therefore the question of how to develop well-designed XML models has not been studied extensively. As applications are increasingly penetrated by XML technologies, and because query and programming languages provide native XML support, it would be beneficial to use these features to work with well-designed XML models. In order to better focus on XML-oriented technologies in systems engineering and programming languages, an XML modeling language should be used, which is more focused on modeling and structure than typical XML schema languages. In this paper, we examine the current state of the art in XML schema languages and XML modeling, and present a list of requirements for a XML conceptual modeling language.

The goal of this article is to present an algorithm to simplify the automatic generation of descriptions of XML document structures. In particular we show how to obtain a DTD (document type definition) for data whose structure is described by a conceptual data model. An important objective of this translation is to preserve as much structural information from the conceptual schema as possible. This enables partial constraint checking by validating XML parsers and thus simplifies exchange of data between different databases, in particular the import of data in an XML document into another database schema. In detail we present translations of all constructs of an extended entity-relationship model to DTDs and integrate these into an algorithm. By basing the algorithm on conceptual schemas it is very general and may be customized for data in (object-)relational databases as well as data in databases of any other paradigm, e.g. native XML databases.

The need for managing large repositories of data coming from XML documents is increasing, in particular to support new EDI applications and information systems which provide e-commerce functionality. In fact, XML is emerging as the standard format for documents exchanged over the internet; then information systems will have to deal with XML documents, both incoming and outcoming. This is an exciting research area, because new technologies are arising, such as XSLT, but former and rather stable technologies, such as relational DBMSs, still have to play an important role. It is clear that novel information systems will integrate different technologies, but at the moment it is not clear how. This paper reports about our experience in developing the ERX Data Management System, a system devised to collect data coming from different XML data sources, and store them into a database in a way independent of the source format; its query language, named ERX-QL, is able to query the database and generate new XML documents. We developed the ERX Data Management System to explore the possibility of integrating three different basic technologies, Relational DBMS, Java and XSLT, under a unifying framework which makes the system interoperable w.r.t. the particular adopted technology (for example Relational vs Object-Oriented database technology); hence, this framework is based on an Entity-Relationship-like Data Model (ERX), which is not tied to any specific technical and/or commercial solution. The paper discusses the architecture of the ERX system, and the adopted technical solutions.

XML Schemas provide a generalization of Document Type Definitions for describing the validity of a set of XML documents. There is a growing number of applications that deal with XML documents in various respects. One area of programs is concerned with analyzing XML documents arriving, for example, over the internet. Another rapidly expanding area is best described by the term XML generators. XML generators usually are part of a WWW system, for example generators for XML documents serving as views of data bases. Although XML Schemas provide a concise means for describing the syntax of correct XML documents in a specific domain, XML generators usually treat the XML documents as unstructured strings or, in the context of the Document Object Model, as trees the nodes of which belong to an unspecific Element-interface. The syntactical correctness, i.e. the validity of the generated XML documents cannot be guaranteed at compile time but must be tested at runtime. This means that, in general, t here is no ultimate proof that an XML generator generates only valid documents according to an underlying XML schema. This paper addresses this problem by introducing a new distinct interface for each element defined within an XML schema. Each interface extends the Element-interface of the Document Object Model. This mechanism provides a generalization of a previous approach based on the weaker concept of Document Type Definitions presented by the authors.

The goal of this paper is to propose a method in which relational database system is used to process queries on semistructured data. The method uses a combination of relational and semistructured techniques to process XML documents. First, the document is entirely stored within the relational system. Next, an SQL query is evaluated over the relational data representing XML document. Finally, the resulting XML document is constructed which, in turn, can be represented in the standard way within relational database system (by means of an edge table). The proposed method is presented as the XML-SQL language. The language is described formally and by a number of examples. Some implementation solutions are described.

The location path language XPath is of particular importance for XML applications since it is a core component of many XML processing standards such as XSLT or XQuery. In this paper, based on axis symmetry of XPath, equivalences of XPath 1.0 location paths involving reverse axes, such as anc and prec, are established. These equivalences are used as rewriting rules in an algorithm for transforming location paths with reverse axes into equivalent reverse-axis-free ones. Location paths without reverse axes, as generated by the presented rewriting algorithm, enable efficient SAX-like streamed data processing of XPath.

Database systems are well-known for consistent storage, retrieval, and manipulation of data. At the same time, the Extensible Markup Language (XML) is generally accepted as data description language for both web-based information systems and electronic data interchange between different organizations. Since database systems form the backbone of essentially any information system, the integration of XML and database systems is a must. Data model heterogeneity and schema heterogeneity, however, makes this a challenging task, for example when mapping XML documents to relational database systems (RDBS). This paper focuses on data model heterogeneity and provides an in-depth comparison of concepts available in RDBS and XML schema specification languages, comprising XML DTD and XML Schema. Such an analysis provides the basis for developing appropriate middleware bridging the gap between XML and RDBS.

XML is rapidly becoming the standard method for sending information across the Internet. XML Schema, since its elevation to W3C Recommendation on the 2nd May 2001, is fast becoming the preferred means of describing structured XML data. However, until recently, there has been no effective means of graphically designing XML Schemas without exposing designers to low-level implementation issues. Bird, Goodchild and Halpin (2000) proposed a method to address this shortfall using the 'Object Role Modelling' conceptual language to generate XML Schemas. This paper seeks to build on this approach by defining a mapping between the Unified Modeling Language (UML) class diagrams and XML Schema using the traditional three level database design approach (ie. using conceptual, logical and physical design levels). In our approach, the conceptual level is represented using standard UML class notation, annotated with a few additional conceptual constraints, the logical level is represented in UML, using a set of UML stereotypes, and the XML Schema itself represents the physical level. The goal of this three level design methodology is to allow conceptual level UML class models to be automatically mapped into the logical level, while minimizing redundancy and maximizing connectivity.

With the advent of XML and its use as a database language, dependency and normal form theory has attracted novel research interest. Several approaches to build up a dependency and normal form theory for XML databases have been published, mainly concentrating on functional dependencies and keys. XML-like database structures can be modelled by rational trees using constructors for lists and disjoint unions. This involves restructuring rules on subattributes. The absence of redundancy can be characterised by the nested list normal form. If ordering is ignored, constructors for sets or multisets have to be employed. For these the theory can be extended using counter-free functional dependencies. Finally, for keys an important research question is which systems of subattributes permit Armstrong instances. While this gives just a glimpse of a starting promising theory, a research agenda for further research will be set up.

With the rise of the Web as the major platform for making data and services available for both, humans and applications, interorganizational workflows became a crucial issue. Several languages for the specification of interorganizational workflows have been already proposed, each of them having different origins and pursuing different goals for dealing with the unique characteristics of interorganizational workflows. This paper compares these proposals, trying to identify their strengths and shortcomings. As a pre-requisite, a framework of requirements is suggested which categorizes the major characteristics of specification languages for interorganizational workflows into different perspectives. For each of these perspectives, a set of functional requirements is proposed thereby emphasizing the difference to traditional intraorganizational workflows. On the basis of this framework, seven representative specification languages are surveyed and compared to each other.

XML is fast becoming the standard for information exchange on the WWW. As such, information expressed in XML will need to be integrated with existing information systems, which are mostly based on structured data models such as relational, object-oriented or object/relational data models. This paper shows how our previous framework for integrating heterogeneous structured data sources can also be used for integrating XML data sources with each other and/or with other structured data sources. Our framework allows constructs from multiple modelling languages to co-exist within the same intermediate schema, and allows automatic translation of data, queries and updates between semantically equivalent or overlapping heterogenous schemas.

Semistructured data has become prevalent with the growth of the Internet. The data is usually stored in a database system or in a specialized repository. Many information providers have presented their databases on the web as semistructured data, while others are developing repositories for new applications. Designing a “good” semistructured database is important to prevent data redundancy and updating anomalies. In this paper, we propose a conceptual approach to design semistructured databases. A conceptual layer based on the Entity-Relationship model is used to remove redundancies at the semantic level. An algorithm to map an ER diagram involving composite attributes weak entity types, recursive, n-ary and ISA relationship sets, and aggregations to a semistructured schema graph (S3-Graph) is also given.

The unique selling point of XML as standard representation of content is its ease of use thus facilitating interoperability between various partners and platforms. To overcome XML Schema's weakness concerning semantic expressiveness, tailored XML schema languages would be favorable to represent domain specific knowledge. The contribution of this paper is to identify various approaches to implementing tailored XML schema languages with XML Schema.

Web services are emerging as a promising technology for the effective automation of inter-organizational interactions. However, despite the growing interest, several issues still need to be addressed to provide Web services with benefits similar to what traditional middleware brings to intra-organizational application integration. In this paper, we present a framework that supports the model-driven development of Web services. Specifically, we show how, starting from the external specifications of a Web service (e.g., interface and protocol specifications), we can support the generation of extensible service implementation templates as well as of complete (executable) service specifications, thereby considerably simplifying the service development work.

In software engineering as well as in any engineering domain, a way of customizing the collaborative work to various modes of collaboration, i.e. synchronous and asynchronous, and the possibility of alternating these modes along the phases of a project is required. Our goal is to develop a universal information platform that can support collaboration in a range of application domains, the basic sharing unit being the document. Since not all user groups have the same conventions and not all tasks have the same requirements, this implies that it should be possible to customize the collaborative environment at the level of both communities and individual tasks. In this paper we present the consistency maintenance models underlying the synchronous and asynchronous modes of collaboration. We highlight the importance of choosing a general structured model of the document and particularly analyze the multi-mode collaboration for two main representative types of documents: textual and graphical.

The Extensible Markup Language (XML) has found acceptance as a standard for storing and exchanging structured and semi-structured data. With its expressive power, XML enables a great variety of applications relying on such structures. As the data schema, an XML schema is a means by which documents and objects can be structured. Our approach is to model XML schemata and thus classes of documents on the basis of UML (Unified Modeling Language). We consider UML to be the connecting link between software engineering and document design, i.e., it is possible to design object-oriented software together with the necessary XML structures. For this reason, we describe how to transform the static part of UML, i.e. class diagrams, into XML schemata. The major challenge for the transformation is to define a suitable mapping reflecting the semantics of a UML specification in an XML schema correctly. Because of XML's specific properties, we slightly extend UML in a UML compliant way. Additionally, the resulting XML schema profile supports the tuning of the transformation to XML schema. Our approach provides the stepping stone to bridge the gap between object-oriented software design and the development of XML data schemata.

The goal of automating information systems building was stated in the sixties. Forty years later it is clear that the goal has not been achieved in a satisfactory degree. One of the problems has been the lack of standards in languages and platforms. In this respect, the recent efforts on standardization provide an opportunity to revive the automation goal. This is the main purpose of this paper. We have named the goal "conceptual schema-centric development" (CSCD) in order to emphasize that the conceptual schema should be the center of the development of information systems. We show that to develop an information system it is necessary to define its conceptual schema and that, therefore, the CSCD approach does not place an extra burden on developers. In CSCD, conceptual schemas would be explicit, executable in the production environment and the basis for the system evolution. To achieve the CSCD goal it is necessary to solve many research problems. We identify and comment on a few problems that should be included in a research agenda for CSCD. Finally, we show that the CSCD goal can be qualified as a grand challenge for the information systems research community.

To cope with the ever increasing diversity of markup languages, programming languages, tool kits and interface development environments, conceptual modeling of user interfaces could bring a framework for specifying, designing, and developing user interfaces at a level of abstraction that is higher than the level where code is merely manipulated. For this purpose, a complete environment is presented based on conceptual modeling of user interfaces of information systems structured around three axes: the models that characterize a user interface from the end user's viewpoint and the specification language that allows designers to specify such interfaces, the method for developing interfaces in forward, reverse, and lateral engineering based on these models, and a suite of tools that support designers in applying the method based on the models. This environment is compatible with the Model-Driven Architecture recommendations in the sense that all models adhere to the principle of separation of concerns and are based on model transformation between the MDA levels. The models and the transformations of these models are all expressed in UsiXML (User Interface eXtensible Markup Language) and maintained in a model repository that can be accessed by the suite of tools. Thanks to this environment, it is possible to quickly develop and deploy a wide array of user interfaces for different computing platforms, for different interaction modalities, for different markup and programming languages, and for various contexts of use.

The eXtensible Markup Language (XML) is increasingly finding acceptance as a standard for storing and exchanging structured and semi-structured information. With its expressive power, XML enables a great variety of applications relying on such structures — notably product catalogs, digital libraries, and electronic data interchange (EDI). As the data schema, an XML Document Type Definition (DTD) is a means by which documents and objects can be structured. Currently, there is no suitable way to model DTDs conceptually. Our approach is to model DTDs and thus classes of documents on the basis of UML (Unified Modeling Language). We consider UML to be the connecting link between software engineering and document design, i.e., it is possible to design object-oriented software together with the necessary XML structures. For this reason, we describe how to transform the static part of UML, i.e. class diagrams, into XML DTDs. The major challenge for the transformation is to define a suitable mapping reflecting the semantics of a UML specification in a DTD correctly. Because of XML's specific properties, we slightly extend the UML language in a UML-compliant way. Our approach provides the stepping stone to bridge the gap between object-oriented software design and the development of XML data schemata.

XML is increasingly becoming the preferred method of encoding structured data for exchange over the Internet. XML-Schema, which is an emerging text-based schema definition language, promises to become the most popular method for describing these XML-documents. While text-based languages, such as XML-Schema, offer great advantages for data interchange on the Internet, graphical modelling languages are widely accepted as a more visually effective means of specifying and communicating data requirements for a human audience. With this in mind, this paper investigates the use of Object Role Modelling (ORM), a graphical, conceptual modelling technique, as a means for designing XML-Schemas. The primary benefit of using ORM is that it is much easier to get the model ‘correct' by designing it in ORM first, rather than in XML. To facilitate this process we describe an algorithm that enables an XML-Schema file to be automatically generated from an ORM conceptual data model. Our approach aims to reduce data redundancy and increase the connectivity of the resulting XML instances.

Most research on XML has so far largely neglected the data modeling aspects of XML schemas. In this paper, we attempt to make a systematic approach to data modeling capabilities of XML schemas. We first formalize a core set of features among a dozen competing XML schema language proposals and introduce a new notion of XGrammar. The benefits of such formal description is that it is both concise and precise. We then compare the features of XGrammar with those of the Entity-Relationship (ER) model. We especially focus on three data modeling capabilities of XGrammar: (a) the ability to represent ordered binary relationships, (b) the ability to represent a set of semantically equivalent but structurally different types as "one" type using the closure properties, and (c) the ability to represent recursive relationships.

XML is a common standard for semi-structured and structured data representation and exchange over the Web. This paper describes a semi-automatic process for converting an XML DTD to a schema in a canonical conceptual model based on ORM/NIAM and extended ER models. This process is part of a bottom-up approach for integration of XML sources that takes a set of DTDs and generates an ontology for query purposes. A conceptual schema for a DTD simplifies the integration activity because provides a semantically rich representation of an XML source. The core of the process is a set of conversion rules that consider the DTD structure and heuristics related to default semantic interpretations on such structure in order to generate the corresponding concepts in the canonical conceptual schema.

Many XML documents are being produced, but there are no agreed-upon standards formally defining what it means for complying XML documents to have “good” properties. In this paper we present a formal definition for a proposed canonical normal form for XML documents called XNF. XNF guarantees that complying XML documents have maximally compact connectivity while simultaneously guaranteeing that the data in complying XML documents cannot be redundant. Further, we present a conceptual-model-based methodology that automatically generates XNF-compliant DTDs and prove that the algorithms, which are part of the methodology, produce DTDs to ensure that all complying XML documents satisfy the properties of XNF.

Much research has focused on the problem of knowledge accessibility, sharing and reuse. Specific languages (e.g. KIF, CG, RDF) and ontologies have been proposed. Common characteristics, conventions or ontological distinctions are beginning to emerge. Since knowledge providers (humans and software agents) must follow common conventions for the knowledge to be widely accessed and re-used, we propose lexical, structural, semantic and ontological conventions based on various knowledge representation projects and our own research. These are minimal conventions that can be followed by most and cover the most common knowledge representation cases. However, agreement and refinements are still required. We also show that a notation can be both readable and expressive by quickly presenting two notations — Formalized English (FE) and Frame-CG (FCG) — that we have derived from CG and Frame-Logics. These notations support the above conventions, and are implemented in our Web-based knowledge representation and document indexation tool, WebKB.

XML has become the standard format for representing structured and semi-structured data on the Web. To describe the structure and content of XML data, several XML schema languages have been proposed. Although being very useful for validating XML documents, an XML schema is not suitable for tasks requiring knowledge about the semantics of the represented data. For such tasks it is better to use a conceptual schema. This paper presents an extension of the Entity Relationship (ER) model, called X-Entity, for conceptual modeling of XML schemas. We also present the process of converting a schema, defined in the XML Schema language, to an X-Entity schema. The conversion process is based on a set of rules that consider element declarations and type definitions and generates the corresponding conceptual elements. Such representation provides a cleaner description for XML schemas by focusing only on semantically relevant concepts. The X-Entity model has been used in the context of a Web data integration system with the goal of providing a concise and semantic description for local schemas defined in XML Schema.

The use of relational database management systems (RDBMSs) to store and query XML data has attracted considerable interest with a view to leveraging their powerful and reliable data management services. Due to the mismatch between the relational and XML data models, it is necessary to first shred and load the XML data into relational tables, and then translate XML queries over the original data into equivalent SQL queries over the mapped tables. Although there is a rich literature on XML-relational storage, none of the existing solutions addresses all the storage problems in a single framework. Works on mapping strategies often have little or no details about query translation, and proposals for query translation often target a specific mapping strategy. XML-storage solutions provided by RDBMS also have limitations. Notably, they are tied to a specific backend and use proprietary mapping languages, which not only may require a steep learning curve, but often are unable to express certain desirable mappings. In order to address these limitations, we developed ShreX, a XML-to-relational mapping framework and system that provides the first comprehensive and end-to-end solution to the relational storage of XML data. Mappings in ShreX are defined through annotations to an XML Schema. The use of XML Schema simplifies the mapping process, since it does not require users to master a new specialized mapping language. The use of annotations allows mapping choices to be combined in many different ways. As a result, ShreX not only supports all the mapping strategies proposed in the literature, but also new useful strategies that had not been considered previously. ShreX provides generic (and automatic) document shredding and query translation capabilities; and it is portable — its mapping specifications are independent of the database backend.

In XML retrieval, two distinct approaches have been established and pursued without much cross-fertilization taking place so far. On the one hand, native XML databases tailored to the semistructured data model have received considerable attention, and a wealth of index structures, join algorithms, tree encodings and query rewriting techniques for XML have been proposed. On the other hand, the question how to make XML fit the relational data model has been studied in great detail, giving rise to a multitude of storage schemes for XML in relational database systems (RDBSs). In this paper we examine how native XML indexing techniques can boost the retrieval of XML stored in an RDBS. We present the Relational CADG (RCADG), an adaptation of several native indexing approaches to the relational model, and show how it supports the evaluation of a clean formal language of conjunctive XML queries. Unlike relational storage schemes for XML, the RCADG largely preserves the underlying tree structure of the data in the RDBS, thus addressing several open problems known from the literature. Experiments show that the RCADG accelerates retrieval by up to two or even three orders of magnitude compared to both native and relational approaches.

In this paper we investigate the problem of XML Schema evolution. We first discuss the different kinds of changes that may be needed on an XML Schema. Then, we investigate how to minimize document revalidation, that is, detecting the document parts potentially invalidated by the schema changes that should be revalidated.

XML becomes the standard for the representation of structured and semi-structured data on the Web. Relational and object-relational database systems are a well understood technique for managing and querying such large sets of structured data. Using an object-relational data model and an XML datatype, we show how a relevant subset of XML documents and their implied structure can be mapped onto database structures. Besides straight-forward mappings, there are some XML structures that cannot be easily mapped onto database structures. These structures would sometimes result in large database schemas and sparsely populated databases. As a consequence, such XML document fragments should be mapped onto database attributes of type XML and kept as is. The XML datatype implementation should support evaluating path expressions and fulltext operations. We present an algorithm that finds a type of optimal mapping based on the XML Document Type Definition (DTD) and statistics. The statistics are derived from sample XML document sets and some knowledge about queries on XML document collections.

The World-Wide Web Consortium (W3C) promotes XML and related standards, including XML Schema, XQuery, and XPath. This paper describes a formalization of XML Schema. A formal semantics based on these ideas is part of the official XQuery and XPath specification, one of the first uses of formal methods by a standards body. XML Schema features both named and structural types, with structure based on tree grammars. While structural types and matching have been studied in other work (notably XDuce, Relax NG, and a previous formalization of XML Schema), this is the first work to study the relation between named types and structural types, and the relation between matching and validation.

Usually, the first normal form condition of the relational model of data is imposed. Presently, a broader class of data base applications like office information systems is considered where this restriction is not convenient. Therefore, an extension of the relational model is proposed consisting of Non First Normal Form (NF²) relations. The relational algebra is enriched mainly by so called nest and unnest operations which transform between NF² relations and the usual ones. We state some properties of these operations and some rules which occur in combination with the operations of the usual relational algebra. Since we propose to use the NF² model also for the internal data model these rules are important not only for theoretical reasons but also for a practical implementation.

Peer-to-Peer systems have proven to be an effective way of sharing data. Modern protocols are able to efficiently route a message to a given peer. However, determining the destination peer in the first place is not always trivial. We propose a model in which peers advertise their expertise in the Peer-to-Peer network. The knowledge about the expertise of other peers forms a semantic topology. Based on the semantic similarity between the subject of a query and the expertise of other peers, a peer can select appropriate peers to forward queries to, instead of broadcasting the query or sending it to a random set of peers. To calculate our semantic similarity measure we make the simplifying assumption that the peers share the same ontology. We evaluate the model in a bibliographic scenario, where peers share bibliographic descriptions of publications among each other. In simulation experiments we show how expertise based peer selection improves the performance of a Peer-to-Peer system with respect to precision, recall and the number of messages.

Group communications is an area of research which has received a lot of attention recently. This paper focuses on a model and the architecture of a system which supports group communications by providing group and session management functionality. This system is an extension of directory services which are used with unicast communications. New functionality is needed for the dynamics of group communications (members of a connection may change over the lifetime of the connection) and increased complexity of relations. A model is described which defines six object types which represent the relevant objects. Users and groups represent real world users and their relations. Sessions and flows describe ongoing group communications. Flow templates and certificates provide mechanisms for management and security issues. The architecture presented in this paper is transport-independent, ie it can be used within different group communication platforms. A short sketch of the implementation is given in the last section.

Contemporary XPath query engines evaluate queries in time exponential in the sizes of input queries, a fact that has gone unnoticed for a long time. Recently, the first main-memory evaluation algorithm for XPath 1.0 with polynomial time combined complexity, i.e., which runs in polynomial time both with respect to the size of the data and the queries, has been published. In this paper, we present several important improvements and extensions of that work, including new XPath processing algorithms with improved time and space efficiency. Moreover, we define a very large and practically relevant fragment of XPath for which a further optimized form of query evaluation is possible. Apart from its immediate relevance for XPath query processing, our work also sheds new light at those features of XPath 1.0 which are most costly relative to their practical usefulness.

XML has become the de facto standard format for web publishing and data transportation. Since online information changes frequently, being able to quickly detect changes in XML documents is important to Internet query systems, search engines, and continuous query systems. Previous work in change detection on XML, or other hierarchically structured documents, used an ordered tree model, in which left-to-right order among siblings is important and it can affect the change result. This paper argues that an unordered model (only ancestor relationships are significant) is more suitable for most database applications. Using an unordered model, change detection is substantially harder than using the ordered model, but the change result that it generates is more accurate. This paper proposes X-Diff, an effective algorithm that integrates key XML structure characteristics with standard tree-to-tree correction techniques. The algorithm is analyzed and compared with XyDiff, a published XML diff algorithm. An experimental evaluation on both algorithms is provided.

We present a technique for refining the design of relational storage for XML data based on XML key propagation. Three algorithms are presented: one checks whether a given functional dependency is propagated from XML keys via a predefined view; the others compute a minimum cover for all functional dependencies on a universal relation given XML keys. Experimental results show that these algorithms are efficient in practice. We also investigate the complexity of propagating other XML constraints to relations, and the effect of increasing the power of the transformation language. Computing XML key propagation is a first step toward establishing a connection between XML data and its relational representation at the semantic level.

We consider the problem of translating XML queries into SQL when XML documents have been stored in an RDBMS using a schema-based relational decomposition. Surprisingly, there is no published XML-to-SQL query translation algorithm for this scenario that handles recursive XML schemas. We present a generic algorithm to translate path expression queries into SQL in the presence of recursion in the schema and queries. This algorithm handles a general class of XML-to-Relational mappings, which includes all techniques proposed in literature. Some of the salient features of this algorithm are: (i) It translates a path expression query into a single SQL query, irrespective of how complex the XML schema is, (ii) It uses the "with" clause in SQL99 to handle recursive queries even over non-recursive schemas, (iii) It reconstructs recursive XML subtrees with a single SQL query and (iv) It shows that the support for linear recursion in SQL99 is sufficient for handling path expression queries over arbitrarily complex recursive XML schema.

The growing use of XML mark-up language has made a large amount of heterogeneous XML documents widely available. As the number of applications that utilize heterogeneous XML documents grows, the importance of XML documents transformations increases greatly. A serious obstacle for translating directly between two XML documents, using languages like XSLT, is that a mapping between the two XML representations needs to be carefully specified by a human expert. Current research attempts to address this problem by proposing algorithms to automate aspects of XML schemas matching task. In this paper, we identify two major problems encountered when current matching algorithms are used in the context of XML documents transformations. The first problem concerns possible scalability problem due to the diversity of schema constructs. The second problem deals with the need to perform semantic matching. We argue in favor of conceptual modelling as solution to avoid such problems. We introduce a new layered model for XML schemas, called Layered Interoperability Model for XML Schemas (LIMXS). LIMXS offers a semantic view for XML schemas through the specification of concepts and semantic relationships among them. We will show how our model transforms the matching algorithm into a dynamic and incremental algorithm that provide semantic mappings and helps to automate the transformation process.

This paper discusses methods to generate and display automatically additional hyperlink information to the users of the World Wide Web. Current Web browsers make it hard to predict what will happen if a link is being followed: users get different information than they expect, a new window may be opened, a download starts, or the destination object is just not available. Instead of giving an appropriate notification in advance, users have to follow a link, check whether the document contains the expected information, get back, try another link etc. However, usually it is possible to obtain additional hyperlink information from several sources like link anchor tags, the user's history and web servers. Furthermore, with little enhancements, Web servers may include even more additional information to the hyperlinks in Web documents. These can be displayed before users select a link to improve navigation and reduce the cognitive overhead. In this paper several types of Web hyperlink information are listed, potential methods to present these facts are compared, the prototype implementation of the proposed concept — called by us HyperScout — is presented, and further developments are discussed.

XML is the standard format for data exchange between inter-enterprise applications on the Internet. To facilitate data exchange, industry groups define public document type definitions (DTDs) that specify the format of the XML data to be exchanged between their applications. In this paper, we address the problem of automating the conversion of relational data into XML. We describe SilkRoute, a general, dynamic, and efficient tool for viewing and querying relational data in XML. SilkRoute is general, because it can express mappings of relational data into XML that conforms to arbitrary DTDs. We call these mappings views. Applications express the data they need as an XML-QL query over the view. SilkRoute is dynamic, because it only materializes the fragment of an XML view needed by an application, and it is efficient, because it fully exploits the underlying RDBMs query engine whenever data items in an XML view need to be materialized.

Search engines play a crucial role in the Web. Without search engines large parts of the Web becomes inaccessible for the majority of users. Search engines can make new and smaller sites accessible at low cost. Without them, other media, such as Television, would be needed to advertise the existence new site on the Web, only large commercial sites can follow this path. The Web would be endangered to become dominated by a few, well known sites. A crucial problem of search engines is to keep their index up-to-date. Especially if the index grows, the effort needed to update the index increases, since Web documents are dynamic and thus already stored data becomes obsolete. There have been various attempts to monitor the evolvement of the Web. However, we believe, that change model used in prior work over-estimates the rate of change due to an inadequate change model. Our change model has been adapted from the information retrieval field to distinguish index relevant changes from irrelevant modifications in Web documents, e.g. simple spelling corrections or dynamic advertisement links. We have monitored multiple smaller collections of documents over a time period of six month to measure the documents change.

BibTeXML is an XML representation of BibTeX data. It can be used to represent bibliographic data in XML. The advantage of BibTeXML over BibTeX's native syntax is that it can be easily managed using standard XML tools (in particular, XSLT style sheets), while native BibTeX data can only be manipulated using specialized tools.

The Fluid Documents project has developed various research prototypes that show that powerful annotation techniques based on animated typographical changes can help readers utilize annotations more effectively. Our recently-developed Fluid Open Hypermedia prototype supports the authoring and browsing of fluid annotations on third-party Web pages. This prototype is an extension of the Arakne Environment, an open hypermedia application that can augment Web pages with externally stored hypermedia structures. This paper describes how various Web standards, including DOM, CSS, XLink, XPointer, and RDF, can be used and extended to support fluid annotations.

We present an algorithm for translating XSLT programs into SQL. Our context is that of virtual XML publishing, in which a single XML view is defined from a relational database, and subsequently queried with XSLT programs. Each XSLT program is translated into a single SQL query and run entirely in the database engine. Our translation works for a large fragment of XSLT, which we define, that includes descendant/ancestor axis, recursive templates, modes, parameters, and aggregates. We put considerable effort in generating correct and efficient SQL queries and describe several optimization techniques to achieve this efficiency. We have tested our system on all 22 SQL queries of the TPC-H database benchmark which we represented in XSLT and then translated back to SQL using our translator.

In the original PageRank algorithm for improving the ranking of search-query results, a single PageRank vector is computed, using the link structure of the Web, to capture the relative "importance" of Web pages, independent of any particular search query. To yield more accurate search results, we propose computing a set of PageRank vectors, biased using a set of representative topics, to capture more accurately the notion of importance with respect to a particular topic. By using these (precomputed) biased PageRank vectors to generate query-specific importance scores for pages at query time, we show that we can generate more accurate rankings than with a single, generic PageRank vector. For ordinary keyword search queries, we compute the topic-sensitive PageRank scores for pages satisfying the query using the topic of the query keywords. For searches done in context (e.g., when the search query is performed by highlighting words in a Web page), we compute the topic-sensitive PageRank scores using the topic of the context in which the query appeared.

Ontologies play a prominent role on the Semantic Web. They make possible the widespread publication of machine understandable data, opening myriad opportunities for automated information processing. However, because of the Semantic Web's distributed nature, data on it will inevitably come from many different ontologies. Information processing across ontologies is not possible without knowing the semantic mappings between their elements. Manually finding such mappings is tedious, error-prone, and clearly not possible at the Web scale. Hence, the development of tools to assist in the ontology mapping process is crucial to the success of the Semantic Web. We describe GLUE, a system that employs machine learning techniques to find such mappings. Given two ontologies, for each concept in one ontology GLUE finds the most similar concept in the other ontology. We give well-founded probabilistic definitions to several practical similarity measures, and show that GLUE can work with all of them. This is in contrast to most existing approaches, which deal with a single similarity measure. Another key feature of GLUE is that it uses multiple learning strategies, each of which exploits a different type of information either in the data instances or in the taxonomic structure of the ontologies. To further improve matching accuracy, we extend GLUE to incorporate commonsense knowledge and domain constraints into the matching process. For this purpose, we show that relaxation labeling, a well-known constraint optimization technique used in computer vision and other fields, can be adapted to work efficiently in our context. Our approach is thus distinguished in that it works with a variety of well-defined similarity notions and that it efficiently incorporates multiple types of knowledge. We describe a set of experiments on several real-world domains, and show that GLUE proposes highly accurate semantic mappings.

Hunter Gatherer is an interface that lets Web users carry out three main tasks: (1) collect components from within Web pages; (2) represent those components in a collection; (3) edit those component collections. Our research shows that while the practice of making collections of content from within Web pages is common, it is not frequent, due in large part to poor interaction support in existing tools. We engaged with users in task analysis as well as iterative design reviews in order to understand the interaction issues that are part of within-Web-page collection making and to design an interaction that would support that process. We report here on that design development, as well as on the evaluations of the tool that evolved from that process, and the future work stemming from these results, in which our critical question is: what happens to users' perceptions of web-based resources and their web-based information management practices when they can treat this information as harvestable, recontextualizable data, rather than as fixed pages?

XML itself does not support hypermedia, but the XLink standard has been defined to make XML usable for hypermedia. One of XLink's most interesting features is its support for external links and linkbases, which makes it possible to create links between resources without having to change the resources. In order to use these links, user agents must access linkbases and query them for relevant links, and we present our approach to create a protocol for linkbase access.

Traditionally, when one wants to learn about a particular topic, one reads a book or a survey paper. With the rapid expansion of the Web, learning in-depth knowledge about a topic from the Web is becoming increasingly important and popular. This is also due to the Web's convenience and its richness of information. In many cases, learning from the Web may even be essential because in our fast changing world, emerging topics appear constantly and rapidly. There is often not enough time for someone to write a book on such topics. To learn such emerging topics, one can resort to research papers. However, research papers are often hard to understand by non-researchers, and few research papers cover every aspect of the topic. In contrast, many Web pages often contain intuitive descriptions of the topic. To find such Web pages, one typically uses a search engine. However, current search techniques are not designed for in-depth learning. Top ranking pages from a search engine may not contain any description of the topic. Even if they do, the description is usually incomplete since it is unlikely that the owner of the page has good knowledge of every aspect of the topic. In this paper, we attempt a novel and challenging task, mining topic-specific knowledge on the Web. Our goal is to help people learn in-depth knowledge of a topic systematically on the Web. The proposed techniques first identify those sub-topics or salient concepts of the topic, and then find and organize those informative pages, containing definitions and descriptions of the topic and sub-topics, just like those in a book. Experimental results using 28 topics show that the proposed techniques are highly effective.

Web pages often contain clutter (such as pop-up ads, unnecessary images and extraneous links) around the body of an article that distracts a user from actual content. Extraction of "useful and relevant" content from web pages has many applications, including cell phone and PDA browsing, speech rendering for the visually impaired, and text summarization. Most approaches to removing clutter or making content more readable involve changing font size or removing HTML and data components such as images, which takes away from a webpage's inherent look and feel. Unlike "Content Reformatting", which aims to reproduce the entire webpage in a more convenient form, our solution directly addresses "Content Extraction". We have developed a framework that employs easily extensible set of techniques that incorporate advantages of previous work on content extraction. Our key insight is to work with the DOM trees, rather than with raw HTML markup. We have implemented our approach in a publicly available Web proxy to extract content from HTML web pages.

Recent work on incremental crawling has enabled the indexed document collection of a search engine to be more synchronized with the changing World Wide Web. However, this synchronized collection is not immediately searchable, because the keyword index is rebuilt from scratch less frequently than the collection can be refreshed. An inverted index is usually used to index documents crawled from the web. Complete index rebuild at high frequency is expensive. Previous work on incremental inverted index updates have been restricted to adding and removing documents. Updating the inverted index for previously indexed documents that have changed has not been addressed. In this paper, we propose an efficient method to update the inverted index for previously indexed documents whose contents have changed. Our method uses the idea of landmarks together with the diff algorithm to significantly reduce the number of postings in the inverted index that need to be updated. Our experiments verify that our landmark-diff method results in significant savings in the number of update operations on the inverted index.

This paper evaluates the XLink format in comparison with other linking formats. The comparison is based on Xspect, an implementation of XLink. Xspect handles transformation between an open hypermedia format (OHIF) and XLink, and the paper discusses this isomorphic transformation and generalises it to include another open hypermedia format, FOHM. The Xspect system, based on XSLT and Javascript, provides users with an interface to browse and merge linkbases. Xspect supports navigational hypermedia in the form of links inserted on the fly into Web pages, as well as guided tours presented as SVG. Xspect has two implementations: one server-side and one running on the client. Both implementation provide the user with an interface for the creation of annotations. The main result of the paper is a critique of XLink. XLink is shown to be a format well suited for navigational hypermedia, but lacking in more advanced constructs. More problematic are the issues regarding large-scale use, such as evaluating validity and credibility of linkbases, and ensuring general support for a format as flexible as XLink.

The World Wide Web is opening up access to documents and data for scholars. However it has not yet impacted on one of the primary activities in research: assessing new findings in the light of current knowledge and debating it with colleagues. The ClaiMaker system uses a directed graph model with similarities to hypertext, in which new ideas are published as nodes, which other contributors can build on or challenge in a variety of ways by linking to them. Nodes and links have semantic structure to facilitate the provision of specialist services for interrogating and visualizing the emerging network. By way of example, this paper is grounded in a ClaiMaker model to illustrate how new claims can be described in this structured way.

Links are one of the most important means for navigation in the World Wide Web. However, the visualization of and the interaction with Web links have been scarcely explored, although Links have severe implications on the appearance and usability of Web pages and the World Wide Web as such. This paper presents two studies giving first insights of the effects of link visualization techniques on reading habits and performance. The first user study compares different highlighting techniques for link markers and evaluates their effect on reading performance and user acceptance. The second study examines links-on-demand, links that appear when pressing a dedicated key, and discusses their possible effects on reading and browsing habits. The findings of the conducted studies imply that the standard appearance of link markers has seriously underestimated effects on the usability of Web pages. They can significantly reduce the readability of the text, and alternatives should be carefully considered for the design of future Web browsers.

XML documents may contain a large diversity of characters. The Character Repertoire Validation for XML (CRVX) language is a simple schema language for specifying character repertoire constraints. These constraints can be specific for syntax- and/or context-based parts of an XML document. The constraints are based on the character classes introduced by XML Schema's regular expressions.

XML Schema is a rather complex schema language, partly because of its inherent complexity, and partly because of its XML syntax. In an effort to reduce the syntactic verboseness and complexity of XML Schema, we designed the XML Schema Compact Syntax (XSCS), a non-XML syntax for XML Schema. XSCS is designed for human users, and transformations from and to XML Schema XML syntax are implemented using Java-based tools.

Conference time-tables provide information that is indispensable for all attendees. Since there are a lot of reusable data structures and tasks, we have designed the Conference Time-Table Management (CTTM) system, which is intended to be used as a reusable component in a large diversity of conference Web sites. CTTM features a flexible concept for time-tables and provides users with personalization and notification services.

In the past few years, a number of constraint languages for XML documents has been proposed. They are cumulatively called schema languages or validation languages and they comprise, among others, DTD, XML Schema, RELAX NG, Schematron, DSD, xlinkit. One major point of discrimination among schema languages is the support of co-constraints, or co-occurrence constraints, e.g., requiring that attribute A is present if and only if attribute B is (or is not) present in the same element. Although there is no way in XML Schema to express these requirements, they are in fact frequently used in many XML document types, usually only expressed in plain human-readable text, and validated by means of special code modules by the relevant applications. In this paper we propose SchemaPath, a light extension of XML Schema to handle conditional constraints on XML documents. Two new constructs have been added to XML Schema: conditions — based on XPath patterns — on type assignments for elements and attributes; and a new simple type, xsd:error, for the direct expression of negative constraints (e.g. it is prohibited for attribute A to be present if attribute B is also present). A proof-of-concept implementation is provided. A Web interface is publicly accessible for experiments and assessments of the real expressiveness of the proposed extension.

The Web poses itself as the largest data repository ever available in the history of humankind. Major efforts have been made in order to provide efficient access to relevant information within this huge repository of data. Although several techniques have been developed to the problem of Web data extraction, their use is still not spread, mostly because of the need for high human intervention and the low quality of the extraction results. In this paper, we present a domain-oriented approach to Web data extraction and discuss its application to automatically extracting news from Web sites. Our approach is based on a highly efficient tree structure analysis that produces very effective results. We have tested our approach with several important Brazilian on-line news sites and achieved very precise results, correctly extracting 87.71% of the news in a set of 4088 pages distributed among 35 different sites.

This paper provides an objective evaluation of the performance impacts of binary XML encodings, using a fast stream-based XQuery processor as our representative application. Instead of proposing one binary format and comparing it against standard XML parsers, we investigate the individual effects of several binary encoding techniques that are shared by many proposals. Our goal is to provide a deeper understanding of the performance impacts of binary XML encodings in order to clarify the ongoing and often contentious debate over their merits, particularly in the domain of high performance XML stream processing.

Describing XML Namespaces is an open issue for many users of XML technologies, and even though namespaces are one of the foundations of XML, there is no generally accepted and widely used format for namespace descriptions. We present a framework for describing namespaces based on GRDDL using a controlled vocabulary. Using this framework, namespace descriptions can be easily generated, harvested and published in human- or machine-readable form.

The increased importance of XML as a data representation format has led to several proposals for facilitating the development of applications that operate on XML data. These proposals range from runtime API-based interfaces to XML-based programming languages. The subject of this paper is XJ, a research language that proposes novel mechanisms for the integration of XML as a first-class construct into Java. The design goals of XJ distinguish it from past work on integrating XML support into programming languages — specifically, the XJ design adheres to the XML Schema and XPath standards. Moreover, it supports in-place updates of XML data thereby keeping with the imperative nature of Java. We have built a prototype compiler for XJ, and our preliminary experiments demonstrate that the performance of XJ programs can approach that of traditional low-level API-based interfaces, while providing a higher level of abstraction.

For XML-based applications in general and B2B applications in particular, mapping between differently structured XML documents, to enable exchange of data, is a basic problem. A generic solution to the problem is of interest and desirable both in an academic and practical sense. We present a case study of the problem that arises in an XML based project, which involves mapping of different XML schemas to each other. We describe our approach to solving the problem, its advantages and limitations. We also compare and contrast our approach with previously known approaches and commercially available software solutions.

Web accessibility consists on a set of checkpoints which are rather expensive to evaluate or to spot. However, using W3C technologies, this cost can be clearly minimized. This article presents a W3C formalized rule-set version for automatable checkpoints from WCAG 1.0.

Hyperlinks are an essential feature of the World Wide Web, highly responsible for its success. XLink improves on HTML's linking capabilities in several ways. In particular, links after XLink can be "out-of-line" (i.e., not defined at a link source) and collected in (possibly several) linkbases, which considerably ease building complex link structures. Modeling of link structures and processing of linkbases under the Web's "open world linking" are aspects neglected by XLink. Adding a notion of "interface" to XLink, as suggested in this work, considerably improves modeling of link structures. When a link structure is traversed, the relevant linkbase(s) might become ambiguous. We suggest three linkbase management modes governing the binding of a linkbase to a document to resolve this ambiguity.

On an abstract level, XML Schema increases the limited expressive power of Document Type Definitions (DTDs) by extending them with a recursive typing mechanism. However, an investigation of the XML Schema Definitions (XSDs) occurring in practice reveals that the vast majority of them are structurally equivalent to DTDs. This might be due to the complexity of the XML Schema specification and the difficulty to understand the effect of constraints on typing and validation of schemas. To shed some light on the actual expressive power of XSDs this paper studies the impact of the Element Declarations Consistent (EDC) and the Unique Particle Attribution (UPA) rule. An equivalent formalism based on contextual patterns rather than on recursive types is proposed which might serve as a light-weight front end for XML Schema. Finally, the effect of EDC and UPA on the way XML documents can be typed is discussed. It is argued that a cleaner, more robust, stronger but equally efficient class is obtained by replacing EDC and UPA with the notion of 1-pass preorder typing: schemas that allow to determine the type of an element of a streaming document when its opening tag is met. This notion can be defined in terms of restrained competition regular expressions and there is again an equivalent syntactical formalism based on contextual patterns.

As XQuery is gathering momentum as the standard query language for XML, there is a growing interest in using it as an integral part of the XML application development infrastructure. In that context, one question which is often raised is how well XQuery interoperates with other XML languages, and notably with XSLT. XQuery 1.0 and XSLT 2.0 share a lot in common: they share XPath 2.0 as a common sub-language and have the same expressiveness. However, they are based on fairly different programming paradigms. While XSLT has adopted a highly declarative template based approach, XQuery relies on a simpler, and more operational, functional approach. In this paper, we present an approach to compile XSLT 2.0 into XQuery 1.0, and a working implementation of that approach. The compilation rules explain how XSLT's template-based approach can be implemented using the functional approach of XQuery and underpins the tight connection between the two languages. The resulting compiler can be used to migrate a XSLT code base to XQuery, or to enable the use of XQuery runtimes (e.g., as will soon be provided by most relational database management systems) for XSLT users. We also identify a number of areas where compatibility between the two languages could be improved. Finally, we show experiments on actual XSLT stylesheets, demonstrating the applicability of the approach in practice.

This paper describes an experimental system in which customized high performance XML parsers are prepared using parser generation and compilation techniques. Parsing is integrated with Schema-based validation and deserialization, and the resulting validating processors are shown to be as fast as or in many cases significantly faster than traditional nonvalidating parsers. High performance is achieved by integration across layers of software that are traditionally separate, by avoiding unnecessary data copying and transformation, and by careful attention to detail in the generated code. The effect of API design on XML performance is also briefly discussed.

Path expressions are the principal means of locating data in a hierarchical model. But path expressions are brittle because they often depend on the structure of data and break if the data is structured differently. The structure of data could be unfamiliar to a user, may differ within a data collection, or may change over time as the schema evolves. This paper proposes a novel construct that locates related nodes in an instance of an XML data model, independent of a specific structure. It can augment many XPath expressions and can be seamlessly incorporated in XQuery or XSLT.

XML is fast becoming the standard format to store, exchange and publish over the web, and is getting embedded in applications. Two challenges in handling XML are its size (the XML representation of a document is significantly larger than its native state) and the complexity of its search (XML search involves path and content searches on labeled tree structures). We address the basic problems of compression, navigation and searching of XML documents. In particular, we adopt recently proposed theoretical algorithms for succinct tree representations to design and implement a compressed index for XML, called XBzipIndex, in which the XML document is maintained in a highly compressed format, and both navigation and searching can be done uncompressing only a tiny fraction of the data. This solution relies on compressing and indexing two arrays derived from the XML data. With detailed experiments we compare this with other compressed XML indexing and searching engines to show that XBzipIndex has compression ratio up to 35% better than the ones achievable by those other tools, and its time performance on some path and content search operations is order of magnitudes faster: few milliseconds over hundreds of MBs of XML files versus tens of seconds, on standard XML data sources.

XML is the predominant format for representing structured information inside documents, but it stops at the level of files. This makes it hard to use XML-oriented tools to process information which is scattered over multiple documents within a file system. File System XML (FSX) and its content integration provides a unified view of file system structure and content. FSX's adaptors map file contents to XML, which means that any file format can be integrated with an XML view in the integrated view of the file system.

Namespaces are a central building block of XML technologies today, they provide the identification mechanism for many XML-related vocabularies. Despite their ubiquity, there is no established mechanism for describing namespaces, and in particular for describing the dependencies of namespaces. We propose a simple model for describing namespaces and their dependencies. Using these descriptions, it is possible to compile directories of namespaces providing searchable and browsable namespace descriptions.

Locating files based on file system structure, file properties, and maybe even file contents is a core task of the user interface of operating systems. By adapting XPath's power to the environment of a Unix shell, it is possible to greatly increase the expressive power of the command line language. We present a concept for integrating an XPath view of the file system into a shell, which can be used to find files based on file attributes and contents in a very flexible way. The syntax of the command line language is backwards compatible with traditional shells, and the new XPath-based expressions can be easily mastered with a little bit of XPath knowledge.

There are principal differences between the relational model and XML's tree model. This causes problems in all cases where information from these two worlds has to be brought together. Using a few rules for mapping the incompatible aspects of the two models, it becomes easier to process data in systems which need to work with relational and tree data. The most important requirement for a good mapping is that the conceptual model is available and can thus be used for making mapping decisions.

In many research settings, bibliographies are a central resource for collecting information about related work, keeping track of the own research record, and annotating this information with remarks. By its very nature, this information should be shared between researchers within a research group and maybe in larger organizational units (for example research institutes) as well. However, most tools used for managing bibliographic data do not support collaboration. Using ShaRef, users can share bibliographic information, collaborate, and publish and export data using a variety of output channels. ShaRef's goal is to make sharing of and collaboration with bibliographic information easier than it is today.

Wissensvermittlung setzt zu einem massgeblichen Teil nicht nur das Lehren von Fakten und Methoden voraus, sondern unverzichtbar auch deren Einordnung in den durch das Fachgebiet vorgegebenen Rahmen. Eine ICT Strategie wissensvermittelnder Organisationen sollte diesem weiten Fokus der Wissensvermittlung Rechnung tragen und durch strategische Zielsetzungen verhindern, dass geschlossene Insellösungen entstehen, die dem Ziel der Vermittlung vernetzten Wissens abträglich sind. Im Rahmen geeigneter strategischer und technischer Rahmenbedingungen können heutzutage basierend auf existierenden Technologien Tools entwickelt werden, die sich durch ihr modulares und offenes Konzept optimal im sich ständig ändernden ICT Umfeld einer Hochschule einsetzen lassen. Am Beispiel eines Tools zur Verwaltung von Literaturverweisen wird erläutert, wie eine offene ICT Strategie in Form technischer Lösungen umgesetzt werden kann.

The usability of research papers on the Web would be enhanced by a system that explicitly modelled the rhetorical relations between claims in related papers. We describe ClaiMaker, a system for modelling readers' interpretations of the core content of papers. ClaiMaker provides tools to build a Semantic Web representation of the claims in research papers using an ontology of relations. We demonstrate how the system can be used to make inter-document queries.

XML is based on Unicode, and therefore XML documents may use the full Unicode character repertoire. However, XML-based applications often use XML interfaces to legacy software which in many cases is not capable of dealing with the full Unicode character repertoire. We therefore propose a schema language for XML which is capable of limiting the character repertoire of XML documents. This schema language, called Character Repertoire Validation for XML (CRVX), has features to permit or disallow character repertoire subsets from certain parts of an XML document, for example only for element and attribute names. CRVX uses information from the Unicode Character Database (UCD) to make character repertoire specification as easy as possible. CRVX is not intended to be the only schema language in an XML application scenario, but it provides useful additional schema-based validation to protect applications from unsupported characters. XML applications typically combine different schema languages before processing XML documents, and CRVX is intended to complement other schema languages such as grammar-based languages (DTD, XML Schema) or rule-based languages (Schematron). CRVX can be implemented in various ways. One simple solution is to use XSLT to transform an CRVX schema into an XSLT program, which is then used to validate XML documents. We briefly describe such an implementation. Other (and more efficient) implementations could be based on DOM or SAX parsers.

Metadata usage often depends on schemas for metadata, which are important to convey the meaning of the metadata. We propose an architecture where users can extend the schema used by a system for managing referential metadata. Users can plugin new schemas and install custom filters for exporting metadata, so that users are not forced to limit their metadata to a fixed schema. The goal of this architecture is to provide users with a system that helps them managing their referatory, enables them with powerful tools to adapt the tool to their metadata, and still makes it possible to collect the metadata of several users in a central storage and exploit the common facets of the metadata. Our system is based on a specialized schema language, which has been built on top of the XML schema languages XML Schema and Schematron.

In the last years, networked multimedia multipoint applications have been developed in conjunction with emerging broadband networks. Experiences have shown that existing transport systems support these applications only insufficiently, since they offer no assistance for real-time multimedia and multipoint applications. In this paper, we propose a Multicast Communication Framework (MCF) which satisfies the needs of multimedia multipoint applications. MCF covers both transportation and presentation of multimedia data. It guarantees quality of service (QoS) for the complete path between multimedia sources and multimedia sinks. Furthermore, it offers a high-level abstraction of multicast communication services that hides the details of the underlying endsystems and networks.

We present the functional language CDuce, discuss some design issues, and show its adequacy for working with XML documents. Distinctive features of CDuce are a powerful pattern matching, first class functions, overloaded functions, a very rich type system (arrows, sequences, pairs, records, intersections, unions, differences), precise type inference for patterns and error localization, and a natural interpretation of types as sets of values. We also outline some important implementation issues; in particular, a dispatch algorithm that demonstrates how static type information can be used to obtain very efficient compilation schemas.

Awareness of individual and group activities is critical to successful collaboration and is commonly supported in CSCW systems by active, information generation mechanisms separate from the shared workspace. These mechanisms penalise information providers, presuppose relevance to the recipient, and make access difficult, We discuss a study of shared editor use which suggests that awareness information provided and exploited passively through the shared workspace, allows users to move smoothly between close and loose collaboration, and to assign and coordinate work dynamically. Passive awareness mechanisms promise effective support for collaboration requiring this sort of behaviour, whilst avoiding problems with active approaches.

Collaborative systems provide a rich but potentially chaotic environment for their users. This paper presents a system that allows users to control collaboration by enacting policies that serve as general guidelines to restrict and define the behavior of the system in reaction to the state of the world. Policies are described in terms of access control rights on data objects, and are assigned to groups of users called roles. Roles represent not only statically-defined collections of users, but also dynamic descriptions of users that are evaluated as applications are run. This run-time aspect of roles allows them to react flexibly to the dynamism inherent in collaboration. We present a specification language for describing roles and policies, as well as a number of common “real-world” policies that can be applied to collaborative settings.

Digital web-accessible annotations are a compelling medium for personal comments and shared discussions around documents. Only recently supported by widely used products, "in-context" digital annotation is a relatively unexamined phenomenon. This paper presents a case study of annotations created by members of a large development team using Microsoft Office 2000 — approximately 450 people created 9,000 shared annotations on about 1,250 documents over 10 months. We present quantitative data on use, supported by interviews with users, identifying strengths and weaknesses of the existing capabilities and possibilities for improvement.

In this paper we present the Clover architectural model, a new conceptual architectural model for groupware. Our model results from the combination of the layer approach of Dewan's generic architecture with the functional decomposition of the Clover design model. The Clover design model defines three classes of services that a groupware application may support, namely, production, communication and coordination services. The three classes of services can be found in each functional layer of our model. Our model is illustrated with a working system, the CoVitesse system, its software being organized according to our Clover architectural model.

Joint editing as opposed to "normal" editing is an activity carried out by several people simultaneously. It raises the problem of coordinating write access to a document. The approach described in this paper uses an editing model of reserved regions and a client/server architecture. Any region of a document may be selected and reserved (provided that it is not reserved already) and may then be changed by the owner. Other users can only read it. The software basis of the editor is the Andrew Toolkit. This allows the use of arbitrary media types within the document.

This paper considers the deceptively simple question: Why can't downloaded academic papers be managed in the simple and effective manner in which digital music files are managed? We make the case that the answer is different treatments of metadata. Two key differences are identified: Firstly, digital music metadata is standardized and moves with the content file, while academic metadata is not and does not. Secondly digital music metadata lookup services are collaborative and automate the movement from a digital file to the appropriate metadata, while academic metadata services do not. To understand why these differences exist we examine the divergent evolution of metadata standards for digital music and academic papers. It is observed that the processes differ in interesting ways according to their intent. Specifically music metadata was developed primarily for personal file management, while the focus of academic metadata has been on information retrieval. We argue that lessons from MP3 metadata can assist individual academics facing their growing personal document management challenges. Our focus therefore is not on metadata for the academic publishing industry or institutional resource sharing, it is limited to the personal libraries growing on our hard-drives. This bottom-up approach to document management combined with p2p distribution radically altered the music landscape. Might such an approach have a similar impact on academic publishing? This paper outlines plans for improving the personal management of academic papers — doing academic metadata and file management the MP3 way — and considers the likelihood of success.

We address the issue of design of architectures and abstractions to implement multimedia scientific manipulation systems, and briefly describe a prototype CSCW infrastructure which we have used to implement a multi-user distributed and collaborative scientific manipulation environment on the multimedia desktop. Finally, we present example design systems to exhibit that multimedia interfaces, incorporating text, graphics, audio and video, greatly facilitate distributed and collaborative scientific design effort. SHASTRA is a distributed and collaborative geometric design and scientific manipulation environment. In this system we address the research and development of the next generation of scientific software environments where multiple users (say, a collaborative engineering design team) create, share, manipulate, analyze, simulate, and visualize complex three dimensional geometric designs over a distributed heterogeneous network of workstations and supercomputers.

Distributed multimedia applications are very demanding with respect to support they require from the underlying group communication platform. In this paper, an approach is described which aims at providing group communication platform designers with a component which can be used for powerful group and session management functionality. This component, which can be integrated into group communication platforms, is part of a system called the group and session management system (GMS). The GMS model consists of GMS user agents, which are the components to be integrated into group communication platforms, and GMS system agents which are distributed directory agents providing the distributed database which the user agents access. Communication between these two types of agents is defined in two protocols, the GMS access protocol between user agents and system agents, and the GMS system protocol between system agents. GMS also defines a number of objects and relations which can be used to manage users, groups, and sessions on a very abstract level, thus providing both group communication platform designers and programmers of distributed multimedia application with a high-level description of group communications. This approach enables a truly integrated approach for collaborative applications, where all applications, even when using different group communication platforms, can share the same database about users, groups, and sessions. The paper also contains a short description of the ongoing implementation of GMS's components.

Influenced by the linking model which is implicit in HTML, today's publishing model on the Web is content-centered, with the emphasis of publishing on content rather than links. With the growing amount of information available on the Web, and the more powerful hypermedia architectures made possible by new Web technologies, putting the content into context will become increasingly important. In this paper, a new way of structuring publishing systems for information providers is presented in an attempt to shift the emphasis in Web-based publishing from content to an improved balance between content and links. After a description of the architecture of a link-based publishing system, a strategy for implementing such a system is described. Finally, a number of challenges associated with such a fundamental transition in the publishing model are described, in the technical as well as in the organizational domain.

This article examines a case of developing a prototype for an ontology-driven e-government application based on Semantic Web technologies in order to learn more about how to interrelate systems development with the tasks of information and knowledge management related to e-government service provision. The focus of evaluation is set by analyzing the information management challenges specific to the administrative domain and by the need for taking into account the increased granularity of informational resources and the manifold semantic differences in dealing with those resources. Following the different tasks and problems within the development process the authors identify what appeared to be critical issues: requirements analysis, choice and mastering of Semantic Web technologies, representation of ontology and informational resources, creating interfaces for users and other services. Based on the project analysis, the article concludes by suggesting an agenda for the cooperation of administrative information managers and systems developers as a prerequisite for successful Semantic Web projects in e-government.

Model management is a new approach to meta data management that offers a higher level programming interface than current techniques. The main abstractions are models (e.g., schemas, interface definitions) and mappings between models. It treats these abstractions as bulk objects and offers such operators as Match, Merge, Diff, Compose, Apply, and ModelGen. This paper extends earlier treatments of these operators and applies them to three classical meta data management problems: schema integration, schema evolution, and round-trip engineering.

Although the Web has continuously grown and evolved since its introduction in 1989, the technical foundations have remained relatively unchanged. Of the basic technologies, URLs and HTTP has remained stable for some time now, and only HTML has changed more frequently. However, the introduction of XML has heralded a substantial change in the way in which content can be managed. One of the most significant of these changes is with respect to the greatly enhanced model for linking functionality that is enabled by the emerging XLink and XPointer standards. These standards have the capacity to fundamentally change the way in which we utilise the Web, especially with respect to the way in which users interact with information. In this paper, we will discuss some of the richer linking functionality that XLink and XPointer enable — particularly with respect to aspects such as content transclusion, multiple source and destination links, generic linking, and the use of linkbases to add links into content over which the author has no control. The discussions will be illustrated with example XLink code fragments, and will emphasise the particular uses to which these linking concepts can be put.

XML as the most successful data representation format makes it easy to start working with structured data because of the simplicity of XML documents and DTDs, and because of the general availability of tools. This paper first describes the origin and features of XML as a markup language. In a second part, the question of how to use the features provided by XML for structuring content is addressed. Data modeling for electronic publishing and document engineering is an research field with many open issues, the most important open question being what to use as the modeling language for XML-based applications. While the paper does not provide a solution to the modeling language question, it provides guidelines for how to design schemas once the model has been defined.

Recent reports in the popular media suggest a significant decrease in peer-to-peer (P2P) file-sharing traffic, attributed to the public's response to legal threats. Have we reached the end of the P2P revolution? In pursuit of legitimate data to verify this hypothesis, we embark on a more accurate measurement effort of P2P traffic at the link level. In contrast to previous efforts we introduce two novel elements in our methodology. First, we measure traffic of all known popular P2P protocols. Second, we go beyond the "known port" limitation by reverse engineering the protocols and identifying characteristic strings in the payload. We find that, if measured accurately, P2P traffic has never declined; indeed we have never seen the proportion of p2p traffic decrease over time (any change is an increase) in any of our data sources

The paper provides preliminary results from a major study of the academic and research libraries users in Slovakia. The study is part of a larger research project on interaction of man and information environment. The goal of the research is to identify patterns of interaction of individuals and groups with information resources, derive models and information styles. The methodological model for questionnaire survey of users is described. The first results confirm the need to support user strategies, collaboration, different stages of information seeking and knowledge states, closer links with learning and problem solving, easy and flexible access, human creative processes of analysis, synthesis, interpretation, and the need to develop new knowledge organization structures.

This paper presents the results of our study regarding the different facets and ways of using annotations in both digital libraries and collaboratories. This study represents an innovative attempt at gathering methodological tools and synergies from both fields in order to effectively define a comprehensive model for annotations. Thus we propose a conceptual model for annotations in order to develop an annotation service that can be plugged into digital libraries and collaboratories. Finally, starting from our model, we introduce a search strategy for exploiting annotations in order to search and retrieve relevant documents for a user query.

Kepler is an attempt to bridge the gap between established, organization-backed digital libraries and groups of researchers that wish to publish their findings under their control, anytime, anywhere yet have the advantages of an OAI-compliant digital library. We describe an architecture and implementation of the Kepler system that allows an archivelet to be installed in the order of minutes by an author on a personal machine and a group server in less than an hour. The group server will harvest from all archivelets and make the union of all published papers available for search to a community. We describe how a group administrator can provide an XML schema for the metadata and how the Kepler engine will validate against them when an author publishes a paper and completes the metadata. We have demonstrated that we can surmount the technical difficulties for authors to publish as easy as to a website yet produce OAI-compliant digital libraries.

This paper argues for the necessity of digital libraries to increase access to their holdings and have greater impact on e-learning and education by facilitating the creation of secondary repositories. These repositories will provide discipline/community specific metadata and applications and will allow users to find, use, manipulate and analyze digital objects more easily. To this end, MATRIX has developed Media Matrix 1.0 an online, easy to use server-side suite of tools that allows users to locate specific media and streaming media files found in digital repositories and segment, annotate and organize this media online. This application provides users with an environment both to work with and personalize digital media, and also to share and discuss their findings with a community of users. Through creating a secondary repository of usage statistics and user-generated materials/metadata to supplement both traditional cataloging records and discipline-specific online indexes, tools like Media Matrix can help extend the usefulness of digital libraries without increasing costs to the libraries.

XML is becoming the standard representation format for metadata. Metadata for multimedia documents, as for instance MPEG-7, require approximate match search functionalities to be supported in addition to exact match search. As an example, consider image search performed by using MPEG-7 visual descriptors. It does not make sense to search for images that are exactly equal to a query image. Rather, images similar to a query image are more likely to be searched. We present the architecture of an XML search engine where special techniques are used to integrate approximate and exact match search functionalities.

The increase in the amount of data available in digital libraries calls for the development of search engines that allow the users to find quickly and effectively what they are looking for. The XML tagging makes possible the addition of structural information in digitized content. These metadata offer new opportunities to a wide variety of new services. This paper describes the requirements that a search engine inside a digital library should fulfill and it also presents a specific XML search engine architecture. This architecture is designed to index a large amount of text with structural tagging and to be web-available. The architecture has been developed and successfully tested at the Miguel de Cervantes Digital Library.

We present an integrated framework for the document conversion from legacy formats to XML format. We describe the LegDoC project, aimed at automating the conversion of layout annotations layout-oriented formats like PDF, PS and HTML to semantic-oriented annotations. A toolkit of different components covers complementary techniques the logical document analysis and semantic annotations with the methods of machine learning. We use a real case conversion project as a driving example to exemplify different techniques implemented in the project.

One of the objectives of the Open Access movement is to establish institutional repositories at universities and other research institutions in order to support self-archiving. Although a lot of software solutions have already been presented in recent years they lack a seamless integration of authoring tools, support for authors, and other technical publication tools. This paper presents a formal approach to describe software components applied in publishing processes. Additionally it is depicted how this formal description leads to the technological basis for SCOPE (Service Core for Open Publishing Environments) — a publishing platform for XML based publishing models. SCOPE is a framework intended for the integration of different publication components into a single platform.

Managing bibliographic data is a requirement for many researchers, and in the group setting within which the majority of research takes place, the managing and sharing of bibliographic data is an important facet of organizing the research work. Managing and sharing bibliographies has to balance different levels of shared access (public catalogs, closed research group bibliographies, and personal bibliographies), and the sharing platform should integrate as seamlessly as possible into diverse environments in terms of operating systems, document processing, and other information management tools. The ShaRef system presented in this paper has been designed to fill the gap between public libraries and personal bibliographies, and provides an open platform for sharing bibliographic data among user groups. Through its simple and flexible data model and system architecture, ShaRef adapts to many settings and requirements, and can be used to increase collaboration and information flow within groups.

While XML-based Web Service architectures are successfully turning the Web into an infrastructure for cooperating applications, not all problems with respect to interoperability problems have yet been solved. XML-based data exchange has the ability to carry the full Unicode character repertoire, which is approaching 100'000 characters. Many legacy application are being Web-Service-enabled rather than being re-built from scratch, and therefore still have the same limitations. A frequently seen limitation is the inability to handle the full Unicode character repertoire. We describe an architectural approach and a schema language to address this issue. The architectural approach proposes to establish validation as basic Web Service functionality, which should be built into a Web Services architecture rather than applications. Based on this vision of modular an infrastructure-based validation, we propose a schema language for character repertoire validation. Lessons learned from the first implementation and possible improvements of the schema language conclude the paper.

The music industry is an interesting example for how business models from the pre-Internet area can get into trouble in the new Internet-based economy. Since 2000, the music industry has suffered declining sales, and very often this is attributed to the advent of the Internet-based peer-to-peer file sharing programs. We argue that this explanation is only one of several possible explanations, and that the general decrease in the economic indicators is a more reasonable way to explain the declining sales. Whatever the reason for the declining sales may be, the question remains what the music industry could and should do to stop the decline in revenue. The current strategy of the music industry is centered around protecting their traditional business model through technical measures and in parallel working towards legally protecting the technical measures. It remains to be seen whether this approach is successful, and whether the resulting landscape of tightly controlled digital content distribution is technically feasible and accepted by the consumers. We argue that the search for new business models is the better way to go, even though it may take some time and effort to identify these business models.

Providing users with help and other documentation is essential for any software targeted at end users. Authoring help and documentation in a platform-independent way is hard, because different help systems have different conventions for structuring and organizing the documents. The Help System Generator (HSG) presented in this paper provides an easy and platform-independent way of preparing and publishing help and documentation. Using HSG, software creators can easily author, reuse, and publish help and documentation for different platforms.

Access control for shared resources is a complex and challenging task, in particular if the access control policy should be able to cope with different kind of sharing and collaboration. The reason for this is that traditional access control system often depend on administrators to set up the foundations of the access control mechanism, in most cases users and their group memberships. The access control model presented in this paper approaches this problem by supporting two different kinds of groups, named groups and resource-based groups. Using the implementation of this model in our application allows to to support a wide variety of sharing and collaboration types between the application's users.

One of the main strategic goals of the European Union is a borderless Europe. In reality there are yet a lot of steps to achieve this ambitious goal. An impediment to this mobility is the lack of integration in pan-European administrative processes. To solve the problems these business processes have to be made transparent to the citizen and public services need to be integrated. To do so, public administrations have to interact seamlessly vertically (Europe, nation, region, municipality) as well as horizontally (between countries) with each other. This implies not only the use of standards for data exchange but also the interoperability of business processes. InfoCitizen is a "proof-of-concept" e-government project in the context of the EU IST Framework Program 5 with a budget of more than three million Euros. Within InfoCitizen a European Information Architecture dealing with the interoperability problem has been developed. Based on these blueprints a prototype has been implemented and currently user-partners are evaluating the concepts and the system in interacting local showcases. In this paper the results of the project are shown by summarising the project so far. Findings are used to map out future tasks.

Since a few years digital government is becoming an active research area with lots of promises to revolutionise government and its interaction with citizens and businesses. A crucial point for the success of e-government is the integration and sharing of services and information provided by different authorities. We argue that Web services are a promising technology to solve this problem. The work has been done in the framework of the "eBZ-Digital City" project, which is funded by the Municipality of Bozen-Bolzano.

Advances in Business-to-Business electronic commerce now offer opportunities for improved efficiency and profitability in the commercial sector. But similar opportunities are not yet commonplace for inter-administration situations. Differences in goals mean that packaged software solutions do not carry across well to administrative computing. However processes, shared where appropriate, are still the core element of inter-organizational knowledge, although in administration there is a greater emphasis on rules and legislation, and the payoffs to cooperating administrative units are not always clear. In this paper a layered architecture, derived from one previously proposed for virtual enterprises, is introduced. This architecture includes a high level service request layer, process guidance agents, context-aware work environments and the concept of "just enough" structuring.

Electronic Government has proven a watershed in the domain of Public Administration, despite being difficult to pin down precisely. Indeed, the Government-to-Government arena is one of the least studied aspects of this newly established field of knowledge, despite its importance in fostering co-operation and collaboration between government agencies, mainly with respect to the management of their knowledge, in order to increase the effectiveness of Public Administration. This paper aims to present the key success factors needed to implement government-to-government endeavours effectively. The research design used in this article was largely drawn from a Government-to-Government case study successfully implemented in Brazil.

Corporate memories (stored information and internal processes) in both private and public organizations grow at an exponential rate. This growth is not only quantitative but also qualitative, in the form of increasing interdependencies between processes and information bits. Although the quantitative growth is relatively easy to handle, increasing information complexity is constantly pushing existing information systems to their limits. It is slowly becoming a self-proving fact that organizations will have to transition from the traditional model of searchable/updatable repositories of "facts and figures" to self-organizing, self-adapting corporate knowledge management systems. Ontologies and Semantic Web principles are the most promising relevant technology, now entering their mature age, allowing the creation of extensible vocabularies able to describe any semantic area. Project ONTO-LOGGING is an attempt to harness the full potential of ontologies as a flexible tool of knowledge management within any knowledge-driven organization, such as corporations and public ad-ministrations.

This paper explores the role of knowledge mapping in electronic government. It begins by outlining the rationale for knowledge mapping. It then reviews different conceptualisations of knowledge maps. These include concept, competency and process based maps. Then, it illustrates the application of these maps in a series of examples from the Australian government websites. The paper concludes by identifying some major issues and challenges for the future of knowledge mapping in electronic government.

Individuals, teams, organizations, and networks can be thought of as tiers or classes within the complex grid of technology and practice in which research documentation is both consumed and generated. The panoply of possible classes share with the others a common need for document management tools and practices. The distinctive document management tools and practices used within each represent boundaries across which information could flow openly if technology and metadata standards were to provide an accessible digital framework. The CERN Document Server (CDS), implemented by a research partnership at the San Diego Supercomputer Center (SDSC), establishes a prototype tiered repository system for such a panoply. Research suggests modifications to enable cross-domain information flow and is represented as a metadata grid.

As part of a more extensive study of reading-related practices, we have explored how people share information they encounter in their everyday reading as a complement to the more traditional digital library focus on sharing intentionally retrieved materials. In twenty contextual interviews in home and work place settings, we investigated how people encounter and save published material in the form of paper and electronic clippings. We found that sharing forms a significant use for encountered materials. Furthermore, the function of these clippings extends far beyond a simple exchange of content to inform the recipient; in fact, the content itself may have little immediate value to the recipient. We also found the practice to be ubiquitous: all of our participants had both shared clippings with others and received them themselves. Specifically, this paper reports on: (1) how sharing encountered items fits into the broader spectrum of clipping practices; (2) the function and value of the shared information; and (3) the social role of sharing the encountered information. We conclude that from a technological standpoint, we should think beyond an email model for sharing encountered information and, from a social perspective, we should attend to how sharing this sort of material contributes to the strength of social ties outside of a traditional information needs framework.

Today people typically read and annotate printed documents even if they are obtained from electronic sources like digital libraries. If there is a reason for them to share these personal annotations online, they must re-enter them. Given the advent of better computer support for reading and annotation, including tablet interfaces, will people ever share their personal digital ink annotations as is, or will they make substantial changes to them? What can we do to anticipate and support the transition from personal to public annotations? To investigate these questions, we performed a study to characterize and compare students' personal annotations as they read assigned papers with those they shared with each other using an online system. By analyzing over 1, 700 annotations, we confirmed three hypotheses: (1) only a small f