Miguel Oliveira e Silva

A class discriminality measure based on feature space partitioning

This paper presents a new class discriminability measure based on an adaptive partitioning of the feature space according to the available class samples. It is intended to be used as a criterion in a classifier-independent feature selection procedure. The partitioning is performed according to a binary splitting rule and appropriate stopping criteria. Results from several tests withc Gaussian and non-GAussian, multidimensional and multicalss computer-generated samples, were very similar to those obtained using a Bayes error criterion function, i.e. the optimal feature subsets selected by both criterion functions were the same. The main advantage of the new measure is that it is computationally efficient.

Evaluation of Complex Distributed Multimodal Applications: Evaluating a TeleRehabilitation System When It Really Matters

The evaluation of applications or systems within dynamic environments is complex. The existence of multiple hardware and software items which share the same space can provoke concurrency issues and result in erratic interactions. A sudden change within the environment can result is dramatic changes both to the user and application itself which can pass unnoticed in traditional evaluation methodologies. To verify if a component is compatible with a given environment is of paramount importance for areas like pervasive computing, ambient intelligence or ambient assisted living (AAL). In this paper, a semi-automatic platform for evaluation is presented and integrated with a TeleRehabilitation system in an AAL scenario to enhance evaluation. Preliminary results show the advantages of the platform in comparison with typical observation solutions mainly in terms of achieved data and overall ease of use.

Design and Development of Multimodal Applications: A Vision on Key Issues and Methods

Multimodal user interfaces provide users with different ways of interacting with applications. This has advantages both in providing interaction solutions with additional robustness in environments where a single modality might result in ambiguous input or output (e.g., speech in noisy environments), and for users with some kind of limitation (e.g., hearing difficulties resulting from ageing) by yielding alternative and more natural ways of interacting. The design and development of applications supporting multimodal interaction involves numerous challenges, particularly if the goals include the development of multimodal applications for a wide variety of scenarios, designing complex interaction and, at the same time, proposing and evolving interaction modalities. These require the choice of an architecture, development and evaluation methodologies and the adoption of principles that foster constant improvements at the interaction modalities level without disrupting existing applications. Based on previous and ongoing work, by our team, we present our approach to the design, development and evaluation of multimodal applications covering several devices and application scenarios.

Applications of the Multimodal Interaction Architecture in Ambient Assisted Living

Developing applications for ambient assisted living (AAL) scenarios requires dealing with diverse user groups, heterogeneous environments, and a large plethora of devices. These requirements pose several challenges on how to design and develop user interaction with the proposed applications and services. In this context, the versatility provided by multimodal interaction (MMI) is paramount and the adopted architecture should be instrumental in harnessing its full potential. This chapter offers an insight on how AAL challenges can be tackled by multimodal-based solutions. It presents the authors’ views and research outcomes in multimodal application development for AAL grounded on an architecture for MMI aligned with the W3C recommendations.

An Ontology for Human-Machine Computation Workflow Specification

Lately, a focus has been given to the re-usability of workflow definitions and to flexible and re-usable workflow components, culminating with approaches that harness the benefits of the enriched semantics provided by ontologies. Following this trend and the needs of multiple application domains, such as micro-task crowdsourcing and ambient assisted living, of incorporating cooperation between the efforts of human and machine entities, this paper proposes an ontology and process for the definition, instantiation and execution of semantically enriched workflows.

Concurrent Object-Oriented Programming: The MP-Eiffel Approach.

concurrent programming Since we are interested in the essential properties of concurrency, we don’t want to bind our concurrent processing entities to specific “lower level” realizations such as threads, processes, object request brokers, MPI, PVM, or any other. Instead, we will use an abstract notion of “processor” adapted from Meyer [Mey97, page 964]: 2 JOURNAL OF OBJECT TECHNOLOGY Submitted to TOOLS USA 2003 2 CONCURRENT PROGRAMMING A processor is an autonomous thread of control capable of supporting the sequential execution of instructions. Nothing is assumed on how this virtual processor will be implemented at runtime. We won’t even exclude the possibility that a processor may start by being a thread in one machine and end as a process in another through a remote procedure call mechanism. In general, concurrency does not require simultaneous (parallel) processor execution. A concurrent program can be thought as the concurrent execution of sequential “programs”, one for each processor (of course, they may depend highly on each other). From a concurrent programming system we expect the ability to – safely – specify and control two things: • concurrent execution of processors; • inter-processor synchronization and communication. Concurrent execution of processors Concurrent systems need mechanisms to start, support, and terminate the execution of processors, either as part of the programming language constructs or provided in a library. In particular they need to assign processors to specific processing devices (threads, processes, computers in a distributed system, or any other). This assignment will be called heterogeneous if the concurrent system allows the assignment of different processing devices for processors, otherwise it will be classified as homogeneous processor mapping. Heterogeneous processor mapping is a desirable property since it enforces the decoupling between a concurrent program and specific processing devices. However, specific types of concurrent programming, such as real-time and embedded systems may pose strong restrictions to valid (feasible) processor mappings. Inter-processor synchronization and communication To ensure a correct inter-processor interaction it is necessary to enforce proper timing constraints between them. Such synchronization requirements may arise from the necessity to guarantee safety properties [Lam83], the verification of some condition, the need to impose a specific processor scheduling strategy [RF77], or several of these possibilities at the same time. Submitted to TOOLS USA 2003 JOURNAL OF OBJECT TECHNOLOGY 3 CONCURRENT OBJECT-ORIENTED PROGRAMMING: THE MP-EIFFEL APPROACH

Live evaluation within ambient assisted living scenarios

Ambient Assisted Living is a new challenge within evaluation processes. It represents high levels of data and a strong focus on the user itself by encompassing dynamical environments with contextual data and by offering several interaction modalities. In such scenarios, traditional question-answer processes fail short to retrieve the necessary amount of data for more comprehensive evaluations. In this paper, we propose an enhanced evaluation approach adapted to these new demands. The proposal follows a user-centric approach and provides an integrative platform for evaluators to gather more information. This platform is characterized by a reusable enquiry module, its ability for real time monitoring and a event-driven dynamic module for adaptable evaluation processes. As a proof of concept, a concrete scenario based on a telerehabilitation application is also presented.

External Dispatch: Yet Another Object-Oriented Single and Multiple Dispatch Mechanism.

Although multiple dispatch properly solves difficult programming problems such as binary methods, the large majority of existing object-oriented programming languages still don’t support it. The few languages that provide such a mechanism do so in ways that either lie outside an object-oriented modular construct (class), or possess some other limitations, such as arbitrarily choosing one of the dispatch object types as the repository for dispatch methods. This article presents a new objectoriented language mechanism for single and multiple dispatch. As a proof of concept, we will use Java as the base language. This mechanism is compatible with existing object-oriented language constructs, and provides a simple, expressive, and universal dispatch tool. Our proposal introduces a new object-oriented external dispatch mechanism, which complements the traditional object-oriented internal single dispatch mechanism. This new mechanism is applicable not only to multiple dispatch, but can also be used as an alternative to decorators and some creational design patterns. A more complete realization for external dispatch motivated the definition of a new singleton language mechanism that is also presented.

Contract-Java: Design by Contract in Java with Safe Error Handling

Design by Contract (DbC) is a programming methodology in which the meaning of program entities, such as methods and classes, is made explicit by the use of programming predicates named assertions. A false assertion is always a manifestation of an incorrect program. This simple founding idea, when properly applied, give programmers a tool able to specify, test, debug, document programs, as well as a mechanism to construct a simple, safe and sane error handling mechanism. Nevertheless, although well adapted to object-oriented programming (and other popular techniques such as unit testing), DbC still has a very low practical acceptance and application. We believe that one of the main reasons for such is the lack of a proper support for it in many programming languages currently in use (such as Java). A complete support for DbC requires not only the ability to specify assertions; but also the necessity to distinguish different kinds of assertions, depending of what is being asserted; a proper integration in object-oriented programming; and, finally, a coherent connection with error handling mechanisms. It is in this last requirement that existing tools that extend Java with DbC mechanisms completely fail to properly, and coherently, integrate DbC within Java programming. The dominant practices for systematically handling failures in programming languages are not DbC based, using instead a defensive programming approach, either by using normal languages mechanisms (as in programming language C) or by the use of typed exceptions in try/catch based exception mechanisms. In this article, we will present and justify the requirements posed on programming languages for a complete support for DbC; On the context of the last presented requirement – error handling – defensive programming will be discussed and criticized; It will be showed that, unlike Eiffels original DbC error handling, existing typed exceptions in try/catch based exception mechanisms are not well adapted to algorithmic abstraction provided by methods; Finally, a new DbC Java extension named Contract-Java will be presented and it will be showed that it is coherently integrated both with Java existing mechanisms and DbC. It will be presented an innovative Contract-Java extension to DbC that automatically generates debugging information for (non-rescued) contract failures, that we believe further enhances the DbC debugging capabilities.