60 research outputs found
Using a Machine Learning Approach to Implement and Evaluate Product Line Features
Bike-sharing systems are a means of smart transportation in urban
environments with the benefit of a positive impact on urban mobility. In this
paper we are interested in studying and modeling the behavior of features that
permit the end user to access, with her/his web browser, the status of the
Bike-Sharing system. In particular, we address features able to make a
prediction on the system state. We propose to use a machine learning approach
to analyze usage patterns and learn computational models of such features from
logs of system usage.
On the one hand, machine learning methodologies provide a powerful and
general means to implement a wide choice of predictive features. On the other
hand, trained machine learning models are provided with a measure of predictive
performance that can be used as a metric to assess the cost-performance
trade-off of the feature. This provides a principled way to assess the runtime
behavior of different components before putting them into operation.Comment: In Proceedings WWV 2015, arXiv:1508.0338
Hacking an Ambiguity Detection Tool to Extract Variation Points: an Experience Report
Natural language (NL) requirements documents can be a precious source to identify variability information. This information can be later used to define feature models from which different systems can be instantiated. In this paper, we are interested in validating the approach we have recently proposed to extract variability issues from the ambiguity defects found in NL requirement documents. To this end, we single out ambiguities using an available NL analysis tool, QuARS, and we classify the ambiguities returned by the tool by distinguishing among false positives, real ambiguities, and variation points.
We consider three medium sized requirement documents from different domains, namely, train control, social web, home automation. We report in this paper the results of the assessment. Although the validation set is not so large, the results obtained are quite uniform and permit to draw some interesting conclusions.
Starting from the results obtained, we can foresee the tailoring of a NL analysis tool for extracting variability from NL requirement documents
Raffinamento nei linguaggi a spazi di Tuple
Dottorato di ricerca in informatica. Supervisore C. Montangero. Coordinatore U. MontanariConsiglio Nazionale delle Ricerche - Biblioteca Centrale - P.le Aldo Moro, 7, Rome; Biblioteca Nazionale Centrale - P.za Cavalleggeri, 1, Florence / CNR - Consiglio Nazionale delle RichercheSIGLEITItal
Distributed States Logic
We introduce a temporal logic to reason on global applications.
First, we define a modal logic for localities that embeds the local
theories of each component into a theory of the distributed states of the
system. We provide the logic with a sound and complete axiomatization.
Then, we extend the logic with temporal operators. The contribution is
that it is possible to reason about properties that involve several
components, even in the absence of a global clock, as required in an
asynchronous setting. We support our proposal by working out an example, a
simple secure communication system
Refining by architectural style or Architecting by refinements
In L. Vidal, A.Finkelstein, G. Spanoudakis, and A. L. Wolf (eds) Joint Proceedings of the ACM SIGSOFT 96 Workshops, Part I, 2nd Int. Software Architecture Workshop. S. Francisco, October 1996, ACM Press, pp 76-7
A Lightweight Approach to the Early Detection and Resolution of Feature Interactions
The feature interaction problem has been recognized as a general problem of software engineering, whenever one wants to reap the advantages of incremental development. In this context, a feature is a unit of change to be integrated in a new version of the system under development, and the problem is that new features may interact with the others in unexpected ways. We introduce a common abstract model, to be built during early requirement analysis in a feature oriented development. The model is common, since all the features share it, and is an abstraction of the behavioural model retaining only what is needed to characterize each feature with respect to their possible interactions. The basic constituents are the abstract resources that the features access in their operations, the access mode (read or write), and the reason of each access. Given the model, the interactions between the features are automatically detected, and the goal oriented characterization of the features provides the developers with valuable suggestions on how to qualify them as synergies or conflicts (good and bad interactions), and on how to resolve conflicts. We provide evidence of the feasibility of the approach with an extended example from the Smart Home domain. The main contribution is a lightweight state-based technique to support the developers in the early detection and resolution of the conflicts between features
A Refinement Calculus for Tuple Spaces
It is fairly accepted that the realization of complex systems must
be accomplished step by step from the initial specification, through a
sequence of intermediate phases, to the final program. These
development steps, linking a preliminary version, or description, of
the program to a more detailed one, are usually called
refinement steps, while the intermediate stages of a refinement
process are called levels of abstraction.
A refinement calculus is a means to support this modus operandi
in program development, allowing to link different levels of
abstraction: it introduces a precise relation between intermediate
descriptions, and the rules to check whether the relation is
satisfied.
Tuple space languages are concurrent languages, that foster the
definition of autonomous entities of computation (the processes), and
offer mechanisms for their synchronization and communication. In
particular, they represent one of the most acknowledged models of
coordination.
Tuple space languages are based on the idea that a dynamic collection
of tuples can act as shared state of concurrent processes, and play
the role of coordination media among them.
To build a refinement calculus for tuple spaces, we address three
points, in this paper:
1) We single out a specification language, a variation of first order
temporal logic. Temporal relations between propositional formulae are
not expressive enough to describe relations between tuple spaces,
which are multisets of atoms. The specification language, called
Oikos-tl, includes three new temporal operators that enhance the
expressive power of the logic, permitting to directly link state
transitions and state configurations. The semantics of the
specification language is formally defined, and a set of useful
properties for refinement are shown.
2) We introduce a reference language for tuple spaces, dubbed TuSpRel,
and define its axiomatic and operational semantics. We need the
former to derive properties, the latter to describe the allowed
computations of a system. We relate these descriptions, and guarantee
that using the axiomatic semantics we can derive properties, which are
correct and complete with respect to the operational behaviour. The
non-deterministic features of tuple space languages make this result
new, and more complex than in other programming paradigms. One of the
contributions of our work is the idea to derive weakest preconditions
exploiting the demonic strict choice in non-deterministic selection.
The transition system defining the operational semantics is based on
the new notion of enabling precondition, which exploits the angelic
strict choice.
3) To build the refinement calculus, we take a compositional
approach. We first consider the basic statements of the language, and
say under which conditions they satisfy a property, then compose these
proofs to derive that a system refines a specification. Finally, in
the refinement calculus definition, we extend to tuple space languages
the ability to exploit logic formulae to specify the behaviour of
unrefined modules: in the intermediate steps, a system is only
partially written in the programming language, and the still unrefined
features are described by logical formulae
- …