AMBIENT-PRISMA: Distribution and Mobility in Aspect-Oriented Software Architectures

This thesis presents a framework called Ambient-PRISMA for describing and developing distributed and mobile software systems in an abstract way. Ambient-PRISMA enriches an aspect-oriented software architecture approach called PRISMA with concepts of Ambient Calculus (AC). Ambient Calculus (AC) is a formalism that provides primitives to describe distribution and mobility characteristics in an abstract way. It introduces a concept called ambient which is a bounded place where computation happens. This enrichment is performed by extending the PRISMA metamodel, and Aspect-Oriented Architecture Description Language (AOADL). A case study of an electronic Auction System with mobile agents is used throughout the thesis in order to illustrate the work.Ali Irshaid, N. (2007). AMBIENT-PRISMA: Distribution and Mobility in Aspect-Oriented Software Architectures. http://hdl.handle.net/10251/12900Archivo delegad

Virtual Composition of EMF Models

National audienceModel composition is a very important modeling task as it allows to combine various perspectives of a system (represented by various models) into a single specialized view (a composed model). Several approaches have been proposed to tackle this problem, but they present some important limitations concerning efficiency, interoperability, and/or synchronization issues (mainly due to the element cloning mechanism used to create the composed model). In this paper we propose a new model composition method based on the virtualization of the composition mechanism. In our approach, the composed model is in fact created as a virtual model that redirects all its model access and manipulation requests directly to the set of base models from which it was generated. This is done transparently for the designer. Our mechanism improves the composition process with relation to the limitations mentioned above. The solution has been implemented and validated in a prototype tool on top of EMF.La composition de modèles est une tâche de modélisation très importante car elle permet de combiner différents points de vue d'un système (qui est représenté par divers modèles) en une seule vue spécialisée (un modèle composé). Plusieurs approches ont été proposées pour aborder ce problème, mais elles présentent d'importantes limitations concernant l'efficacité, l'interopérabilité, et/ou les problèmes de synchronisation (principalement en raison du mécanisme de clonage d'éléments utilisé pour la création du modèle composé). Dans cet article nous proposons une nouvelle méthode de composition des modèles basée sur la virtualisation du mécanisme de composition. Dans notre approche, le modèle composé est en fait créé comme un modèle virtuel qui redirige toutes ses demandes d'accès et de manipulation directement à l'ensemble des modèles de base à partir desquelles il a été généré. Cela se fait d'une manière transparente pour le concepteur. Notre mécanisme améliore le processus de composition par rapport aux limitations mentionnées ci-dessus. La solution a été implémentée et validée dans un prototype développé sur EMF (Eclipse Modeling Framework)

Enhancing Biomechanical Function through Development and Testing of Assistive Devices for Shoulder Impairment and Total Limb Amputation

Assistive devices serve as a potential for restoring sensorimotor function to impaired individuals. My research focuses on two assistive devices: a passive shoulder exoskeleton and a muscle-driven endoprosthesis (MDE). Previous passive shoulder exoskeletons have focused on testing during static loading conditions in the shoulder. However, activities of daily living are based on dynamic tasks. My research for passive shoulder exoskeletons analyzes the effect that a continuous passive assistance has on shoulder biomechanics. In my research I showed that passive assistance decreases the muscular activation in muscles responsible for positive shoulder exoskeleton. An MDE has the potential to have accurate and precise control of movement as well as restore a sense of proprioception to the user. Such a transformative and invasive device has never previously been tested. Therefore, my research focused on analyzing fundamental principles of the MDE in an in-vivo rabbit model. The two concepts I tested in my research were the feasibility of implanting an orthopedic device underneath the skin at the distal end of a limb following amputation and the locomotor restorative capabilities of an artificial tendon used for muscle-device connection. In my work I proved the feasibility of implanting fully-footed rigid endoprostheses underneath the skin and isolated the primary factors for a successful surgery and recovery. In addition, my research showed that although artificial tendons have the potential to restore locomotor function, proper in-situ tendon lengths must be achieved for optimal movement. This research informed the design and testing of a fully jointed muscle-driven endoprosthesis prototype

Traceability of Requirements and Software Architecture for Change Management

At the present day, software systems get more and more complex. The requirements of software systems change continuously and new requirements emerge frequently. New and/or modified requirements are integrated with the existing ones, and adaptations to the architecture and source code of the system are made. The process of integration of the new/modified requirements and adaptations to the software system is called change management. The size and complexity of software systems make change management costly and time consuming. To reduce the cost of changes, it is important to apply change management as early as possible in the software development cycle. Requirements traceability is considered crucial in change management for establishing and maintaining consistency between software development artifacts. It is the ability to link requirements back to stakeholders’ rationales and forward to corresponding design artifacts, code, and test cases. When changes for the requirements of the software system are proposed, the impact of these changes on other requirements, design elements and source code should be traced in order to determine parts of the software system to be changed. Determining the impact of changes on the parts of development artifacts is called change impact analysis. Change impact analysis is applicable to many development artifacts like requirements documents, detailed design, source code and test cases. Our focus is change impact analysis in requirements and software architecture. The need for change impact analysis is observed in both requirements and software architecture. When a change is introduced to a requirement, the requirements engineer needs to find out if any other requirement related to the changed requirement is impacted. After determining the impacted requirements, the software architect needs to identify the impacted architectural elements by tracing the changed requirements to software architecture. It is hard, expensive and error prone to manually trace impacted requirements and architectural elements from the changed requirements. There are tools and approaches that automate change impact analysis like IBM Rational RequisitePro and DOORS. In most of these tools, traces are just simple relations and their semantics is not considered. Due to the lack of semantics of traces in these tools, all requirements and architectural elements directly or indirectly traced from the changed requirement are candidate impacted. The requirements engineer has to inspect all these candidate impacted requirements and architectural elements to identify changes if there are any. In this thesis we address the following problems which arise in performing change impact analysis for requirements and software architecture. Explosion of impacts in requirements after a change in requirements. In practice, requirements documents are often textual artifacts with implicit structure. Most of the relations among requirements are not given explicitly. There is a lack of precise definition of relations among requirements in most tools and approaches. Due to the lack of semantics of requirements relations, change impact analysis may produce high number of false positive and false negative impacted requirements. A requirements engineer may have to analyze all requirements in the requirements document for a single change. This may result in neglecting the actual impact of a change. Manual, expensive and error prone trace establishment. Considerable research has been devoted to relating requirements and design artifacts with source code. Less attention has been paid to relating Requirements (R) with Architecture (A) by using well-defined semantics of traces. Designing architecture based on requirements is a problem solving process that relies on human experience and creativity, and is mainly manual. The software architect may need to manually assign traces between R&A. Manual trace assignment is time-consuming, expensive and error prone. The assigned traces might be incomplete and invalid. Explosion of impacts in software architecture after a change in requirements. Due to the lack of semantics of traces between R&A, change impact analysis may produce high number of false positive and false negative impacted architectural elements. A software architect may have to analyze all architectural elements in the architecture for a single requirements change. In this thesis we propose an approach that reduces the explosion of impacts in R&A. The approach employs semantic information of traces and is supported by tools. We consider that every relation between software development artifacts or between elements in these artifacts can play the role of a trace for a certain traceability purpose like change impact analysis. We choose Model Driven Engineering (MDE) as a solution platform for our approach. MDE provides a uniform treatment of software artifacts (e.g. requirements documents, software design and test documents) as models. It also enables using different formalisms to reason about development artifacts described as models. To give an explicit structure to requirements documents and treat requirements, architecture and traces in a uniform way, we use metamodels and models with formally defined semantics. The thesis provides the following contributions: A modeling language for definition of requirements models with formal semantics. The language is defined according to the MDE principles by defining a metamodel. It is based on a survey about the most commonly found requirements types and relation types. With this language, the requirements engineer can explicitly specify the requirements and the relations among them. The semantics of these entities is given in First Order Logic (FOL) and allows two activities. First, new relations among requirements can be inferred from the initial set of relations. Second, requirements models can be automatically checked for consistency of the relations. Tool for Requirements Inferencing and Consistency Checking (TRIC) is developed to support both activities. The defined semantics is used in a technique for change impact analysis in requirements models. A change impact analysis technique for requirements using semantics of requirements relations and requirements change types. The technique aims at solving the problem of explosion of impacts in requirements when semantics of requirements relations is missing. The technique uses formal semantics of requirements relations and requirements change types. A classification of requirements changes based on the structure of a textual requirement is given and formalized. The semantics of requirements change types is based on FOL. We support three activities for impact analysis. First, the requirements engineer proposes changes according to the change classification before implementing the actual changes. Second, the requirements engineer indentifies the propagation of the changes to related requirements. The change alternatives in the propagation are determined based on the semantics of change types and requirements relations. Third, possible contradicting changes are identified. We extend TRIC with a support for these activities. The tool automatically determines the change propagation paths, checks the consistency of the changes, and suggests alternatives for implementing the change. A technique that provides trace establishment between R&A by using architecture verification and semantics of traces. It is hard, expensive and error prone to manually establish traces between R&A. We present an approach that provides trace establishment by using architecture verification together with semantics of requirements relations and traces. We use a trace metamodel with commonly used trace types. The semantics of traces is formalized in FOL. Software architectures are expressed in the Architecture Analysis and Design Language (AADL). AADL is provided with a formal semantics expressed in Maude. The Maude tool set allows simulation and verification of architectures. The first way to establish traces is to use architecture verification techniques. A given requirement is reformulated as a property in terms of the architecture. The architecture is executed and a state space is produced. This execution simulates the behavior of the system on the architectural level. The property derived from the requirement is checked by the Maude model checker. Traces are generated between the requirement and the architectural components used in the verification of the property. The second way to establish traces is to use the requirements relations together with the semantics of traces. Requirements relations are reflected in the connections among the traced architectural elements based on the semantics of traces. Therefore, new traces are inferred from existing traces by using requirements relations. We use semantics of requirements relations and traces to both generate/validate traces and generate/validate requirements relations. There is a tool support for our approach. The tool provides the following: (1) generation/validation of traces by using requirements relations and/or verification of architecture, (2) generation/validation of requirements relations by using traces. A change impact analysis technique for software architecture using architecture verification and semantics of traces between R&A. The software architect needs to identify the impacted architectural elements after requirements change. We present a change impact analysis technique for software architecture using architecture verification and semantics of traces. The technique is semi-automatic and requires participation of the software architect. Our technique has two parts. The first part is to identify the architectural elements that implement the system properties to which proposed requirements changes are introduced. By having the formal semantics of requirements relations and traces, we identify which parts of software architecture are impacted by a proposed change in requirements. We have extended TRIC for determining candidate impacted architectural elements. The second part of our technique is to propose possible changes for software architecture when the software architecture does not satisfy the new and/or changed requirements. The technique is based on architecture verification. The output of verification is a counter example if the requirements are not satisfied. The counter example is used with a classification of architectural changes in order to propose changes in the software architecture. These changes produce a new version of the architecture that possibly satisfies the new or the changed requirements

Model-Driven Development of Aspect-Oriented Software Architectures

[EN] The Model-Driven Development (MDD) paradigm has become widely spread in the last few years due to being based on models instead of source code, and using automatic generation techniques to obtain the final software product. Until now, the most mature methodologies that have been proposed to develop software following MDD are mainly based on functional requirements by following the Object-Oriented Paradigm. Therefore, mature MDD methodologies are required for supporting the code generation from models that specify non-functional requirements. The Aspect-Oriented Software Development (AOSD) approach was created to provide explicit mechanisms for developing non-functional requirements through reusable elements called aspects. Aspect-Oriented Software Architectures (AOSA) emerged to deal with the design of both, functional requirements and non-functional requirements, which opened an important challenge in the software engineering field: the definition of a methodology for supporting the development of AOSAs following the MDD paradigm. This new methodology should allow the code generation from models which specify functional and non-functional requirements. This paper presents a mature approach, called PRISMA, which deals with this challenge. Therefore, this contribution takes a step forward in the area presenting in detail the PRISMA MDD process, which has been applied to generate the code of several real applications of the tele-operated robotics domain. PRISMA MDD approach provides complete support for the development of technology-independent AOSAs, which can be compiled from high-level, aspect-oriented architectural models into different technology platforms and languages following an MDD process. This contribution illustrates how to apply the PRISMA MDD approach through the modelling framework that has been developed to support it, and a case study of a tele-operated robot that has been completely developed using this approach. Finally, the results obtained from the application of PRISMA MDD process to develop applications of the tele-operation domain are analyzed in terms of code generation.The work reported here has been partially sponsored by the Spanish MEC projects (DSDM TIN2008-00889-E and MULTIPLE TIN2009-13838), and MICINN (INNOSEP TIN2009-13849)Pérez Benedí, J.; Ramos Salavert, I.; Carsí Cubel, JÁ.; Costa Soria, C. (2013). Model-Driven Development of Aspect-Oriented Software Architectures. Journal of Universal Computer Science. 19(10):1433-1473. https://doi.org/10.3217/jucs-019-10-143314331473191

Model-Driven Development of Aspect-Oriented Software Architectures

The work presented in this thesis of master is an approach that takes advantage of the Model-Driven Development approach for developing aspect-oriented software architectures. A complete MDD support for the PRISMA approach is defined by providing code generation, verification and reusability properties.Pérez Benedí, J. (2007). Model-Driven Development of Aspect-Oriented Software Architectures. http://hdl.handle.net/10251/12451Archivo delegad

Eugenia:towards disciplined and automated development of GMF-based graphical model editors

EMF and GMF are powerful frameworks for implementing tool support for modelling languages in Eclipse. However, with power comes complexity, implementing a graphical editor for a modelling language using EMF and GMF requires developers to handcraft and maintain several detailed interconnected models through a loosely guided, labour-intensive, and error-prone process. We demonstrate how the application of metamodel annotation and model transformation techniques can help to manage the complexity of GMF and EMF and deliver significant productivity, quality, and maintainability benefits. We present Eugenia, an open-source tool that implements the proposed approach, illustrate its functionality with an example, evaluate it through an empirical study, and report on the community’s response to the tool

Analysis as first-class citizens – an application to Architecture Description Languages

Architecture Description Languages (ADLs) support modeling and analysis of systems through models transformation and exploration. Various contributions made proposals to bring verification capabilities to designers through model-based frame- works and illustrated benefits to the overall system quality. Model-level analyses are usually performed as an exogenous, unidirectional and semantically weak transformation towards a third-party model. We claim such process can be incomplete and/or inefficient because gathered results lead to evolution of the primary model. This is particularly problematic for the design of Distributed Real-Time Embedded (DRE) systems that has to tackle many concerns like time, security or safety. In this paper, we argue why analysis should no longer be considered as a side step in the design process but, rather, should be embedded as a first-class citizen in the model itself. We review several standardized architecture description languages, which consider analysis as a goal. As an element of solution, we introduce current work on the definition of a language dedicated to the analysis of models within the scope of one particular ADL, namely the Architecture Analysis and Design Language (AADL)