Alvaro Soria

Easy gesture recognition for Kinect

Abstract Recent progress in entertainment and gaming systems has brought more natural and intuitive human–computer interfaces to our lives. Innovative technologies, such as Xbox Kinect, enable the recognition of body gestures, which are a direct and expressive way of human communication. Although current development toolkits provide support to identify the position of several joints of the human body and to process the movements of the body parts, they actually lack a flexible and robust mechanism to perform high-level gesture recognition. In consequence, developers are still left with the time-consuming and tedious task of recognizing gestures by explicitly defining a set of conditions on the joint positions and movements of the body parts. This paper presents EasyGR (Easy Gesture Recognition), a tool based on machine learning algorithms that help to reduce the effort involved in gesture recognition. We evaluated EasyGR in the development of 7 gestures, involving 10 developers. We compared time consumed, code size, and the achieved quality of the developed gesture recognizers, with and without the support of EasyGR. The results have shown that our approach is practical and reduces the effort involved in implementing gesture recognizers with Kinect.

Artificial intelligence in service-oriented software design

Service-Oriented Architecture (SOA) has gained considerable popularity for the development of distributed enterprise-wide applications within the software industry. The SOA paradigm promotes the reusability and integrability of software in heterogeneous environments by means of open standards. Most software companies capitalize on SOA by discovering and composing services already accessible over the Internet, whereas other organizations need internal control of applications and develop new services with quality-attribute properties tailored to their particular environment. Therefore, based on architectural and business requirements, developers can elaborate different alternatives within a SOA framework to design their software applications. Each of these alternatives will imply trade-offs among quality attributes, such as performance, dependability and availability, among others. In this context, Artificial Intelligence (AI) can assist developers in dealing with service-oriented design with the positive impact on scalability and management of generic quality attributes. In this paper, we offer a detailed, conceptualized and synthesized analysis of AI research works that have aimed at discovering, composing, or developing services. We also identify open research issues and challenges in the aforementioned research areas. The results of the characterization of 69 contemporary approaches and potential research directions for the areas are also shown. It is concluded that AI has aimed at exploiting the semantic resources and achieving quality-attribute properties so as to produce flexible and adaptive-to-change service discovery, composition, and development.

Supporting Virtual Meetings in Distributed Scrum Teams

Scrum has gained surprising momentum as an agile project management approach. It provides effective social integration by building up social team capital, and it provides much needed control and coordination mechanisms. Especially, daily Scrum meetings ensure an open channel for communication. However, this channel has been threatened by distributed software development which has highly been adopted in software industries. To support virtual meetings regardless physical locations of team members, we developed a 3D tool based on Scrum life cycle. The tool provides a virtual world consisted in technology to hold meetings in a Scrum context. We used a questionnaire to evaluate the usability and effectiveness of the tool with undergraduate students.

Assisting the synchronization of UCM-based architectural documentation with implementation

A key aspect of architecture-centric development is the traceability of design documentation. In particular, architects should be always aware of the relationships between the architectural model “as documented” and its corresponding implementation model. The problem is that these two models usually diverge from each other over time, due to factors such as new requirements, refactorings, etc. Therefore, tool assistance is very important to assess the level of conformance between architectural documentation and implementation. In this paper, we present a tool approach called ArchSync that helps architects to conciliate architectural documentation expressed through Use-Case Maps with Java source code, as modifications are being made on the code. ArchSync relies on a heuristic that incrementally detects inconsistencies with respect to the architectural prescriptions, based on the analysis of system execution traces. ArchSync can also give suggestions for re-synchronization. Results of two case-studies showing the applicability of the approach are reported.

Tool Support for Fault Localization Using Architectural Models

Locating software faults is a problematic activity in many systems. Existing tool approaches usually work close to the system implementation, requiring the developer to perform tedious code analyses in which the amount of information she must manage is usually overwhelming. This problem calls for approaches able to work at higher abstraction levels than code. In this context, we present a tool approach, called FLABot, to assist fault-localization tasks. A novelty of FLABot is that it reasons about faults using software architecture information. Based on Use-case-maps and system logs, FLABot performs a heuristic search for possible faulty functions in the architecture, and then maps these functions to code sections. This allows the developer to quickly navigate large systems and spot code regions that may contain faults, which can be further debugged using conventional techniques. Our preliminary experiments have shown that FLABot is practical and reduces the efforts for discovering faults.

Architecture-driven assistance for fault-localization tasks

Finding software faults is a problematic activity in many systems. Existing approaches usually work close to the system implementation and require developers to perform different code analyses. Although these approaches are effective, the amount of information to be managed by developers is often overwhelming. This problem calls for complementary approaches able to work at higher levels of abstraction than code, helping developers to keep intellectual control over the system when analyzing faults. In this context, we present an expert-system approach, called FLABot, which assists developers in fault-localization tasks by reasoning about faults using software architecture models. We have evaluated a prototype of FLABot in two medium-size case studies, involving novice and non-novice developers. We compared time consumed, code browsed and faults found by these developers, with and without the support of FLABot, observing interesting effort reductions when applying FLABot. The results and lessons learned have shown that our approach is practical and reduces the efforts for finding individual faults.

Teaching scrum to software engineering students with virtual reality support

Scrum has received significant academic attention because of its widespread application in software development industries. Teaching agile software development can be illustrated by teaching with lecture-based classes. However, involving students in a real software environment is a trendy alternative which fosters their engagement. Software engineering graduates are not appropriately prepared for applying their skills in a real software project. Thus, we focus on teaching and integrating teamwork-oriented skills in a real software development environment based on Scrum. In this work, we present Virtual Scrum (VS), a virtual reality environment that assists students with the running of a software project following the Scrum framework. VS supports artifacts needed for carrying out Scrum meetings and media-based tools to achieve permanent communication among Scrum members. A survey of students, who used the tool in a Software Engineering (SE) course, showed that VS is helpful to exercise Scrum practices.

Adaptive 3D Virtual Learning Environments—A Review of the Literature

New ways of learning have emerged in the last years by using computers in education. For instance, many Virtual Learning Environments have been widely adopted by educators, obtaining promising outcomes. Recently, these environments have evolved into more advanced ones using 3D technologies and taking into account the individual learner needs and preferences. This focus has led a shift to more personalized learning approaches, requiring that the environments adapt themselves to the learner. Then, many adaptive 3D environments have explored adaptive features to create new and enhanced learning experiences in different contexts. However, very little is known about both what factors are involved with adaptive 3D environments to achieve learning benefits and what assessment factors are present in current studies. For this reason, this review analyzes the recent publications on Adaptive 3D Virtual Learning Environments. Findings have revealed that these environments have covered factors on defining the learners model, the instructional strategies and contents, and the adaptations mechanisms. Nearly half of the environments have addressed thorough assessments whereas the rest has not reported any evaluation at all. Moreover, when they report assessment, promising outcomes have also been shown not only in multiple domains of knowledge but also at various stages of education. These findings indicate that the field of Adaptive 3D Virtual Learning Environments is an active and ongoing area, and this study highlights several promising directions and suggestions for future research.

Unsupervised Learning for Detecting Refactoring Opportunities in Service-Oriented Applications

Service-Oriented Computing (SOC) has been widely used for building distributed and enterprise-wide software applications. One major problem in this kind of applications is their growth; as size and complexity of applications increase, the probability of duplicity of code increases, among other refactoring issues. This paper proposes an unsupervised learning approach to assist software developers in detecting refactoring opportunities in service-oriented applications. The approach gathers non-refactored Web Service Description Language (WSDL) documents and applies clustering and visualization techniques to deliver a list of refactoring suggestions to start working on the refactoring process. We evaluated our approach using two real-life case-studies by using internal validity criteria for the clustering quality.

AI-based Web Service Composition: A Review

ABSTRACT Web service composition allows developers to create applications by capitalizing on the service-oriented architecture paradigm. Such applications are rapidly deployable and offer developers reuse opportunities and access to an ample variety of complex systems. However, the challenge when composing services is addressing quality-of-service (QoS) issues. Thus, we attempt to shed light on the role of artificial intelligence (AI) in assisting developers to deal with QoS-based web service compositions. This paper characterizes contemporary approaches that use AI to explore alternative solutions. We concluded that AI has aimed at exploiting the semantic resources to produce flexible and adaptive-to-change web service compositions.