TheRuleInterchangeFormatProductionRuleDialect(RIF- PRD) is a W3C Recommendation to define production rules for the Semantic Web, whose semantics is defined operationally via labeled ter- minal transition systems.
In this paper, we introduce a declarative logical characterization of the full default semantics of RIF-PRD based on Answer Set Programming (ASP), including matching, conflict resolution and acting.
Our proposal to the semantics of RIF-PRD enjoys several features. Being based on ASP, it enables a straightforward integration with Logic Programming rule based technology, namely for reasoning and acting with ontologies. Then, its full declarative logical character facilitates the in- vestigation of formal properties of RIF-PRD itself. Furthermore, it turns out that our characterization based on ASP is flexible enough so that new conflict resolution semantics for RIF-PRD can easily be defined and encoded. Finally, it immediately serves as the declarative specification of an implementation, whose prototype we developed.

n/a

n/a

n/a

Transactional Memory allows programmers to reduce the number of synchronization errors introduced in concurrent programs, but does not ensures its complete elimination. This paper proposes a pattern matching based approach to the static detection of atomicity violation, based on a path-sensitive symbolic execution method to model four anomalies that may affect Transactional Memory programs. The proposed technique may be used to to bring to programmer's attention pairs of transactions that the programmer has mis-specified, and should have been combined into a single transaction. The algorithm first traverses the AST tree, removing all the non-transactional blocks and generating a trace tree in the path sensitive manner for each thread. The trace tree is a Trie like data structure, where each path from root to a leaf is a list of transactions. For each pair of threads, erroneous patterns involving two consecutive transactions are then checked in the trace tree. Results allow to conclude that the proposed technique, although triggering a moderate number of false positives, can be successfully applied to Java programs, correctly identifying the vast majority of the relevant erroneous patterns.

Dispersive liquid–liquid microextraction (DLLME) coupled with gas chromatography–mass spectrometry (GC–MS) was applied for the determination of 11 alkylphenols in eluates of chars produced in the co-pyrolysis of different wastes.

The optimized DLLME procedure, 4 mL of sample solution, 15 μL of trichloroethylene as extraction solvent, 1 mL of acetone as dispersion solvent and addition of 15% (w/v) of NaCl, was validated. Under the optimum conditions, the enrichment factors were in the range of 82–180. Calibration curves were constructed for each analyte in pure water in the concentration range of 0.5–8 μg/L with correlation coefficients higher than 0.999. The limits of detection were between 0.07 and 0.17 μg/L. The repeatability of the method was evaluated using water samples fortified with the analyte mixture at two concentration levels: the relative standard deviation (RSD) values were between 3.7% and 8.0% for a concentration of 0.5 μg/L, and between 4.2% and 6.4% for a concentration of 3 μg/L. The recoveries of the analytes evaluated by fortification of real eluate samples were in the range of 67.9–97.9% for eluate 1 (obtained from a decontaminated char) and in the range of 61.9–101.4% for eluate 2 (obtained from the untreated char). o-Methylphenol presented low recoveries for both eluates showing a possible matrix effect. The results obtained show that this method is adequate for the determination of alkylphenols in environmental aqueous samples and presents itself as a fast and inexpensive technique, using minor amounts of organic solvents.

Background: Aspect-oriented programming (AOP) is an
emerging programming paradigm whose focus is about improving
modularity, with an emphasis on the modularization of
crosscutting concerns.

Objective: The goal of this paper is to assess the extent to which
an AOP language – ObjectTeams/Java (OT/J) – improves the
modularity of a software system. This improvement has been
claimed but, to the best of our knowledge, this paper is the first
attempting to present quantitative evidence of it.

Method: We compare functionally-equivalent implementations of
the Gang-of-Four design patterns, developed in Java and OT/J,
using software metrics.

Results: The results of our comparison support the modularity
improvement claims made in the literature. For six of the seven
metrics used, the OT/J versions of the patterns obtained
significantly better results.

Limitations: This work uses a set of metrics originally defined
for object-oriented (OO) systems. It may be the case that the
metrics are biased, in that they were created in the context of OO
programming (OOP), before the advent of AOP. We consider this
comparison a stepping stone as, ultimately, we plan to assess the
modularity improvements with paradigm independent metrics,
which will conceivably eliminate the bias. Each individual
example from the sample used in this paper is small. In future, we
plan to replicate this experiment using larger systems, where the
benefits of AOP may be more noticeable.

Conclusion: This work contributes with evidence to fill gaps in
the body of quantitative results supporting alleged benefits to
software modularity brought by AOP languages, namely OT/J.

n/a

The recent developments in virtualization change completely the panorama of the Hardware/OS deployment. New bottlenecks arise in the deployment of application stacks, where IT industry will spend most of the time to assure automation. VIRTU tool aims at managing, configuring and testing distributed ground applications of space systems on a virtualized environment, based on open tools and cross virtualization support. This tool is a spin-off of previous activities performed by the European Space Operations Center (ESOC) and thus it covers the original needs from the ground data systems infrastructure division of the European Space Agency. VIRTU is a testing oriented solution. Its ability to group several virtual machines in an assembly provides the means to easily deploy a full testing infrastructure, including the client/server relationships. The possibility of making on-demand request of the testing infrastructure will provide some infrastructure optimizations, specially having in mind that ESA maintains Ground Control software of various missions, and each mission cam potentially have a different set of System baselines and last up to 15 years. The matrix array of supported system combinations is therefore enormous and any improvement on the process provides substantial benefits to ESA, by reducing the effort and schedule of each maintenance activity. The ESOC's case study focuses on the development and validation activities of infrastructure or mission Ground Systems solutions. The Ground Systems solutions are typically composed of distributed systems that could take advantage of virtualized environments for testing purposes. Virtualization is used as way to optimize maintenance for tasks such as testing new releases and patches, test different system's configurations and replicate tests. The main benefits identified are related to deployment test environment and the possibility to have on-demand infrastructure.

n/a

n/a

We prove a Fredholm criterion for operators in the Banach algebra of singular integral operators with matrix piecewise continuous coefficients acting on a variable Lebesgue space with a radial oscillating weight over a logarithmic Carleson curve. The local spectra of these operators are massive and have a shape of spiralic horns depending on the value of the variable exponent, the spirality indices of the curve, and the Matuszewska-Orlicz indices of the weight at each point. These results extend (partially) the results of A. Böttcher, Yu. Karlovich, and V. Rabinovich for standard Lebesgue spaces to the case of variable Lebesgue spaces.

SmART (Smart Application Reconfiguration Tool) is a framework for the automatic configuration of systems and applications. The tool implements an application configuration workflow that resorts to the similarities between configuration files (i.e., patterns such as parameters, comments and blocks) to allow a syntax independent manipulation and transformation of system and application configuration files.Without compromising its generality, SmART targets virtualized IT infrastructures, configuring virtual appliances and its applications. SmART reduces the time required to (re)configure a set of applications by automating time-consuming steps of the process, independently of the nature of the application to be configured. Industrial experimentation and utilization of SmART show that the framework is able to correctly transform a large amount of configuration files into a generic syntax and back to their original syntax. They also show that the elapsed time in that process is adequate to what would be expected of an interactive tool. SmART is currently being integrated into the VIRTU bundle, whose trial version is available for download from the projects web page.

Some performance issues of transactional memory are caused by unnecessary abort situations where non serializable and yet non conflicting transactions are scheduled to execute concurrently. Smartly relaxing the isolation properties of transactions may overcome these issues and attain considerable performance improvements. However, it is known that relaxing isolation restrictions may lead to runtime anomalies. In some situations, like database management systems, developers may choose that compromise, hence avoiding anomalies explicitly. Memory transactions protect the state of the program, therefore execution anomalies may have more severe consequences in the semantics of programs. So, the compromise between a relaxed isolation strategy and enforcing the necessary program correctness is harder to setup. The solution we devise is to statically analyse programs to detect the kind of anomalies that emerge under snapshot isolation. Our approach allows a compiler to either warn the developer about the possible snapshot isolation anomalies in a given program, or possibly inform automatic correctness strategies to ensure Serializability.