Catálogo de publicaciones - libros

A persistent computing system is a reactive system that functions continuously anytime without stopping its reactions even when it needs to be maintained, upgraded, or reconfigured, it has some trouble, or it is attacked. However, the requirement that a computing system should run continuously and persistently is never taken into account as an essential and/or general requirement by traditional system design and development methodologies. As a result, there is no clearly defined standard to be used for measuring the reactability of a computing system. This paper proposes the first method to measure the reactability of a persistent computing system in a unified way. The paper introduces the notion of reactive processing path among components and shows that the reactive processing paths can be used to measure the reactability of a persistent computing system.

In current composition languages for web services, there is insufficient support to explicitly separate crosscutting concerns, which leads to compositions that are hard to maintain or evolve. A similar problem in object-oriented languages is being tackled by aspect-oriented programming, and some work has been started to apply these techniques to web service composition languages as well. We identified some problems with these approaches. This short paper lists these limitations and offers a number of requirements to apply aspect-oriented techniques to workflow languages.

In component based software engineering, an application is build by composing trusted and reusable units of execution, the components. A composition is formed by connecting the components’ related interfaces. The point of connection, namely the connector, is an abstract representation of their interaction. Most component models’ implementations rely on extensive middleware, which handles component interaction and hides matters of heterogeneity and distribution from the application components. In resource constrained embedded systems this middleware and its resource demands are a key factor for the acceptance and usability of component based software. By addressing connectors as first class architectural entities at model level, all application logic related to interaction can be located within them. Therefore, the set of all explicit connectors of a component architecture denotes the exact requirements of that application’s communication and interaction needs. We contribute by demonstrating how to use explicit connectors in model driven development to synthesize a custom tailored, component based communication middleware. This synthesis is achieved by model transformations and optimizations using prefabricated basic building blocks for communication primitives.

Software development for embedded systems gains momentum but faces many challenges. Especially the constraints of deeply embedded systems, i.e., extreme resource and performance constraints, seem to prohibit the successful application of modern and approved programming and modularization techniques. In this paper we indicate that this objection is not necessarily justified. We propose to use refinement chain optimization to tailor and streamline feature-oriented designs to satisfy the resource constraints of (deeply) embedded systems. By means of a quantitative analysis of a case study we show that our proposal leads to a performance and footprint improvement significant for (deeply) embedded systems.

The aspect-oriented paradigm aims to modularize concerns that crosscut traditional abstraction boundaries. In the AOSD community, there is an increasing interest in the development of reusable implementations of typical crosscutting concerns, such as security, synchronization, profiling, etc. To employ a reusable aspect in a concrete application, deployment logic has to be written that specifies where and how to apply the new behavior, and how the interaction with the base application and the other aspects in the system is organized. We have analyzed the means for the specification of such deployment logic in current aspect-oriented technologies and have identified a number of issues regarding its reuse, its dynamic invocation and its integration with the rest of the system. With the knowledge gained, we propose important first steps towards better support for the specification of deployment logic.

Aspects require access to the join point context in order to select and adapt join points. For this purpose, current aspect-oriented systems offer a large number of pointcut constructs that provide access to join point information that is to the join point context, like parameters in method call join points. However, these systems are quite miserly with information that cannot directly be derived from the local execution context. Recently, there have been some proposals that offer access to some kind of non-local information. One such proposal is the that permits to abstract over . Path pointcuts expose non-local objects that are specified in corresponding path expression patterns. In this paper, we show recurrent situations where developers need to access the whole , and consequently, they add workarounds other than pointcut constructs to get the required accesses. Then, we present and study an extension to the path expression pointcuts to permit exposing the object paths and show how this extension overcomes the problem.

The ability to debug programs composed using aspect-oriented programming (AOP) techniques is critical to the adoption of AOP. Nevertheless, many AOP systems lack adequate support for debugging, making it difficult to diagnose faults and understand the program’s composition and control flow. We present an that characterizes AOP-specific program composition techniques and AOP-specific program behaviors, and relates them to the AOP-specific faults they induce. We specify debugging criteria that we feel all AOP systems should support and compare how several AOP systems measure up to this ideal.

We explain why AOP composition techniques, particularly dynamic and binary weaving, hinder source-level debugging, and how results from related research on debugging optimized code help solve the problem. We also present Wicca, the first dynamic AOP system to support full source-level debugging. We demonstrate how Wicca’s powerful interactive debugging features allow a programmer to quickly diagnose faults in the base program behavior or AOP-specific behavior.

This paper discusses how evolution in software systems can be supported by a unified application of both static as well as dynamic aspect-oriented technology. The support for evolution is required statically, where the applications could be taken offline and adapted, and dynamically where going offline is not an available option. While this is straightforward in the static case by taking the system offline and statically weaving the aspects, runtime evolution requires an additional dynamic aspect weaving infrastructure.

Our current implementation of the supports most of the features known from the static aspect weaving domain, offers a tailored dynamic aspect weaving support, and is able to target a wide range of applications including embedded systems with very small memory footprint. The availability of a both for static and dynamic aspects means that the decision whether an aspect is static or dynamic is postponed to the later stages of the deployment of aspects into the sytem, and is decided according to the requirements and available resources. As a case study, we will present our experiences with the static and runtime evolution of the embedded operating system eCos.

Contemporary software systems are composed of many components, which, in general, undergo phased and incremental development. In order to facilitate the corresponding construction process, it is important that the development team in charge has a good understanding of how individual software components typically evolve. Furthermore, software engineers need to be able to recognize abnormal patterns of growth with respect to size, structure, and complexity of the components and the resulting composite. Only if a development team understands the processes that underpin the evolution of software systems, will they be able to make better development choices. In this paper, we analyze recurring structural and evolutionary patterns that we have observed in public-domain software systems built using object-oriented programming languages. Based on our analysis, we discuss common growth patterns found in present-day component-based software systems and illustrate simple means to aid developers in achieving a better understanding of those patterns. As a consequence, we hope to raise the awareness level in the community on how component-based software systems tend to naturally evolve.

Pattern composition has been recognized as a key element for the adoption of pattern languages and systems. This paper discusses the challenges of structural pattern composition and proposes an approach for role-based pattern composition, with two alternative composition mechanisms. To demonstrate the applicability of the proposed composition model, we have extended an existing pattern-driven architecting environment with an implementation of the approach.