Rubén Fuentes-Fernández

Learning teamwork skills in university programming courses

University courses about computer programming usually seek to provide students not only with technical knowledge, but also with the skills required to work in real-life software projects. Nowadays, the development of software applications requires the coordinated efforts of the members of one or more teams. Therefore, it is important for software professionals to master the sort of skills that assure the success of teamwork, such as communication, leadership, negotiation, or team management. However, these abilities are difficult to teach, one of the reasons being that they require true commitment from the students. However, today students are taking a more and more passive role in their own education, two of the more evident consequences being the increase in dropout rates and the decrease in marks obtained in exams. The NUCLEO e-learning framework has been designed to promote the effective acquisition of teamwork skills and, at the same time, to promote the more active participation of the students in their own learning process. NUCLEO adopts a socio-constructivist pedagogical approach that pursues the development of communities of practice for Problem Based Learning. Our research has rooted the design decisions of NUCLEO in the analysis of its socio-cultural environment with Activity Theory, which considers conflicts within groups as the impetus of their evolution and the forges of their environments. This paper presents the analysis of the main features of NUCLEO according to Activity Theory, as well as the experimental results obtained with the framework in three different case studies in university courses.

Understanding the human context in requirements elicitation

The human context within which a software system will operate is fundamental for its requirements. It may not appear to be very much related to the system, but it is very relevant in achieving its successful adoption. However, requirements engineers have usually a background in Software Engineering and are not trained to elicit this kind of information. This situation raises the need for analytical tools to deal with these features. These tools should enable collaborative work between requirements engineers, who use them in development, social practitioners, who provide the knowledge and processes underlying these tools, and the customers, who know the domain and intended application of the projects. The framework presented in this paper is based on the socio-psychological Activity Theory and its analysis of human contexts. It includes a repository of social properties and a process to perform this elicitation using it. The paper illustrates its application through a case study on the impact of a new system in the organization of a firm.

A Multi-Agent System Architecture for Sensor Networks

The design of the control systems for sensor networks presents important challenges. Besides the traditional problems about how to process the sensor data to obtain the target information, engineers need to consider additional aspects such as the heterogeneity and high number of sensors, and the flexibility of these networks regarding topologies and the sensors in them. Although there are partial approaches for resolving these issues, their integration relies on ad hoc solutions requiring important development efforts. In order to provide an effective approach for this integration, this paper proposes an architecture based on the multi-agent system paradigm with a clear separation of concerns. The architecture considers sensors as devices used by an upper layer of manager agents. These agents are able to communicate and negotiate services to achieve the required functionality. Activities are organized according to roles related with the different aspects to integrate, mainly sensor management, data processing, communication and adaptation to changes in the available devices and their capabilities. This organization largely isolates and decouples the data management from the changing network, while encouraging reuse of solutions. The use of the architecture is facilitated by a specific modelling language developed through metamodelling. A case study concerning a generic distributed system for fire fighting illustrates the approach and the comparison with related work.

Advances in Artificial Intelligence – IBERAMIA 2012

The notion of Contradiction is present in many aspects of the world and human information processing. As a consequence, more and more computer systems have been pushed into dealing with the contradiction detection task. Contradiction Detection (CD) is not a simple task, thus, it is subject to many discussions and approaches in different areas of human knowledge, such as Philosophy, Ethics, Linguistics, Computer Science, etc. and, as such, approached under different perspectives and goals. In this paper we focus on CD in a never-ending learning system called NELL (Never-ending Language Learner). Considering that NELL is intended to be self-supervised, as well as, self-reflective, it takes advantage of every new acquired knowledge (and stored its Knowledge Base KB) to learn better and better each day. In this sense, NELL uses its own knowledge to achieve better performance in every new learning task. Therefore, the presence of contradictions in the KB of a never-ending learning system, like NELL, can result in the exponential propagation of incorrect knowledge that can lead to concept-drift. Following along these lines, in this work we proposed an approach to detect and eliminate contradictions from NELL’s KB. The results obtained from the performed experiments shows that the proposed approach can detect contradictions, as well as, eliminating them by deletion or by extending the KB hierarchy structure.

Model Transformation By-Example: An Algorithm for Generating Many-to-Many Transformation Rules in Several Model Transformation Languages

Practitioners of model-driven engineering usually find that producing model transformations still requires much effort. The Model Transformation By-Example (MTBE) approach softens this problem by means of the automated creation of model transformations from pairs of source and target model examples. However, the current techniques and tools for MTBE are limited in the sense that they can only produce transformations rules that are limited to just one element in some of the patterns. In addition, some transformation languages cannot directly represent many-to-many transformation rules. To overcome both limitations, this paper presents a MTBE algorithm, that can generate many-to-many rules in several transformation languages even if the transformation language cannot directly represent these kinds of rules. In particular, the implementation of this algorithm with the ATL language is available for practitioners, and it has already generated several MTs that are applied in software development. Finally, the paper compares this algorithm with existing techniques for MTBE.

A technique for defining agent-oriented engineering processes with tool support

The formalization of engineering processes is necessary for guaranteeing the quality and cost of the products involved. Agent-oriented engineering has already proposed development processes that still need to be further formalized to be applicable by non-researchers. This paper proposes a technique to instantiate processes for specific agent-oriented methodologies. This technique is based on three orthogonal views that are respectively related with lifecycles, disciplines and guidances. In addition, processes are modeled with a tool, which is automatically generated from a process metamodel inspired by the software & systems process engineering metamodel. Accordingly, engineers can choose the methodology-process pair best-suited for the characteristics of their project. The paper illustrates the approach based on the unified development process and the scrum process for the INGENIAS methodology and compares the results with other existing alternatives.

Model integration in agent-oriented development

Each current agent-oriented methodology focuses on some aspects of multi-agent systems and may leave others aside. For this reason, a developer may find it useful to apply different specialised methods and tools for each aspect of the system under development. Nevertheless, the integration of different elements into a specification is not trivial. This paper proposes addressing this issue by using mappings between different modelling languages and an intermediate language. The use of this intermediate language called Unified Modelling Language for Activity Theory (UML-AT), reduces the number of required mappings. Being rooted in the Activity Theory (AT) framework, which comes from social sciences, UML-AT supports most of the key agent-related concepts found in literature. The application of this integration approach is illustrated with a case study about the implementation of Foundation for Intelligent Physical Agents (FIPA) protocols. The case study involves the use of a software support tool for the translation.

A Tool for Generating Model Transformations By-Example in Multi-Agent Systems

Many Multi-Agent Systems (MAS) methodologies incorporate a model-driven approach. Model Driven Engineering is based on three main ideas: models are the “first-class citizens”, meta-models define modelling languages that are used to specify models and models are transformed during the development. However, model transformation is still a challenging issue in MAS. At first, MAS designers are not necessarily familiar with existing model transformation languages or tools. Secondly, existing tools for creating model transformations do not satisfy the necessities of agent-oriented software engineering, since they focused on coding with little support for developers. This paper proposes a tool for the creation of model transformations that is based on the generation of model transformations by-example. This tool overcomes the limitations of other similar tools in the sense that it can generate many-to-many transformation rules. The tool application is exemplified with two MAS methodologies, INGENIAS and ADELFE.

Analysis of Intelligent Transportation Systems Using Model-Driven Simulations.

Intelligent Transportation Systems (ITSs) integrate information, sensor, control, and communication technologies to provide transport related services. Their users range from everyday commuters to policy makers and urban planners. Given the complexity of these systems and their environment, their study in real settings is frequently unfeasible. Simulations help to address this problem, but present their own issues: there can be unintended mistakes in the transition from models to code; their platforms frequently bias modeling; and it is difficult to compare works that use different models and tools. In order to overcome these problems, this paper proposes a framework for a model-driven development of these simulations. It is based on a specific modeling language that supports the integrated specification of the multiple facets of an ITS: people, their vehicles, and the external environment; and a network of sensors and actuators conveniently arranged and distributed that operates over them. The framework works with a model editor to generate specifications compliant with that language, and a code generator to produce code from them using platform specifications. There are also guidelines to help researchers in the application of this infrastructure. A case study on advanced management of traffic lights with cameras illustrates its use.

A framework for the definition of metamodels for Computer-Aided Software Engineering tools

Computer-Aided Software Engineering (CASE) tools support modeling-related activities in development projects. Given the variety of tools and functionalities, it is quite common to work with several tools in the same project. However, data cannot usually be exchanged between these tools without loss of information. Recent approaches address this model interchange problem using metamodels to characterize the involved information and transformations to export/import it. Nevertheless, most of these solutions focus on the abstract syntax of models. They fail to consider aspects such as the presentation of models or tool-specific information, which are either disregarded or represented in ad-hoc ways that make difficult their processing. In order to overcome these limitations, this paper introduces a framework to define metamodels of CASE tools and a process to carry out the model interchange using them. The proposed metamodels have a modular organization with several internal metamodels. Each of them is aimed at describing some specific information about content, structure and presentation for both models and tools. The paper illustrates this approach with a case study used for comparison with existing works for this problem.