230 research outputs found
RAMSES: a Reflective Middleware for Software Evolution
No full textAbstract. Software systems today need to dynamically self-adapt against dynamic requirement changes. In this paper we describe RAMSES a reflective middleware whose aim consists of consistently evolving software systems against runtime changes. This middleware provides the ability to change both structure and behavior for the base-level system at run-time by using its design information. The meta-level is composed of cooperating objects, and has been specified by using a design pattern language. The base objects are controlled by meta-objects that drive their evolution. The essence of RAMSES is the ability of extracting the design data from the base application, and of constraining the dynamic evolution to stable and consistent systems
Deriving Liveness Goals from Temporal Logic Specifications
No full textIntroduction The use of temporal logic has been widely explored both on the fields of specification and certification of properties of reactive systems (Pnueli, 1977), (Sernadas, 1980), (Fiadeiro and Maibaum, 1992), (Clarke, Grumberg and Kurshan, 1992), (Manna and Pnueli, 1992), (Manna and Pnueli, 1993), (Sernadas, Sernadas and Costa, 1995), (Sernadas, Sernadas and Ramos, 1996) and in monitoring (Hulsmann and Saake, 1991), (Kung, 1984), (Lipeck and Saake, 1987), (Schwiderski, Hartmann and Saake, 1994). The advantages are known to lie on the clear declarative formalization of the system at hand and on the use of temporal verification techniques to prove properties of the specified systems. Temporal logic specification has also given an important contribution towards the establishment of suitable compositional specification frameworks (Barringer, Kuiper and Pnueli, 1984). -- This work was partly supported by CEC under ESPRIT-III BRA WG 6071 IS-CORE (Information
Transactions on Aspect-Oriented Software Development IV
No full textSoftware evolution and adaptation is a research area, as also the name states, in continuous evolution, that offers stimulating challenges for both academic and industrial researchers. The evolution of software systems, to face unexpected situations or just for improving their features, relies on software engineering techniques and methodologies, that often imply re-designing, refactoring and re-coding part of or the whole system. Nowadays, similar approaches are not applicable in all situations (e.g., for evolving non-stopping systems or systems whose code is not available) and different approaches are necessary
PW01-90 - Influence Of Apolipoprotein E Genotype On Cognitive Function In Patients With Mild Alzheimer Dementia
No full textScheme Derivation for WWW Information Sources and their Integration with Databases in Bioinformatics
No full textHofestädt R, Höding M, Saake G, Scholz U. Scheme Derivation for WWW Information Sources and their Integration with Databases in Bioinformatics. In: Litwin W, Morzy T, Vossen G, eds. Advances in databases and information systems. Second East European Symposium ; Proceedings. Lecture Notes in Computer Science. Vol 1475. Berlin: Springer Publishing; 1998: 296-304
Viewpoint for Maintaining UML Models against Application Changes
No full textThe urgency that characterizes many requests for evolution forces the system administrators/developers of directly adapting the system without passing through the adaptation of its design. This creates a gap between the design information and the system it describes. The existing design models provide a static and often outdated snapshot of the system unrespectful of the system changes. Software developers spend a lot of time on evolving the system and then on updating the design information according to the evolution of the system. To this respect, we present an approach to automatically keep the design information (UML diagrams in our case) updated when the system evolves. The UML diagrams are bound to the application and all the changes to it are reflected to the diagrams as well
Proceedings of the 1st ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'04)
No full textSoftware Evolution: a Trip through Reflective, Aspect, and Meta-Data Oriented Techniques
No full textPrevious workshops related to aspect oriented software development, reflection organized at previous ECOOP conferences (e.g., RMA'001. and AOM-MeT'012.) and conferences on the same topics (Reflection'01 and AOSD since 2002) have pointed out the growing interest on these topics and their relevance in the software evolution as techniques for code instrumentation. Very similar conclusions can be drawn by reading the contributions to the workshops on unanticipated software evolution (USE 2002 and USE 20033.). Following the example provided by these venues, the RAM-SE (Reflection, AOP and Meta-Data for Software Evolution) workshop has provided an opportunity for researchers with a broad range of interests in reflective techniques and aspect-oriented software development to discuss recent developments of such a techniques in application to the software evolution. The workshop main goal was to encourage people to present works in progress. These works could cover all the spectrum from theory to practice. To ensure creativity, originality, and audience interests, participants have been selected by the workshop organizers on the basis of 5-page position paper. We hope that the workshop will help them to mature their ideas and to improve the quality of their future publications based on the presented work. The workshop proceedings are available as research report C-186 of the Department of Mathematical and Computing Sciences of the Tokyo Institute of Technology and freely downlodable from the workshop web site4
Co-Evolving Application Code and Design Models by Exploiting Meta-Data
No full textEvolvability and adaptability are intrinsic properties of today's software applications. Unfortunately, the urgency of evolving/adapting a system often drives the developer to directly modify the application code neglecting to update its design models. Even, most of the development environments support the code refactoring without supporting the refactoring of the design information.
Refactoring, evolution and in general every change to the code should be reflected into the design models, so that these models consistently represent the application and can be used as documentation in the successive maintenance steps. The code evolution should not evolve only the application code but also its design models. Unfortunately, to co-evolve the application code and its design is a hard job to be carried out automatically, since there is an evident and notorious gap between these two representations.
We propose a new approach to code evolution (in particular to code refactoring) that supports the automatic co-evolution of the design models. The approach relies on a set of predefined metadata that the developer should use to annotate the application code and to highlight the refactoring performed on the code. Then, these meta-data are retrieved through reflection and used to automatically and coherently update the application design models
- …
