papers: remove unicode extended characters from abstracts
authorStefano Zacchiroli <zack@upsilon.cc>
Sat, 16 Feb 2013 11:06:10 +0000 (12:06 +0100)
committerStefano Zacchiroli <zack@upsilon.cc>
Sat, 16 Feb 2013 11:06:10 +0000 (12:06 +0100)
to reduce the impact of char encoding issues in BiBTeX files

most notably: replace — with ,

12 files changed:
research/publications.mdwn
research/publications/cbse2011-mpm.bib
research/publications/enase2009-upgrade.bib
research/publications/infsof2012-mpm.bib
research/publications/matita-crafting.bib
research/publications/nrhm-overlapping-conversions.bib
research/publications/phd-thesis.bib
research/publications/scp2010-evolution.bib
research/publications/streaming-co-constraints.bib
research/publications/strongdeps-esem-2009.bib
research/publications/strongdeps-tr.bib
research/publications/wiki-templating-tr.bib

index ee73fe3..384feb3 100644 (file)
@@ -13,7 +13,7 @@ in reverse chronological order.
       <a href="http://www.sciencedirect.com/science/article/pii/S0950584912001851">pp. 459-474</a>.
       ISSN 0950-5849, Elsevier, February 2013.</em>
     [[!toggle id=id42 text="Abstract..."]] [[!toggleable id=id42 text="""
-    *Abstract:* The success of modern software distributions in the Free and Open Source world can be explained, among other factors, by the availability of a large collection of software packages and the possibility to easily install and remove those components using state of the art package managers. However, package managers are often built using a monolithic architecture and hard-wired and ad-hoc dependency solvers implementing some customized heuristics. In this paper we propose a modular architecture relying on precise interface formalisms that allows the system administrator to choose from a variety of dependency solvers and backends. We argue that this is the path that leads to the next generation of package managers that will deliver better results, offer more expressive preference languages, and be easily adaptable to new platforms. We have built a working prototype—called MPM—following the design advocated in this paper, and we show how it largely outperforms a variety of state of the art package managers.
+    *Abstract:* The success of modern software distributions in the Free and Open Source world can be explained, among other factors, by the availability of a large collection of software packages and the possibility to easily install and remove those components using state of the art package managers. However, package managers are often built using a monolithic architecture and hard-wired and ad-hoc dependency solvers implementing some customized heuristics. In this paper we propose a modular architecture relying on precise interface formalisms that allows the system administrator to choose from a variety of dependency solvers and backends. We argue that this is the path that leads to the next generation of package managers that will deliver better results, offer more expressive preference languages, and be easily adaptable to new platforms. We have built a working prototype, called MPM, following the design advocated in this paper, and we show how it largely outperforms a variety of state of the art package managers.
     """]]
  1. <a class="paper-download" href="jss2012-concern.pdf" title="download paper in PDF format">[.pdf]</a> <a class="bibtex-download" href="jss2012-concern.bib" title="download bibliographic entry in BibTeX format">[.bib]</a> <span class="doi_logo"><a href="http://dx.doi.org/10.1016/j.jss.2012.02.018" title="Document Object Identifier">doi&gt;</a></span> Pietro Abate, <a href="http://www.dicosmo.org">Roberto Di Cosmo</a>, <a href="http://www.pps.univ-paris-diderot.fr/~treinen">Ralf Treinen</a>, <a href="http://upsilon.cc/~zack">Stefano Zacchiroli</a>. **Dependency Solving: a Separate Concern in Component Evolution Management**.  <em>In <a href="http://www.journals.elsevier.com/journal-of-systems-and-software/">Journal
       of Systems and Software</a>,
@@ -37,7 +37,7 @@ in reverse chronological order.
       ISSN 0167-6423,
       Elsevier, 2011.</em>
     [[!toggle id=id35 text="Abstract..."]] [[!toggleable id=id35 text="""
-    *Abstract:* FOSS (Free and Open Source Software) systems present interesting challenges in system evolution. On one hand, most FOSS systems are based on very fine-grained units of soft- ware deployment—called packages—which promote system evolution; on the other hand, FOSS systems are among the largest software systems known and require sophisticated static and dynamic conditions to be verified, in order to successfully deploy upgrades on user machines. The slightest error in one of these conditions can turn a routine upgrade into a system administrator nightmare. In this paper we introduce a model-based approach to support the upgrade of FOSS systems. The approach promotes the simulation of upgrades to predict failures before affecting the real system. Both fine-grained static aspects (e.g. configuration incoher- ences) and dynamic aspects (e.g. the execution of configuration scripts) are taken into account, improving over the state of the art of upgrade planners. The effectiveness of the approach is validated by instantiating the approach to widely-used FOSS distributions.
+    *Abstract:* FOSS (Free and Open Source Software) systems present interesting challenges in system evolution. On one hand, most FOSS systems are based on very fine-grained units of software deployment, called packages, which promote system evolution; on the other hand, FOSS systems are among the largest software systems known and require sophisticated static and dynamic conditions to be verified, in order to successfully deploy upgrades on user machines. The slightest error in one of these conditions can turn a routine upgrade into a system administrator nightmare. In this paper we introduce a model-based approach to support the upgrade of FOSS systems. The approach promotes the simulation of upgrades to predict failures before affecting the real system. Both fine-grained static aspects (e.g. configuration incoherences) and dynamic aspects (e.g. the execution of configuration scripts) are taken into account, improving over the state of the art of upgrade planners. The effectiveness of the approach is validated by instantiating the approach to widely-used FOSS distributions.
     """]]
  1. <a class="paper-download" href="nrhm-overlapping-conversions.pdf" title="download paper in PDF format">[.pdf]</a> <a class="bibtex-download" href="nrhm-overlapping-conversions.bib" title="download bibliographic entry in BibTeX format">[.bib]</a> <span class="doi_logo"><a href="http://dx.doi.org/10.1080/13614560802316145" title="Document Object Identifier">doi&gt;</a></span> <a href="http://vitali.web.cs.unibo.it/Main/PaoloMarinelli">Paolo Marinelli</a>, <a href="http://vitali.web.cs.unibo.it">Fabio Vitali</a>, <a href="http://upsilon.cc/~zack">Stefano Zacchiroli</a>. **Towards the unification of formats for overlapping markup**.  <em>
        In <a href="http://www.tandf.co.uk/journals/titles/13614568.asp">New Review
@@ -48,7 +48,7 @@ in reverse chronological order.
        1361-4568</a>.
       </em>
     [[!toggle id=id20 text="Abstract..."]] [[!toggleable id=id20 text="""
-    *Abstract:* Overlapping markup refers to the issue of how to represent data structures more expressive than trees—for example direct acyclic graphs—using markup (meta-)languages which have been designed with trees in mind—for example XML. In this paper we observe that the state of the art in overlapping markup is far from being the widespread and consistent stack of standards and technologies readily available for XML and develop a roadmap for closing the gap. In particular we present in the paper the design and implementation of what we believe to be the first needed step, namely: a syntactic conversion framework among the plethora of overlapping markup serialization formats. The algorithms needed to perform the various conversions are presented in pseudo-code, they are meant to be used as blueprints for researchers and practitioners which need to write batch translation programs from one format to the other.
+    *Abstract:* Overlapping markup refers to the issue of how to represent data structures more expressive than trees, for example direct acyclic graphs, using markup (meta-)languages which have been designed with trees in mind, for example XML. In this paper we observe that the state of the art in overlapping markup is far from being the widespread and consistent stack of standards and technologies readily available for XML and develop a roadmap for closing the gap. In particular we present in the paper the design and implementation of what we believe to be the first needed step, namely: a syntactic conversion framework among the plethora of overlapping markup serialization formats. The algorithms needed to perform the various conversions are presented in pseudo-code, they are meant to be used as blueprints for researchers and practitioners which need to write batch translation programs from one format to the other.
     """]]
  1. <a class="paper-download" href="mcs-disambiguation-errors.pdf" title="download paper in PDF format">[.pdf]</a> <a class="bibtex-download" href="mcs-disambiguation-errors.bib" title="download bibliographic entry in BibTeX format">[.bib]</a> <span class="doi_logo"><a href="http://dx.doi.org/10.1007/s11786-008-0058-2" title="Document Object Identifier">doi&gt;</a></span> <a href="http://www.cs.unibo.it/~sacerdot">Claudio Sacerdoti Coen</a>, <a href="http://upsilon.cc/~zack">Stefano Zacchiroli</a>. **Spurious Disambiguation Errors and How to Get Rid of Them**.  <em>
        In <a href="http://www.springerlink.com/content/1661-8270">Mathematics in
@@ -116,7 +116,7 @@ in reverse chronological order.
       ACM 2011. <em>Award:</em> <a href="http://www.sigsoft.org/">ACM SIGSOFT</a> Distinguished Paper
       Award</em>
     [[!toggle id=id36 text="Abstract..."]] [[!toggleable id=id36 text="""
-    *Abstract:* Software distributions in the FOSS world rely on so-called package managers for the installation and removal of packages on target machines. State-of-the-art package managers are monolithic in architecture, and each of them is hard-wired to an ad-hoc dependency solver implementing a customized heuristics. In this paper we propose a modular architecture allowing for pluggable dependency solvers and backends. We argue that this is the path that leads to the next generation of package managers that will deliver better results, accept more expressive input languages, and can be easily adaptable to new platforms. We present a working prototype—called MPM—which has been implemented following the design advocated in this paper.
+    *Abstract:* Software distributions in the FOSS world rely on so-called package managers for the installation and removal of packages on target machines. State-of-the-art package managers are monolithic in architecture, and each of them is hard-wired to an ad-hoc dependency solver implementing a customized heuristics. In this paper we propose a modular architecture allowing for pluggable dependency solvers and backends. We argue that this is the path that leads to the next generation of package managers that will deliver better results, accept more expressive input languages, and can be easily adaptable to new platforms. We present a working prototype, called MPM, which has been implemented following the design advocated in this paper.
     """]]
  1. <a class="paper-download" href="splc2010-fd-deps.pdf" title="download paper in PDF format">[.pdf]</a> <a class="bibtex-download" href="splc2010-fd-deps.bib" title="download bibliographic entry in BibTeX format">[.bib]</a> <span class="doi_logo"><a href="http://dx.doi.org/10.1007/978-3-642-15579-6_40" title="Document Object Identifier">doi&gt;</a></span> <a href="http://www.dicosmo.org">Roberto Di Cosmo</a>, <a href="http://upsilon.cc/~zack">Stefano Zacchiroli</a>. **Feature Diagrams as Package Dependencies**.  <em>In proceedings of SPLC 2010: <a href="http://splc2010.postech.ac.kr/">14th International Software
       Product Line Conference</a>, Jeju Island, South Korea, 13-17
@@ -141,7 +141,7 @@ in reverse chronological order.
        Florida, USA.
       </em>
     [[!toggle id=id28 text="Abstract..."]] [[!toggleable id=id28 text="""
-    *Abstract:* Component-based systems often describe context requirements in terms of explicit inter-component dependencies. Studying large instances of such systems—such as free and open source software (FOSS) distributions—in terms of declared dependencies between packages is appealing. It is however also misleading when the language to express dependencies is as expressive as boolean formulae, which is often the case. In such settings, a more appropriate notion of component dependency exists: strong dependency. This paper introduces such notion as a first step towards modeling semantic, rather then syntactic, inter-component relationships. Furthermore, a notion of component sensitivity is derived from strong dependencies, with applications to quality assurance and to the evaluation of upgrade risks. An empirical study of strong dependencies and sensitivity is presented, in the context of one of the largest, freely available, component-based system.
+    *Abstract:* Component-based systems often describe context requirements in terms of explicit inter-component dependencies. Studying large instances of such systems, such as free and open source software (FOSS) distributions, in terms of declared dependencies between packages is appealing. It is however also misleading when the language to express dependencies is as expressive as boolean formulae, which is often the case. In such settings, a more appropriate notion of component dependency exists: strong dependency. This paper introduces such notion as a first step towards modeling semantic, rather then syntactic, inter-component relationships. Furthermore, a notion of component sensitivity is derived from strong dependencies, with applications to quality assurance and to the evaluation of upgrade risks. An empirical study of strong dependencies and sensitivity is presented, in the context of one of the largest, freely available, component-based system.
     """]]
  1. <a class="paper-download" href="enase2009-upgrade.pdf" title="download paper in PDF format">[.pdf]</a> <a class="bibtex-download" href="enase2009-upgrade.bib" title="download bibliographic entry in BibTeX format">[.bib]</a> <span class="doi_logo"><a href="http://dx.doi.org/10.1007/978-3-642-14819-4_19" title="Document Object Identifier">doi&gt;</a></span> <a href="http://www.di.univaq.it/cicchetti">Antonio Cicchetti</a>, <a href="http://www.di.univaq.it/diruscio/">Davide Di Ruscio</a>, <a href="http://www.di.univaq.it/pellicci/">Patrizio Pelliccione</a>, <a href="http://www.di.univaq.it/alfonso/">Alfonso Pierantonio</a>, <a href="http://upsilon.cc/~zack">Stefano Zacchiroli</a>. **A Model Driven Approach to Upgrade Package-Based Software Systems**.  <em>In proceedings of <a href="http://www.enase.org/">ENASE
       2009</a>: 4th international conference on Evaluation of Novel Aspects to
@@ -151,7 +151,7 @@ in reverse chronological order.
       262-276</a>, Springer-Verlag,
       2010.</em>
     [[!toggle id=id26 text="Abstract..."]] [[!toggleable id=id26 text="""
-    *Abstract:* Complex software systems are more and more based on the abstraction of package, brought to popularity by Free and Open Source Software (FOSS) distributions. While helpful as an encapsulation layer, packages do not solve all problems of deployment, and more generally of management, of large software collections. In particular upgrades, which often affect several packages at once due to inter-package dependencies, often fail and do not hold good transactional properties. This paper shows how to apply model driven techniques to describe and manage software upgrades of FOSS distributions. It is discussed how to model static and dynamic aspects of package upgrades—the latter being the most challenging aspect to deal with—in order to be able to predict common causes of upgrade failures and undo residual effects of failed or undesired upgrades.
+    *Abstract:* Complex software systems are more and more based on the abstraction of package, brought to popularity by Free and Open Source Software (FOSS) distributions. While helpful as an encapsulation layer, packages do not solve all problems of deployment, and more generally of management, of large software collections. In particular upgrades, which often affect several packages at once due to inter-package dependencies, often fail and do not hold good transactional properties. This paper shows how to apply model driven techniques to describe and manage software upgrades of FOSS distributions. It is discussed how to model static and dynamic aspects of package upgrades, the latter being the most challenging aspect to deal with, in order to be able to predict common causes of upgrade failures and undo residual effects of failed or undesired upgrades.
     """]]
  1. <a class="paper-download" href="sac09-manners.pdf" title="download paper in PDF format">[.pdf]</a> <a class="bibtex-download" href="sac09-manners.bib" title="download bibliographic entry in BibTeX format">[.bib]</a> <span class="doi_logo"><a href="http://doi.acm.org/10.1145/1529282.1529422" title="Document Object Identifier">doi&gt;</a></span> <a href="http://diiorio.web.cs.unibo.it/">Angelo Di Iorio</a>, <a href="http://www.cs.unibo.it/~rossi/">Davide Rossi</a>, <a href="http://vitali.web.cs.unibo.it">Fabio Vitali</a>, <a href="http://upsilon.cc/~zack">Stefano Zacchiroli</a>. **Where are your Manners? Sharing Best Community Practices in the Web 2.0**.  <em>In proceedings of ACM SAC 2009: the <a href="http://www.acm.org/conferences/sac/sac2009/">24th Annual ACM
       Symposium on Applied Computing</a>. ISBN
@@ -189,7 +189,7 @@ in reverse chronological order.
        18-32</a>, 2007.
       </em>
     [[!toggle id=id10 text="Abstract..."]] [[!toggleable id=id10 text="""
-    *Abstract:* Proof assistants are complex applications whose development has never been properly systematized or documented. This work is a contribution in this direction, based on our experience with the development of Matita: a new interactive theorem prover based—as Coq—on the Calculus of Inductive Constructions (CIC). In particular, we analyze its architecture focusing on the dependencies of its components, how they implement the main functionalities, and their degree of reusability. The work is a first attempt to provide a ground for a more direct comparison between different systems and to highlight the common functionalities, not only in view of reusability but also to encourage a more systematic comparison of different softwares and architectural solutions.
+    *Abstract:* Proof assistants are complex applications whose development has never been properly systematized or documented. This work is a contribution in this direction, based on our experience with the development of Matita: a new interactive theorem prover based, as Coq, on the Calculus of Inductive Constructions (CIC). In particular, we analyze its architecture focusing on the dependencies of its components, how they implement the main functionalities, and their degree of reusability. The work is a first attempt to provide a ground for a more direct comparison between different systems and to highlight the common functionalities, not only in view of reusability but also to encourage a more systematic comparison of different softwares and architectural solutions.
     """]]
  1. <a class="paper-download" href="notation.pdf" title="download paper in PDF format">[.pdf]</a> <a class="bibtex-download" href="notation.bib" title="download bibliographic entry in BibTeX format">[.bib]</a> <span class="doi_logo"><a href="http://dx.doi.org/10.1007/11812289_16" title="Document Object Identifier">doi&gt;</a></span> <a href="http://www.sti.uniurb.it/padovani/">Luca Padovani</a>, <a href="http://upsilon.cc/~zack">Stefano Zacchiroli</a>. **From Notation to Semantics: There and Back Again**.  <em>
        In Proceedings of <a href="http://www.mkm-ig.org/meetings/mkm06/">MKM 2006</a>: The 5th
@@ -310,7 +310,7 @@ in reverse chronological order.
        5-7, 2006.
       </em>
     [[!toggle id=id13 text="Abstract..."]] [[!toggleable id=id13 text="""
-    *Abstract:* In many use cases applications are bound to be run consuming only a limited amount of memory. When they need to validate large XML documents, they have to adopt streaming validation, which does not rely on an in-memory representation of the whole input document. In order to validate an XML document, different kinds of constraints need to be verified. Co-constraints—which relate the content of elements to the presence and values of other attributes or elements—are one such kind of constraints. In this paper we propose an approach to the problem of validating in a streaming fashion an XML document against a schema also specifying co-constraints. We describe how the streaming evaluation of co-constraints influences the output of the validation process. Our proposal makes use of the validation language SchemaPath, a light extension to XML Schema, adding conditional type assignment for the support of co-constraints. The paper is based on the description of our streaming SchemaPath validator.
+    *Abstract:* In many use cases applications are bound to be run consuming only a limited amount of memory. When they need to validate large XML documents, they have to adopt streaming validation, which does not rely on an in-memory representation of the whole input document. In order to validate an XML document, different kinds of constraints need to be verified. Co-constraints, which relate the content of elements to the presence and values of other attributes or elements, are one such kind of constraints. In this paper we propose an approach to the problem of validating in a streaming fashion an XML document against a schema also specifying co-constraints. We describe how the streaming evaluation of co-constraints influences the output of the validation process. Our proposal makes use of the validation language SchemaPath, a light extension to XML Schema, adding conditional type assignment for the support of co-constraints. The paper is based on the description of our streaming SchemaPath validator.
     """]]
  1. <a class="paper-download" href="tinycals.pdf" title="download paper in PDF format">[.pdf]</a> <a class="bibtex-download" href="tinycals.bib" title="download bibliographic entry in BibTeX format">[.bib]</a> <span class="doi_logo"><a href="http://dx.doi.org/10.1016/j.entcs.2006.09.026" title="Document Object Identifier">doi&gt;</a></span> <a href="http://www.cs.unibo.it/~sacerdot">Claudio Sacerdoti Coen</a>, <a href="http://www.cs.unibo.it/~tassi">Enrico Tassi</a>, <a href="http://upsilon.cc/~zack">Stefano Zacchiroli</a>. **Tinycals: Step by Step Tacticals**.  <em>
        In Proceedings of <a href="http://www.ags.uni-sb.de/~omega/workshops/UITP06/">UITP 2006</a>:
@@ -380,7 +380,7 @@ in reverse chronological order.
        0002</a>, 22/05/2009.
       </em>
     [[!toggle id=id27 text="Abstract..."]] [[!toggleable id=id27 text="""
-    *Abstract:* Component-based systems often describe context requirements in terms of explicit inter-component dependencies. Studying large instances of such systems—such as free and open source software (FOSS) distributions—in terms of declared dependencies between packages is appealing. It is however also misleading when the language to express dependencies is as expressive as boolean formulae, which is often the case. In such settings, a more appropriate notion of component dependency exists: strong dependency. This paper introduces such notion as a first step towards modeling semantic, rather then syntactic, inter-component relationships. Furthermore, a notion of component sensitivity is derived from strong dependencies, with applications to quality assurance and to the evaluation of upgrade risks. An empirical study of strong dependencies and sensitivity is presented, in the context of one of the largest, freely available, component-based system.
+    *Abstract:* Component-based systems often describe context requirements in terms of explicit inter-component dependencies. Studying large instances of such systems, such as free and open source software (FOSS) distributions, in terms of declared dependencies between packages is appealing. It is however also misleading when the language to express dependencies is as expressive as boolean formulae, which is often the case. In such settings, a more appropriate notion of component dependency exists: strong dependency. This paper introduces such notion as a first step towards modeling semantic, rather then syntactic, inter-component relationships. Furthermore, a notion of component sensitivity is derived from strong dependencies, with applications to quality assurance and to the evaluation of upgrade risks. An empirical study of strong dependencies and sensitivity is presented, in the context of one of the largest, freely available, component-based system.
     """]]
  1. <a class="paper-download" href="mancoosi-d2.1.pdf" title="download paper in PDF format">[.pdf]</a> <a class="bibtex-download" href="mancoosi-d2.1.bib" title="download bibliographic entry in BibTeX format">[.bib]</a> <a href="http://www.di.univaq.it/diruscio/">Davide Di Ruscio</a>, <a href="http://www.di.univaq.it/pellicci/">Patrizio Pelliccione</a>, <a href="http://www.di.univaq.it/alfonso/">Alfonso Pierantonio</a>, <a href="http://upsilon.cc/~zack">Stefano Zacchiroli</a>. **Metamodel for Describing System Structure and State**.  <em>
        <a href="http://www.mancoosi.org">Mancoosi project</a>
@@ -412,7 +412,7 @@ in reverse chronological order.
          report UBLCS-2007-21</a>, August 2007, <a href="http://www.cs.unibo.it">Department of Computer Science</a>, <a href="http://www.unibo.it">University of Bologna</a>.
       </em>
     [[!toggle id=id16 text="Abstract..."]] [[!toggleable id=id16 text="""
-    *Abstract:* Content templating enables reuse of content structures between wiki pages. Such a feature is implemented in several mainstream wiki engines. Systematic study of its conceptual models and comparison of the available implementations are unfortunately missing in the wiki literature. In this paper we aim to fill this gap first analyzing template-related user needs, and then reviewing existing approaches at content templating. Our investigation shows that two models emerge—functional and creational templating—and that both have weakness failing to properly fit in "The Wiki Way". As a solution, we propose the adoption of creational templates enriched with light constraints, showing that such a solution has a low implementative footprint in state-of-the-art wiki engines, and that it has a synergy with semantic wikis.
+    *Abstract:* Content templating enables reuse of content structures between wiki pages. Such a feature is implemented in several mainstream wiki engines. Systematic study of its conceptual models and comparison of the available implementations are unfortunately missing in the wiki literature. In this paper we aim to fill this gap first analyzing template-related user needs, and then reviewing existing approaches at content templating. Our investigation shows that two models emerge, functional and creational templating, and that both have weakness failing to properly fit in "The Wiki Way". As a solution, we propose the adoption of creational templates enriched with light constraints, showing that such a solution has a low implementative footprint in state-of-the-art wiki engines, and that it has a synergy with semantic wikis.
     """]]
 
 # dissertations
@@ -425,7 +425,7 @@ in reverse chronological order.
          Miculan</a>).
       </em>
     [[!toggle id=id12 text="Abstract..."]] [[!toggleable id=id12 text="""
-    *Abstract:* Matita (that means pencil in Italian) is a new interactive theorem prover under development at the University of Bologna. When compared with state-of-the-art proof assistants, Matita presents both traditional and innovative aspects. The underlying calculus of the system, namely the Calculus of (Co)Inductive Constructions (CIC for short), is well-known and is used as the basis of another mainstream proof assistant—Coq—with which Matita is to some extent compatible. In the same spirit of several other systems, proof authoring is conducted by the user as a goal directed proof search, using a script for storing textual commands for the system. In the tradition of LCF, the proof language of Matita is procedural and relies on tactic and tacticals to proceed toward proof completion. The interaction paradigm offered to the user is based on the script management technique at the basis of the popularity of the Proof General generic interface for interactive theorem provers: while editing a script the user can move forth the execution point to deliver commands to the system, or back to retract (or "undo") past commands. Matita has been developed from scratch in the past 8 years by several members of the Helm research group, this thesis author is one of such members. Matita is now a full-fledged proof assistant with a library of about 1.000 concepts. Several innovative solutions spun-off from this development effort. This thesis is about the design and implementation of some of those solutions, in particular those relevant for the topic of user interaction with theorem provers, and of which this thesis author was a major contributor. Joint work with other members of the research group is pointed out where needed. The main topics discussed in this thesis are briefly summarized below. Disambiguation. Most activities connected with interactive proving require the user to input mathematical formulae. Being mathematical notation ambiguous, parsing formulae typeset as mathematicians like to write down on paper is a challenging task; a challenge neglected by several theorem provers which usually prefer to fix an unambiguous input syntax. Exploiting features of the underlying calculus, Matita offers an efficient disambiguation engine which permit to type formulae in the familiar mathematical notation. Step-by-step tacticals. Tacticals are higher-order constructs used in proof scripts to combine tactics together. With tacticals scripts can be made shorter, readable, and more resilient to changes. Unfortunately they are de facto incompatible with state-of-the-art user interfaces based on script management. Such interfaces indeed do not permit to position the execution point inside complex tacticals, thus introducing a trade-off between the usefulness of structuring scripts and a tedious big step execution behavior during script replaying. In Matita we break this trade-off with tinycals: an alternative to a subset of LCF tacticals which can be evaluated in a more fine-grained manner. Extensible yet meaningful notation. Proof assistant users often face the need of creating new mathematical notation in order to ease the use of new concepts. The framework used in Matita for dealing with extensible notation both accounts for high quality bidimensional rendering of formulae (with the expressivity of MathML-Presentation) and provides meaningful notation, where presentational fragments are kept synchronized with semantic representation of terms. Using our approach interoperability with other systems can be achieved at the content level, and direct manipulation of formulae acting on their rendered forms is possible too. Publish/subscribe hints. Automation plays an important role in interactive proving as users like to delegate tedious proving sub-tasks to decision procedures or external reasoners. Exploiting the Web-friendliness of Matita we experimented with a broker and a network of web services (called tutors) which can try independently to complete open sub-goals of a proof, currently being authored in Matita. The user receives hints from the tutors on how to complete sub-goals and can interactively or automatically apply them to the current proof. Another innovative aspect of Matita, only marginally touched by this thesis, is the embedded content-based search engine Whelp which is exploited to various ends, from automatic theorem proving to avoiding duplicate work for the user. We also discuss the (potential) reusability in other systems of the widgets presented in this thesis and how we envisage the evolution of user interfaces for interactive theorem provers in the Web 2.0 era.
+    *Abstract:* Matita (that means pencil in Italian) is a new interactive theorem prover under development at the University of Bologna. When compared with state-of-the-art proof assistants, Matita presents both traditional and innovative aspects. The underlying calculus of the system, namely the Calculus of (Co)Inductive Constructions (CIC for short), is well-known and is used as the basis of another mainstream proof assistant, Coq, with which Matita is to some extent compatible. In the same spirit of several other systems, proof authoring is conducted by the user as a goal directed proof search, using a script for storing textual commands for the system. In the tradition of LCF, the proof language of Matita is procedural and relies on tactic and tacticals to proceed toward proof completion. The interaction paradigm offered to the user is based on the script management technique at the basis of the popularity of the Proof General generic interface for interactive theorem provers: while editing a script the user can move forth the execution point to deliver commands to the system, or back to retract (or "undo") past commands. Matita has been developed from scratch in the past 8 years by several members of the Helm research group, this thesis author is one of such members. Matita is now a full-fledged proof assistant with a library of about 1.000 concepts. Several innovative solutions spun-off from this development effort. This thesis is about the design and implementation of some of those solutions, in particular those relevant for the topic of user interaction with theorem provers, and of which this thesis author was a major contributor. Joint work with other members of the research group is pointed out where needed. The main topics discussed in this thesis are briefly summarized below. Disambiguation. Most activities connected with interactive proving require the user to input mathematical formulae. Being mathematical notation ambiguous, parsing formulae typeset as mathematicians like to write down on paper is a challenging task; a challenge neglected by several theorem provers which usually prefer to fix an unambiguous input syntax. Exploiting features of the underlying calculus, Matita offers an efficient disambiguation engine which permit to type formulae in the familiar mathematical notation. Step-by-step tacticals. Tacticals are higher-order constructs used in proof scripts to combine tactics together. With tacticals scripts can be made shorter, readable, and more resilient to changes. Unfortunately they are de facto incompatible with state-of-the-art user interfaces based on script management. Such interfaces indeed do not permit to position the execution point inside complex tacticals, thus introducing a trade-off between the usefulness of structuring scripts and a tedious big step execution behavior during script replaying. In Matita we break this trade-off with tinycals: an alternative to a subset of LCF tacticals which can be evaluated in a more fine-grained manner. Extensible yet meaningful notation. Proof assistant users often face the need of creating new mathematical notation in order to ease the use of new concepts. The framework used in Matita for dealing with extensible notation both accounts for high quality bidimensional rendering of formulae (with the expressivity of MathML-Presentation) and provides meaningful notation, where presentational fragments are kept synchronized with semantic representation of terms. Using our approach interoperability with other systems can be achieved at the content level, and direct manipulation of formulae acting on their rendered forms is possible too. Publish/subscribe hints. Automation plays an important role in interactive proving as users like to delegate tedious proving sub-tasks to decision procedures or external reasoners. Exploiting the Web-friendliness of Matita we experimented with a broker and a network of web services (called tutors) which can try independently to complete open sub-goals of a proof, currently being authored in Matita. The user receives hints from the tutors on how to complete sub-goals and can interactively or automatically apply them to the current proof. Another innovative aspect of Matita, only marginally touched by this thesis, is the embedded content-based search engine Whelp which is exploited to various ends, from automatic theorem proving to avoiding duplicate work for the user. We also discuss the (potential) reusability in other systems of the widgets presented in this thesis and how we envisage the evolution of user interfaces for interactive theorem provers in the Web 2.0 era.
     """]]
  1. <a class="paper-download" href="master-thesis.pdf" title="download paper in PDF format">[.pdf]</a> <a class="bibtex-download" href="master-thesis.bib" title="download bibliographic entry in BibTeX format">[.bib]</a> <a href="http://upsilon.cc/~zack">Stefano Zacchiroli</a>. **Web services per il supporto alla dimostrazione interattiva (Web services for interactive theorem proving)**.  <em>
        Master thesis (Italian only), March 2003, <a href="http://www.cs.unibo.it">Department of Computer Science</a>, <a href="http://www.unibo.it">University of Bologna</a> (advisor: <a href="http://www.cs.unibo.it/~asperti">Andrea Asperti</a>; refereed
index f2c999b..a9022ca 100644 (file)
@@ -1,7 +1,7 @@
 @inproceedings{cbse2011-mpm,
   author = {Pietro Abate and Di Cosmo, Roberto and Ralf Treinen and Stefano Zacchiroli},
   title = {MPM: a modular package manager},
-  abstract = {Software distributions in the FOSS world rely on so-called package managers for the installation and removal of packages on target machines. State-of-the-art package managers are monolithic in architecture, and each of them is hard-wired to an ad-hoc dependency solver implementing a customized heuristics. In this paper we propose a modular architecture allowing for pluggable dependency solvers and backends. We argue that this is the path that leads to the next generation of package managers that will deliver better results, accept more expressive input languages, and can be easily adaptable to new platforms. We present a working prototype—called MPM—which has been implemented following the design advocated in this paper.},
+  abstract = {Software distributions in the FOSS world rely on so-called package managers for the installation and removal of packages on target machines. State-of-the-art package managers are monolithic in architecture, and each of them is hard-wired to an ad-hoc dependency solver implementing a customized heuristics. In this paper we propose a modular architecture allowing for pluggable dependency solvers and backends. We argue that this is the path that leads to the next generation of package managers that will deliver better results, accept more expressive input languages, and can be easily adaptable to new platforms. We present a working prototype, called MPM, which has been implemented following the design advocated in this paper.},
   publisher = {ACM},
   year = {2011},
   isbn = {978-1-4503-0723-9},
index f3fc82f..8500fdc 100644 (file)
@@ -1,7 +1,7 @@
 @inproceedings{enase2009-upgrade,
   author = {Antonio Cicchetti and Di Ruscio, Davide and Patrizio Pelliccione and Alfonso Pierantonio and Stefano Zacchiroli},
   title = {A Model Driven Approach to Upgrade Package-Based Software Systems},
-  abstract = {Complex software systems are more and more based on the abstraction of package, brought to popularity by Free and Open Source Software (FOSS) distributions. While helpful as an encapsulation layer, packages do not solve all problems of deployment, and more generally of management, of large software collections. In particular upgrades, which often affect several packages at once due to inter-package dependencies, often fail and do not hold good transactional properties. This paper shows how to apply model driven techniques to describe and manage software upgrades of FOSS distributions. It is discussed how to model static and dynamic aspects of package upgrades—the latter being the most challenging aspect to deal with—in order to be able to predict common causes of upgrade failures and undo residual effects of failed or undesired upgrades.},
+  abstract = {Complex software systems are more and more based on the abstraction of package, brought to popularity by Free and Open Source Software (FOSS) distributions. While helpful as an encapsulation layer, packages do not solve all problems of deployment, and more generally of management, of large software collections. In particular upgrades, which often affect several packages at once due to inter-package dependencies, often fail and do not hold good transactional properties. This paper shows how to apply model driven techniques to describe and manage software upgrades of FOSS distributions. It is discussed how to model static and dynamic aspects of package upgrades, the latter being the most challenging aspect to deal with, in order to be able to predict common causes of upgrade failures and undo residual effects of failed or undesired upgrades.},
   publisher = {Springer-Verlag},
   year = {2010},
   doi = {10.1007/978-3-642-14819-4_19},
index fc92245..464c2f3 100644 (file)
@@ -1,7 +1,7 @@
 @article{infsof2012-mpm,
   author = {Pietro Abate and Di Cosmo, Roberto and Ralf Treinen and Stefano Zacchiroli},
   title = {A Modular Package Manager Architecture},
-  abstract = {The success of modern software distributions in the Free and Open Source world can be explained, among other factors, by the availability of a large collection of software packages and the possibility to easily install and remove those components using state of the art package managers. However, package managers are often built using a monolithic architecture and hard-wired and ad-hoc dependency solvers implementing some customized heuristics. In this paper we propose a modular architecture relying on precise interface formalisms that allows the system administrator to choose from a variety of dependency solvers and backends. We argue that this is the path that leads to the next generation of package managers that will deliver better results, offer more expressive preference languages, and be easily adaptable to new platforms. We have built a working prototype—called MPM—following the design advocated in this paper, and we show how it largely outperforms a variety of state of the art package managers.},
+  abstract = {The success of modern software distributions in the Free and Open Source world can be explained, among other factors, by the availability of a large collection of software packages and the possibility to easily install and remove those components using state of the art package managers. However, package managers are often built using a monolithic architecture and hard-wired and ad-hoc dependency solvers implementing some customized heuristics. In this paper we propose a modular architecture relying on precise interface formalisms that allows the system administrator to choose from a variety of dependency solvers and backends. We argue that this is the path that leads to the next generation of package managers that will deliver better results, offer more expressive preference languages, and be easily adaptable to new platforms. We have built a working prototype, called MPM, following the design advocated in this paper, and we show how it largely outperforms a variety of state of the art package managers.},
   month = {February},
   year = {2013},
   issn = {0950-5849},
index 4558f08..103802f 100644 (file)
@@ -1,7 +1,7 @@
 @inproceedings{matita-crafting,
   author = {Andrea Asperti and Sacerdoti Coen, Claudio and Enrico Tassi and Stefano Zacchiroli},
   title = {Crafting a Proof Assistant},
-  abstract = {Proof assistants are complex applications whose development has never been properly systematized or documented. This work is a contribution in this direction, based on our experience with the development of Matita: a new interactive theorem prover based—as Coq—on the Calculus of Inductive Constructions (CIC). In particular, we analyze its architecture focusing on the dependencies of its components, how they implement the main functionalities, and their degree of reusability. The work is a first attempt to provide a ground for a more direct comparison between different systems and to highlight the common functionalities, not only in view of reusability but also to encourage a more systematic comparison of different softwares and architectural solutions.},
+  abstract = {Proof assistants are complex applications whose development has never been properly systematized or documented. This work is a contribution in this direction, based on our experience with the development of Matita: a new interactive theorem prover based, as Coq, on the Calculus of Inductive Constructions (CIC). In particular, we analyze its architecture focusing on the dependencies of its components, how they implement the main functionalities, and their degree of reusability. The work is a first attempt to provide a ground for a more direct comparison between different systems and to highlight the common functionalities, not only in view of reusability but also to encourage a more systematic comparison of different softwares and architectural solutions.},
   publisher = {Springer Berlin / Heidelberg},
   year = {2007},
   isbn = {978-3-540-74463-4},
index df72c2e..1cda3c8 100644 (file)
@@ -1,7 +1,7 @@
 @article{nrhm-overlapping-conversions,
   author = {Paolo Marinelli and Fabio Vitali and Stefano Zacchiroli},
   title = {Towards the unification of formats for overlapping markup},
-  abstract = {Overlapping markup refers to the issue of how to represent data structures more expressive than trees—for example direct acyclic graphs—using markup (meta-)languages which have been designed with trees in mind—for example XML. In this paper we observe that the state of the art in overlapping markup is far from being the widespread and consistent stack of standards and technologies readily available for XML and develop a roadmap for closing the gap. In particular we present in the paper the design and implementation of what we believe to be the first needed step, namely: a syntactic conversion framework among the plethora of overlapping markup serialization formats. The algorithms needed to perform the various conversions are presented in pseudo-code, they are meant to be used as blueprints for researchers and practitioners which need to write batch translation programs from one format to the other.},
+  abstract = {Overlapping markup refers to the issue of how to represent data structures more expressive than trees, for example direct acyclic graphs, using markup (meta-)languages which have been designed with trees in mind, for example XML. In this paper we observe that the state of the art in overlapping markup is far from being the widespread and consistent stack of standards and technologies readily available for XML and develop a roadmap for closing the gap. In particular we present in the paper the design and implementation of what we believe to be the first needed step, namely: a syntactic conversion framework among the plethora of overlapping markup serialization formats. The algorithms needed to perform the various conversions are presented in pseudo-code, they are meant to be used as blueprints for researchers and practitioners which need to write batch translation programs from one format to the other.},
   month = {January},
   year = {2008},
   issn = {1361-4568},
index 143790f..32fd4fa 100644 (file)
@@ -1,6 +1,6 @@
 @thesis{phd-thesis,
   author = {Stefano Zacchiroli},
   title = {User Interaction Widgets for Interactive Theorem Proving},
-  abstract = {Matita (that means pencil in Italian) is a new interactive theorem prover under development at the University of Bologna. When compared with state-of-the-art proof assistants, Matita presents both traditional and innovative aspects. The underlying calculus of the system, namely the Calculus of (Co)Inductive Constructions (CIC for short), is well-known and is used as the basis of another mainstream proof assistant—Coq—with which Matita is to some extent compatible. In the same spirit of several other systems, proof authoring is conducted by the user as a goal directed proof search, using a script for storing textual commands for the system. In the tradition of LCF, the proof language of Matita is procedural and relies on tactic and tacticals to proceed toward proof completion. The interaction paradigm offered to the user is based on the script management technique at the basis of the popularity of the Proof General generic interface for interactive theorem provers: while editing a script the user can move forth the execution point to deliver commands to the system, or back to retract (or "undo") past commands. Matita has been developed from scratch in the past 8 years by several members of the Helm research group, this thesis author is one of such members. Matita is now a full-fledged proof assistant with a library of about 1.000 concepts. Several innovative solutions spun-off from this development effort. This thesis is about the design and implementation of some of those solutions, in particular those relevant for the topic of user interaction with theorem provers, and of which this thesis author was a major contributor. Joint work with other members of the research group is pointed out where needed. The main topics discussed in this thesis are briefly summarized below. Disambiguation. Most activities connected with interactive proving require the user to input mathematical formulae. Being mathematical notation ambiguous, parsing formulae typeset as mathematicians like to write down on paper is a challenging task; a challenge neglected by several theorem provers which usually prefer to fix an unambiguous input syntax. Exploiting features of the underlying calculus, Matita offers an efficient disambiguation engine which permit to type formulae in the familiar mathematical notation. Step-by-step tacticals. Tacticals are higher-order constructs used in proof scripts to combine tactics together. With tacticals scripts can be made shorter, readable, and more resilient to changes. Unfortunately they are de facto incompatible with state-of-the-art user interfaces based on script management. Such interfaces indeed do not permit to position the execution point inside complex tacticals, thus introducing a trade-off between the usefulness of structuring scripts and a tedious big step execution behavior during script replaying. In Matita we break this trade-off with tinycals: an alternative to a subset of LCF tacticals which can be evaluated in a more fine-grained manner. Extensible yet meaningful notation. Proof assistant users often face the need of creating new mathematical notation in order to ease the use of new concepts. The framework used in Matita for dealing with extensible notation both accounts for high quality bidimensional rendering of formulae (with the expressivity of MathML-Presentation) and provides meaningful notation, where presentational fragments are kept synchronized with semantic representation of terms. Using our approach interoperability with other systems can be achieved at the content level, and direct manipulation of formulae acting on their rendered forms is possible too. Publish/subscribe hints. Automation plays an important role in interactive proving as users like to delegate tedious proving sub-tasks to decision procedures or external reasoners. Exploiting the Web-friendliness of Matita we experimented with a broker and a network of web services (called tutors) which can try independently to complete open sub-goals of a proof, currently being authored in Matita. The user receives hints from the tutors on how to complete sub-goals and can interactively or automatically apply them to the current proof. Another innovative aspect of Matita, only marginally touched by this thesis, is the embedded content-based search engine Whelp which is exploited to various ends, from automatic theorem proving to avoiding duplicate work for the user. We also discuss the (potential) reusability in other systems of the widgets presented in this thesis and how we envisage the evolution of user interfaces for interactive theorem provers in the Web 2.0 era.},
+  abstract = {Matita (that means pencil in Italian) is a new interactive theorem prover under development at the University of Bologna. When compared with state-of-the-art proof assistants, Matita presents both traditional and innovative aspects. The underlying calculus of the system, namely the Calculus of (Co)Inductive Constructions (CIC for short), is well-known and is used as the basis of another mainstream proof assistant, Coq, with which Matita is to some extent compatible. In the same spirit of several other systems, proof authoring is conducted by the user as a goal directed proof search, using a script for storing textual commands for the system. In the tradition of LCF, the proof language of Matita is procedural and relies on tactic and tacticals to proceed toward proof completion. The interaction paradigm offered to the user is based on the script management technique at the basis of the popularity of the Proof General generic interface for interactive theorem provers: while editing a script the user can move forth the execution point to deliver commands to the system, or back to retract (or "undo") past commands. Matita has been developed from scratch in the past 8 years by several members of the Helm research group, this thesis author is one of such members. Matita is now a full-fledged proof assistant with a library of about 1.000 concepts. Several innovative solutions spun-off from this development effort. This thesis is about the design and implementation of some of those solutions, in particular those relevant for the topic of user interaction with theorem provers, and of which this thesis author was a major contributor. Joint work with other members of the research group is pointed out where needed. The main topics discussed in this thesis are briefly summarized below. Disambiguation. Most activities connected with interactive proving require the user to input mathematical formulae. Being mathematical notation ambiguous, parsing formulae typeset as mathematicians like to write down on paper is a challenging task; a challenge neglected by several theorem provers which usually prefer to fix an unambiguous input syntax. Exploiting features of the underlying calculus, Matita offers an efficient disambiguation engine which permit to type formulae in the familiar mathematical notation. Step-by-step tacticals. Tacticals are higher-order constructs used in proof scripts to combine tactics together. With tacticals scripts can be made shorter, readable, and more resilient to changes. Unfortunately they are de facto incompatible with state-of-the-art user interfaces based on script management. Such interfaces indeed do not permit to position the execution point inside complex tacticals, thus introducing a trade-off between the usefulness of structuring scripts and a tedious big step execution behavior during script replaying. In Matita we break this trade-off with tinycals: an alternative to a subset of LCF tacticals which can be evaluated in a more fine-grained manner. Extensible yet meaningful notation. Proof assistant users often face the need of creating new mathematical notation in order to ease the use of new concepts. The framework used in Matita for dealing with extensible notation both accounts for high quality bidimensional rendering of formulae (with the expressivity of MathML-Presentation) and provides meaningful notation, where presentational fragments are kept synchronized with semantic representation of terms. Using our approach interoperability with other systems can be achieved at the content level, and direct manipulation of formulae acting on their rendered forms is possible too. Publish/subscribe hints. Automation plays an important role in interactive proving as users like to delegate tedious proving sub-tasks to decision procedures or external reasoners. Exploiting the Web-friendliness of Matita we experimented with a broker and a network of web services (called tutors) which can try independently to complete open sub-goals of a proof, currently being authored in Matita. The user receives hints from the tutors on how to complete sub-goals and can interactively or automatically apply them to the current proof. Another innovative aspect of Matita, only marginally touched by this thesis, is the embedded content-based search engine Whelp which is exploited to various ends, from automatic theorem proving to avoiding duplicate work for the user. We also discuss the (potential) reusability in other systems of the widgets presented in this thesis and how we envisage the evolution of user interfaces for interactive theorem provers in the Web 2.0 era.},
   year = {2007},
 }
index 7db550b..c5398ed 100644 (file)
@@ -1,7 +1,7 @@
 @article{scp2010-evolution,
   author = {Di Cosmo, Roberto and Di Ruscio, Davide and Patrizio Pelliccione and Alfonso Pierantonio and Stefano Zacchiroli},
   title = {Supporting Software Evolution in Component-Based FOSS Systems},
-  abstract = {FOSS (Free and Open Source Software) systems present interesting challenges in system evolution. On one hand, most FOSS systems are based on very fine-grained units of soft- ware deployment—called packages—which promote system evolution; on the other hand, FOSS systems are among the largest software systems known and require sophisticated static and dynamic conditions to be verified, in order to successfully deploy upgrades on user machines. The slightest error in one of these conditions can turn a routine upgrade into a system administrator nightmare. In this paper we introduce a model-based approach to support the upgrade of FOSS systems. The approach promotes the simulation of upgrades to predict failures before affecting the real system. Both fine-grained static aspects (e.g. configuration incoher- ences) and dynamic aspects (e.g. the execution of configuration scripts) are taken into account, improving over the state of the art of upgrade planners. The effectiveness of the approach is validated by instantiating the approach to widely-used FOSS distributions.},
+  abstract = {FOSS (Free and Open Source Software) systems present interesting challenges in system evolution. On one hand, most FOSS systems are based on very fine-grained units of software deployment, called packages, which promote system evolution; on the other hand, FOSS systems are among the largest software systems known and require sophisticated static and dynamic conditions to be verified, in order to successfully deploy upgrades on user machines. The slightest error in one of these conditions can turn a routine upgrade into a system administrator nightmare. In this paper we introduce a model-based approach to support the upgrade of FOSS systems. The approach promotes the simulation of upgrades to predict failures before affecting the real system. Both fine-grained static aspects (e.g. configuration incoherences) and dynamic aspects (e.g. the execution of configuration scripts) are taken into account, improving over the state of the art of upgrade planners. The effectiveness of the approach is validated by instantiating the approach to widely-used FOSS distributions.},
   year = {2011},
   issn = {0167-6423},
   doi = {10.1016/j.scico.2010.11.001},
index b43aea5..7379c34 100644 (file)
@@ -1,7 +1,7 @@
 @inproceedings{streaming-co-constraints,
   author = {Paolo Marinelli and Stefano Zacchiroli},
   title = {Co-Constraint Validation in a Streaming Context},
-  abstract = {In many use cases applications are bound to be run consuming only a limited amount of memory. When they need to validate large XML documents, they have to adopt streaming validation, which does not rely on an in-memory representation of the whole input document. In order to validate an XML document, different kinds of constraints need to be verified. Co-constraints—which relate the content of elements to the presence and values of other attributes or elements—are one such kind of constraints. In this paper we propose an approach to the problem of validating in a streaming fashion an XML document against a schema also specifying co-constraints. We describe how the streaming evaluation of co-constraints influences the output of the validation process. Our proposal makes use of the validation language SchemaPath, a light extension to XML Schema, adding conditional type assignment for the support of co-constraints. The paper is based on the description of our streaming SchemaPath validator.},
+  abstract = {In many use cases applications are bound to be run consuming only a limited amount of memory. When they need to validate large XML documents, they have to adopt streaming validation, which does not rely on an in-memory representation of the whole input document. In order to validate an XML document, different kinds of constraints need to be verified. Co-constraints, which relate the content of elements to the presence and values of other attributes or elements, are one such kind of constraints. In this paper we propose an approach to the problem of validating in a streaming fashion an XML document against a schema also specifying co-constraints. We describe how the streaming evaluation of co-constraints influences the output of the validation process. Our proposal makes use of the validation language SchemaPath, a light extension to XML Schema, adding conditional type assignment for the support of co-constraints. The paper is based on the description of our streaming SchemaPath validator.},
   year = {2006},
   booktitle = {XML 2006: The world's oldest and biggest XML conference},
 }
index c56fe8d..b1fc354 100644 (file)
@@ -1,7 +1,7 @@
 @inproceedings{strongdeps-esem-2009,
   author = {Pietro Abate and Jaap Boender and Di Cosmo, Roberto and Stefano Zacchiroli},
   title = {Strong Dependencies between Software Components},
-  abstract = {Component-based systems often describe context requirements in terms of explicit inter-component dependencies. Studying large instances of such systems—such as free and open source software (FOSS) distributions—in terms of declared dependencies between packages is appealing. It is however also misleading when the language to express dependencies is as expressive as boolean formulae, which is often the case. In such settings, a more appropriate notion of component dependency exists: strong dependency. This paper introduces such notion as a first step towards modeling semantic, rather then syntactic, inter-component relationships. Furthermore, a notion of component sensitivity is derived from strong dependencies, with applications to quality assurance and to the evaluation of upgrade risks. An empirical study of strong dependencies and sensitivity is presented, in the context of one of the largest, freely available, component-based system.},
+  abstract = {Component-based systems often describe context requirements in terms of explicit inter-component dependencies. Studying large instances of such systems, such as free and open source software (FOSS) distributions, in terms of declared dependencies between packages is appealing. It is however also misleading when the language to express dependencies is as expressive as boolean formulae, which is often the case. In such settings, a more appropriate notion of component dependency exists: strong dependency. This paper introduces such notion as a first step towards modeling semantic, rather then syntactic, inter-component relationships. Furthermore, a notion of component sensitivity is derived from strong dependencies, with applications to quality assurance and to the evaluation of upgrade risks. An empirical study of strong dependencies and sensitivity is presented, in the context of one of the largest, freely available, component-based system.},
   year = {2009},
   isbn = {978-1-4244-4842-5},
   doi = {10.1109/ESEM.2009.5316017},
index b66900c..baab8b7 100644 (file)
@@ -1,6 +1,6 @@
 @techreport{strongdeps-tr,
   author = {Pietro Abate and Jaap Boender and Di Cosmo, Roberto and Stefano Zacchiroli},
   title = {Strong Dependencies between Software Components},
-  abstract = {Component-based systems often describe context requirements in terms of explicit inter-component dependencies. Studying large instances of such systems—such as free and open source software (FOSS) distributions—in terms of declared dependencies between packages is appealing. It is however also misleading when the language to express dependencies is as expressive as boolean formulae, which is often the case. In such settings, a more appropriate notion of component dependency exists: strong dependency. This paper introduces such notion as a first step towards modeling semantic, rather then syntactic, inter-component relationships. Furthermore, a notion of component sensitivity is derived from strong dependencies, with applications to quality assurance and to the evaluation of upgrade risks. An empirical study of strong dependencies and sensitivity is presented, in the context of one of the largest, freely available, component-based system.},
+  abstract = {Component-based systems often describe context requirements in terms of explicit inter-component dependencies. Studying large instances of such systems, such as free and open source software (FOSS) distributions, in terms of declared dependencies between packages is appealing. It is however also misleading when the language to express dependencies is as expressive as boolean formulae, which is often the case. In such settings, a more appropriate notion of component dependency exists: strong dependency. This paper introduces such notion as a first step towards modeling semantic, rather then syntactic, inter-component relationships. Furthermore, a notion of component sensitivity is derived from strong dependencies, with applications to quality assurance and to the evaluation of upgrade risks. An empirical study of strong dependencies and sensitivity is presented, in the context of one of the largest, freely available, component-based system.},
   year = {2009},
 }
index 698815d..d37cf2f 100644 (file)
@@ -1,6 +1,6 @@
 @techreport{wiki-templating-tr,
   author = {Di Iorio, Angelo and Fabio Vitali and Stefano Zacchiroli},
   title = {Templating Wiki Content for Fun and Profit},
-  abstract = {Content templating enables reuse of content structures between wiki pages. Such a feature is implemented in several mainstream wiki engines. Systematic study of its conceptual models and comparison of the available implementations are unfortunately missing in the wiki literature. In this paper we aim to fill this gap first analyzing template-related user needs, and then reviewing existing approaches at content templating. Our investigation shows that two models emerge—functional and creational templating—and that both have weakness failing to properly fit in "The Wiki Way". As a solution, we propose the adoption of creational templates enriched with light constraints, showing that such a solution has a low implementative footprint in state-of-the-art wiki engines, and that it has a synergy with semantic wikis.},
+  abstract = {Content templating enables reuse of content structures between wiki pages. Such a feature is implemented in several mainstream wiki engines. Systematic study of its conceptual models and comparison of the available implementations are unfortunately missing in the wiki literature. In this paper we aim to fill this gap first analyzing template-related user needs, and then reviewing existing approaches at content templating. Our investigation shows that two models emerge, functional and creational templating, and that both have weakness failing to properly fit in "The Wiki Way". As a solution, we propose the adoption of creational templates enriched with light constraints, showing that such a solution has a low implementative footprint in state-of-the-art wiki engines, and that it has a synergy with semantic wikis.},
   year = {2007},
 }