Martin A. Musicante

Schema Evolution for XML: A Consistency-Preserving Approach

This paper deals with updates of XML documents that satisfy a given schema, e.g., a DTD. In this context, when a given update violates the schema, it might be the case that this update is accepted, thus implying to change the schema. Our method is intended to be used by a data administrator who is an expert in the domain of application of the database, but who is not required to be a computer science expert. Our approach consists in proposing different schema options that are derived from the original one. The method is consistency-preserving: documents valid with respect to the original schema remain valid. The schema evolution is implemented by an algorithm (called GREC) that performs changes on the graph of a finite state automaton and that generates regular expressions for the modified graphs. Each regular expression proposed by GREC is a choice of schema given to the administrator.

Incremental Constraint Checking for XML Documents

We introduce a method for building an XML constraint validator from a given set of schema, key and foreign key constraints. The XML constraint validator obtained by our method is a bottom-up tree transducer that is used not only for checking, in only one pass, the correctness of an XML document but also for incrementally validating updates over this document. In this way, both the verification from scratch and the update verification are based on regular (finite and tree) automata, making the whole process efficient.

ANEMONA: a programming language for network monitoring applications

This work presents ANEMONA: A language for programming NEtwork MONitoring Applications. The compilation of an ANEMONA program generates code for configuring a policy repository and the corresponding policy deployment and event monitoring. The language allows the definition of expressions of managed objects that are monitored, as well as triggers that when fired may indicate the occurrence of associated events, which are also defined by the language. A translator for the language was implemented that generates code for configuring both the policy repository and deployment. The current implementation of the language employs the Expression MIB and Event MIB. Experimental results are presented, including an ANEMONA program that detects TCP Syn Flooding attacks, and a program for detecting steep variations in the utilization of monitored links.

Approximate reasoning for real-time probabilistic processes

We develop a pseudo-metric analogue of bisimulation for generalized semiMarkov processes. The kernel of this pseudo-metric corresponds to bisimulation; thus we have extended bisimulation for continuous-time probabilistic processes to a much broader class of distributions than exponential distributions. This pseudo-metric gives a useful handle on approximate reasoning in the presence of numerical information - such as probabilities and time - in the model. We give a fixed point characterization of the pseudo-metric. This makes available coinductive reasoning principles for reasoning about distances. We demonstrate that our approach is insensitive to potentially ad hoc articulations of distance by showing that it is intrinsic to an underlying uniformity. We provide a logical characterization of this uniformity using a real-valued modal logic. We show that several quantitative properties of interest are continuous with respect to the pseudo-metric. Thus, if two processes are metrically close, then observable quantitative properties of interest are indeed close.

PEWS platform: a web services composition environment

PEWS (Predicate Path Expression for Web Services) is a programming language for the definition of web service behavioral interfaces. PEWS programs can be used for the description of both simple and composite web services. Simple web services can be built from scratch, by the combination of operations defined in a WSDL description file. Composite web services are constructed from the combination of existing web services, accessed by using their WSDL descriptions. PEWS operators help to define the order in which web services and operations will be performed. This paper presents a PEWS programs edition environment. This environment is in the form of a web interface that enables programmers to edit, test and run composition specifications. The front-end of the environment, i.e. the web interface, interacts with the back-end, a server-side application, for the specification analysis. Our platform offers the possibility of an automatic translation of a PEWS specification into a Java program skeleton, directly executable, to call the web service operations and perform them in the order defined by the PEWS specification. Thus, the use of this platform can help reducing the time for development of the compositions

Composing Web Services with PEWS: A Trace-Theoretical Approach

PEWS is an interface description language for both individual and composed Web services. Individual Web services are expressions over WSDL-defined operations while composed Web services are expressions over PEWS-defined services. This paper distinguishes two dimensions of PEWS. The control dimension describes the control workflow of the service, i.e. the order in which the operations of the Web service will be executed. No data constraints are imposed. The data dimension adds information flow to the control dimension. In order to analyse the composability and the substitutability of composed services, we introduce a trace-theoretical presentation of the language constructs. Our long-term goal is to integrate PEWS into a Web service design system that checks useful properties of the service specification

Regular expression transformations to extend regular languages (with application to a Datalog XML schema validator)

An XML schema is a set of rules for defining the allowed sub-elements of any element in an XML document. These rules use regular expressions to define the language of the elements children. Updates to an XML schema are updates to the regular expressions defined by the schema rules. We consider an interactive, data administration tool for XML databases. In this tool, changes on an XML schema are activated by updates that violate the validity of an XML document. Our schema validator is a Datalog program, resulting from the translation of a given XML schema. Changing the schema implies changing the validator. The main contribution of this paper is an algorithm allowing the evolution of XML schemas. This algorithm is based on the computation of new regular expressions to extend a given regular language in a conservative way, trying to foresee the needs of an application. A translation function from schema constraints to Datalog programs is introduced. The validation of an XML tree corresponds to the evaluation of the Datalog program over the tree. Our method allows the maintenance of the Datalog program in an incremental way, i.e., without redoing the entire translation.

Specification and Runtime Verification of Java Card Programs

Java Card is a version of Java developed to run on devices with severe storage and processing restrictions. The applets that run on these devices are frequently intended for use in critical, highly distributed, mobile conditions. They are required to be portable and safe. Often, the requirements of the application impose the use of dynamic, on-card verifications, but most of the research developed to improve safety of Java Card applets concentrates on static verification methods. This work presents a runtime verification approach based on Design by Contract to improve the safety of Java Card applications. To this end, we propose JCML (Java Card Modeling Language) a specification language derived from JML (Java Modeling Language) and its implementation: a compiler that generates runtime verification code. We also present some experiments and quality indicators.

JCML: A specification language for the runtime verification of Java Card programs

Java Card is a version of Java developed to run on devices with severe storage and processing restrictions. The applets that run on these devices are frequently intended for use in critical, highly distributed, mobile conditions. They are required to be portable and safe. Often, the requirements of the application impose the use of dynamic, on-card verifications, but most of the research developed to improve the safety of Java Card applets concentrates on static verification methods. This work presents a runtime verification approach based on Design by Contract to improve the safety of Java Card applications. To this end, we propose JCML (Java Card Modelling Language) a specification language derived from JML (Java Modelling Language) and its implementation: a compiler that generates runtime verification code. We also present some experiments and quality indicators. This paper extends previous published work from the authors with a more complete and precise definition of the JCML language and new experiments and results.

Conservative type extensions for XML data

We introduce a method for building a minimal XML type (belonging to standard class of regular tree grammars) as an extension of other given types. Not only do we propose an easy-to-handle XML type evolution method, but we prove that this method computes the smallest extension of a given tree grammar, respecting pre-established constraints. We also adapt our technique to an interactive context, where an advised user is guided to build a new XML type from existing ones. A basic prototype of our tool is implemented.