Patricio Letelier

PRISMA: towards quality, aspect oriented and dynamic software architectures

The development of software systems must be done using platforms that allow the description of quality, complex, distributed, dynamic and reusable architectural models. We present in this paper PRISMA, an architectural modelling approach based on aspects and components that uses a component definition language (components, connectors and systems) to define architectural types at a high abstraction level and a configuration language to design the architecture of software systems. The component definition language increases reuse allowing importation of COTS and reduces complexity by integrating two modern software development approaches: component-based software development and aspect-oriented software development. The configuration language designs the architecture of software systems by creating and interconnecting instances of the defined types including possible imported COTS. PRISMA has a metalevel with reflexive properties for these two languages. For this reason, the types of PRISMA may evolve and the topologies of PRISMA may be reconfigured dynamically.

Formal Model Merging Applied to Class Diagram Integration

The integration of software artifacts is present in many scenarios of the Software Engineering field: object-oriented modeling, relational databases, XML schemas, ontologies, aspect-oriented programming, etc. In Model Management, software artifacts are viewed as models that can be manipulated by means of generic operators, which are specified independently of the context in which they are used. One of these operators is Merge, which enables the automated integration of models. Solutions for merging models that are achieved by applying this operator are more abstract and reusable than the ad-hoc solutions that are pervasive in many contexts of the Software Engineering field. In this paper, we present our automated approach for generic model merging from a practical standpoint, providing support for conflict resolution and traceability between software artifacts by using the QVT Relations language. We focus on the definition of our operator Merge, applying it to Class Diagrams integration.

Analysis of the influence of communication between researchers on experiment replication

The replication of experiments is a key undertaking in SE. Successful replications enable a disciplines body of knowledge to grow, as the results are added to those of earlier replications. However, replication is extremely difficult in SE, primarily because it is difficult to get a setting that is exactly the same as in the original experiment. Consequently, changes have to be made to the experiment to adapt it to the new site. To be able to replicate an experiment, information also has to be transmitted (usually orally and in writing) between the researchers who ran the experiment earlier and the ones who are going to replicate the experiment. This article examines the influence of the type of communication there is between experimenters on how successful a replication is. We have studied three replications of the same experiment in which different types of communication were used.

A Metamodeling Approach for Requirements Specification

There are many Requirements Engineering approaches and techniques that help to specify, analyze and validate requirements. However, they are neither widely accepted nor widely used by the industrial software community. One of the main problems faced when applying them is to what extent they can be easily adapted to the specific needs of the project. This has often led to unsatisfactory requirements management in industrial software development. In this work, a proposal for requirements modeling is presented that allows the integration of the expressiveness of some of the more relevant Requirements Engineering techniques by taking advantage of metamodeling. This proposal focuses on scalability with respect to expressiveness and adaptability to the application domain to establish some basic guidelines and extension mechanisms that lend coherence and semantic precision. A case study and 4 tool support are presented to describe the application of this proposal in a real-life project.

A modelling proposal for aspect-oriented software architectures

Aspect-oriented programming (AOP) has emerged in recent years as a new paradigm for software development. PRISMA is an approach for developing complex and large software systems. It combines the aspect-oriented software development (AOSD) and the component-based software development (CBSD) in an elegant and novel way achieving a better management of crosscutting-concerns and software reusability. PRISMA approach proposes the separation of concerns from the very beginning of the software life-cycle in order to introduce them as reusable aspects of software architecture. PRISMA provides a framework to guide the development of complex and large software systems. The framework is composed by a modelling tool, a .NET middleware, and a compiler to automatically generate the application source code. In this paper, we present the modeling tool of the PRISMA framework and how it supports the reuse and maintenance improvements of the PRISMA model and its aspect- oriented description language (AOSD). We illustrate our proposal and modelling tool using a real-life case, the TeachMover robot

Requirements and Scenarios: Running Aspect-Oriented Software Architectures

The intertwining of Requirements and Software Architectures must be based on solid traceability mechanisms in order to effectively maintain the consistency between the two specifications. A new issue has come to the fore in this area: Aspect-Oriented Software Development (AOSD). Achieving the separation of concerns from the very beginning of software development along with their proper traceability throughout the lifecycle is mandatory in terms of quality and maintainability. ATRIUM is a methodology that is defined to guide the development of architectures from requirements and using AOSD techniques as its cornerstone. In this work, we present how ATRIUM uses a scenario technique that provides traceability support. ATRIUM pays special attention to non-functional requirements, their crosscutting relationships, and how they can derive aspects in the software architecture.

Prototyping a Requirements Specification through an Automatically Generated Concurrent Logic Program

OASIS is a formal approach for the specification of object oriented conceptual models. In OASIS conceptual schemas of information systems are represented as societies of interacting concurrent objects. Animating such models in order to validate the specification of information systems is a topic of interest in requirements engineering. Thus a basic execution model for OASIS specifications has been developed. Concurrent Logic Programming is a suitable paradigm for distributed computation allowing a natural representation of concurrence. Using Concurrent Logic Programming, OASIS specifications are animated according to OASIS execution model. In this work, we show how OASIS concepts are directly mapped into concurrent logic programming concepts. To illustrate our ideas, an example of a bank account codified in KL1 is given and parts of the program that animates its corresponding OASIS specification are shown. This work has been developed in the context of a CASE tool supporting the OASIS approach. Our aim is to build a module for animation and validation of specifications. A preliminary version of this module is presented.

Communication and Creative Thinking in Agile Software Development

This paper describes and analyses how a eXtreme Programming (XP) team work can use some ideas from Psychology and Computer Science fostering creativity and innovation in Software Development. The roles for creative team in order to have a chance for creative thinking, communication, innovation, collaboration and knowledge sharing are addressed to Agile Software Development teams.

A goal-oriented approach for safety requirements specification

Robotic systems are developed to execute tasks with several types of risks associated. The possible damages that can affect both the working environment and the self-system lead us to consider that these systems are safety critical, i.e., systems where the strict management of safety aspects is vital. In this work, we introduce our proposal for the consideration of safety related requirements and their consequent trace to the desired final system architecture. For this reason, this paper gives a procedure for the identification and specification of safety requirements based on a goal oriented framework. Moreover, in this work other approaches have been considered and integrated to deal with well known safety standard recommendations. By means of an industrial case study, we show how this proposal can be used to consider safety requirements in tele-operated robotic systems and, by extrapolation, in other critical domains

Supporting the automatic generation of proto-architectures

Many issues must be taken into account in order to provide a right specification of the system-to-be to meet properly the established requirements. In this sense, the introduction of proper supporting techniques able to automate as much as possible the process means a clear advantage. In this work, we introduce a tool called MORPHEUS that gives support to our proposal by providing traceability throughout the process of generation of proto-architecture from requirements.