Daniela Micucci

Falls as anomalies? An experimental evaluation using smartphone accelerometer data

Life expectancy keeps growing and, among elderly people, accidental falls occur frequently. A system able to promptly detect falls would help in reducing the injuries that a fall could cause. Such a system should meet the needs of the people to which is designed, so that it is actually used. In particular, the system should be minimally invasive and inexpensive. Thanks to the fact that most of the smartphones embed accelerometers and powerful processing unit, they are good candidates both as data acquisition devices and as platforms to host fall detection systems. For this reason, in the last years several fall detection methods have been experimented on smartphone accelerometer data. Most of them have been tuned with simulated falls because, to date, datasets of real-world falls are not available. This article evaluates the effectiveness of methods that detect falls as anomalies. To this end, we compared traditional approaches with anomaly detectors. In particular, we experienced the kNN and the SVM methods using both the one-class and two-classes configurations. The comparison involved three different collections of accelerometer data, and four different data representations. Empirical results demonstrated that, in most of the cases, falls are not required to design an effective fall detector.

Engineering spatial concepts

The success of a software system strongly depends on the ability of turning a precise domain analysis into a concrete architecture. Even if the domain model relies on sound ontological bases, there is often a wide semantic gap between the conceptual model and the concrete components that should reify it. To fill the semantic gap, relevant domain concepts should be engineered by identifying the corresponding architectural abstractions, which can be realized by concrete software components. Space plays a crucial role in many application domains, but surprisingly, related architectural abstractions have not emerged yet. This paper proposes space-related abstractions derived from the application of classical software engineering principles; in particular, the information hiding principle that leads to an operational definition of space. Basic abstractions are refined to deal with architectural aspects. As the underlying software engineering principles are close to principles that underlie the definition of space ontologies, the conjecture is that the proposed space architectural abstractions might be the basis for a formalization in ontological terms.

Space integration services: a platform for space-aware communication

The paper presents a platform aimed at supporting space-aware communications in emergency situations. The key idea is to rely on multiple spaces, be they physical or logical, and on mappings among spaces. Thematic information is published in one or more spatial publication contexts, whereas subscribers specify one or more spatial subscription contexts. Information is delivered whenever a non-empty intersection among publication and subscription contexts is recognized according to the space mappings. The platform defines basic space models that can be specialized to model domain-specific spaces. The paper overviews the basic platform mechanisms, sketches their exploitation in a concrete scenario and briefly discusses related works.

Automatic Software Repair: A Survey

Despite their growing complexity and increasing size, modern software applications must satisfy strict release requirements that impose short bug fixing and maintenance cycles, putting significant pressure on developers who are responsible for timely producing high-quality software. To reduce developers workload, repairing and healing techniques have been extensively investigated as solutions for efficiently repairing and maintaining software in the last few years. In particular, repairing solutions have been able to automatically produce useful fixes for several classes of bugs that might be present in software programs. A range of algorithms, techniques, and heuristics have been integrated, experimented, and studied, producing a heterogeneous and articulated research framework where automatic repair techniques are proliferating. This paper organizes the knowledge in the area by surveying a body of 108 papers about automatic software repair techniques, illustrating the algorithms and the approaches, comparing them on representative examples, and discussing the open challenges and the empirical evidence reported so far.

Architectural abstractions for spaces-based communication in Smart Environments

People often behave in Smart Environments by relying on spatial metaphors that deserve to turn into architectural abstractions. The paper presents a set of space-aware communication primitives that support the seamless integration of application components in an open-ended Smart Environment. Environment spaces provide subjective views of the environment according to specific spatial models, be they physical or logical. Software components communicate in a publish/subscribe style by contextualizing information in the spaces they are aware of. Space mappings allow components to interact even if they rely on different spatial models. The paper introduces a formal definition of basic spatial models and describes the spaces-based architectural abstractions through a reference example. Then it presents SIS (Space Integration Services), a concrete framework that reifies the abstractions, together with some performance measurements. Finally, it shows a concrete implementation of the reference scenario and compares the proposed approach with related work.

A platform for interoperability via multiple spatial views in open smart spaces

The paper presents an integration platform for space-based interoperability among heterogeneous components in open smart spaces. The key idea is to rely on multiple spaces, be they physical or logical, and on mappings among spaces. Components publish their information on one or more spatial publication contexts, whereas they make subscriptions to one or more spatial subscription contexts. Information is delivered whenever a non-empty intersection among publication and subscription contexts is recognized according to the space mappings. The platform defines basic space models that can be specialized to model domain-specific spaces. The paper presents the basic platform mechanisms and their application in a sample scenario, discusses the benefits of the approach and compares it to significant related works.

Grounding ecologies on multiple spaces

The paper introduces an architectural model, which pairs virtual and physical ecologies into augmented ecologies. The notion of space as a first class concept fosters a neat separation of the two main parts of an ecology: the environment and the organisms it contains. Virtual organisms view the common environment through multiple ecology spaces, described in terms of core space models and related by mappings between locations. This leads to a flexible space-aware paradigm supporting the indirect communication between organisms, including both message passing and data sharing. Finally, the paper presents a concrete framework reifying the model and an example application.

Reference Architecture and Framework

M. Adorni, F. Arcelli, S. Bandini, L. Baresi, C. Batini, A. Bianchi, D. Bianchini, M. Brioschi, A. Caforio, A. Cali, P. Cappellari, C. Cappiello, T. Catarci, A. Corallo, V. De Antonellis, C. Franza, G. Giunta, A. Limonta, G. Lorenzo, P. Losi, A. Maurino, M. Melideo, D. Micucci, S. Modafferi, E. Mussi, L. Negri, C. Pandolfo, B. Pernici, P. Plebani, D. Ragazzi, C. Raibulet, M. Riva, N. Simeoni, C. Simone, G. Solazzo, F. Tisato, R. Torlone, G. Vizzari, and A. Zilli

Policy enforcement with proactive libraries

Software libraries implement APIs that deliver reusable functionalities. To correctly use these functionalities, software applications must satisfy certain correctness policies, for instance policies about the order some API methods can be invoked and about the values that can be used for the parameters. If these policies are violated, applications may produce misbehaviors and failures at runtime. Although this problem is general, applications that incorrectly use API methods are more frequent in certain contexts. For instance, Android provides a rich and rapidly evolving set of APIs that might be used incorrectly by app developers who often implement and publish faulty apps in the marketplaces. To mitigate this problem, we introduce the novel notion of proactive library, which augments classic libraries with the capability of proactively detecting and healing misuses at runtime. Proactive libraries blend libraries with multiple proactive modules that collect data, check the correctness policies of the libraries, and heal executions as soon as the violation of a correctness policy is detected. The proactive modules can be activated or deactivated at runtime by the users and can be implemented without requiring any change to the original library and any knowledge about the applications that may use the library. We evaluated proactive libraries in the context of the Android ecosystem. Results show that proactive libraries can automatically overcome several problems related to bad resource usage at the cost of a small overhead.

Verifying Policy Enforcers

Policy enforcers are sophisticated runtime components that can prevent failures by enforcing the correct behavior of the software. While a single enforcer can be easily designed focusing only on the behavior of the application that must be monitored, the effect of multiple enforcers that enforce different policies might be hard to predict. So far, mechanisms to resolve interferences between enforcers have been based on priority mechanisms and heuristics. Although these methods provide a mechanism to take decisions when multiple enforcers try to affect the execution at a same time, they do not guarantee the lack of interference on the global behavior of the system. In this paper we present a verification strategy that can be exploited to discover interferences between sets of enforcers and thus safely identify a-priori the enforcers that can co-exist at run-time. In our evaluation, we experimented our verification method with several policy enforcers for Android and discovered some incompatibilities.