Catálogo de publicaciones - libros

Component-Based Development (CBD) and Domain Engineering (DE) are important approaches for software reuse. In a DE process, components are specified in a high abstraction level, within a component architecture specification. When components are reused during an Application Engineering (AE), they are composed with each other and third-party components. However, conflicts usually occur and they must be considered as early as possible, otherwise they may jeopardize the defined architecture. This work proposes a set of functionalities for development with components, with focus on the support for the adaptation and composition functionalities. These were included in Odyssey , an environment that supports DE and AE processes. A preliminary study on the use of these functionalities is also reported.

A credit card authorization system (CAS) is a large information system performing diverse activities such as purchase authentication, balance transfer, cash advances, etc. One characteristic of CAS is its frequent update to satisfy the needs of customers and newly enforced governmental laws. Thus, CAS should be designed to minimize the effects of updates, for which high reusability of the CAS components is desired. In this paper, we present our experience of re-engineering CAS based on a feature model for improved reusability of components, which alleviates the difficulty of system maintenance. The result of this project has been successfully transferred to the company.

Software is constantly changing and these changes may occur at anytime in the software lifecycle. In order to avoid rework and information loss, among other problems, these changes must be controlled in a proper way. When changes affect reused components, possibly composed by other components, it is important to know who is responsible for implementing them. Some consequences of this problem, named Reuse Chain of Responsibility, is the misconception on rights and duties of teams that produce and reuse compo-nents. Aiming to solve this problem, we introduce Odyssey-CCS, a flexible change control system that allows the customization of a change control process to the specific needs of software reuse. Moreover, it keeps a reuse map that holds information about contracts between components producers and reusers. The reuse map is integrated to an existing component library and is queried by Odyssey-CCS within the impact analysis activity.

This study evaluates a method for reengineering a procedural system to an object-oriented system. Relationships between functions in the procedural system were identified using various coupling metrics. While the coupling metrics used for analysis were helpful in identifying candidate objects, domain expert analysis of the candidate objects was required. The time taken at each step in the process was captured to help determine the effectiveness of the method. Overall the process was found to be effective for identifying objects.

SmartEiffel has been enjoying two different mechanisms to express subtyping and implementation inheritance for one year. After large scale practical tests and thanks to user feedback, this paper finalises the new typing policy of SmartEiffel, which combines two forms of multiple inheritance with genericity in one statically-checked, object-oriented language. Having two forms of inheritance allows the designer to capture more design decisions in the source code. It is now straightforward to share reusable code between otherwise unrelated types. The new mechanism allows to reuse code from an existing class without polluting the reuser’s interface. It also enables an elegant implementation of some design patterns. Furthermore, this mechanism helps compilers to statically remove more dynamic dispatch code. It can also be used to add a no-penalty and no-risk multiple-inheritance-like construct to a single-inheritance language such as Java.

The development and maintenance of a reuse repository requires significant investment, planning and managerial support. To minimise risk and ensure a healthy return on investment, reusable components should be accessible, reliable and of a high quality. In this paper we concentrate on accessability; we describe a technique which enables a developer to effectively and conveniently make use of large scale libraries. Unlike most previous solutions to component retrieval, our tool, RASCAL, is a proactive component recommender. RASCAL recommends a set of task-relevant reusable components to a developer. Recommendations are produced using Collaborative Filtering (CF). We compare and contrast CF effectiveness when using two information retrieval techniques, namely Vector Space Model (VSM) and Latent Semantic Indexing (LSI). We validate our technique on real world examples and find overall results are encouraging; notably, RASCAL can produce reasonably good recommendations when they are most valuable i.e., at an early stage in code development.

Object-oriented frameworks are nowadays a common and useful technology used in the implementation of software system families. Despite their benefits, over the last years many researchers have described the inadequacy of object-oriented mechanisms to address the modularization and composition of many framework features, thus reducing the extent to which a framework can be extended. The crosscutting nature of many framework features is identified as one of the main causes of these problems. In this paper, we analyze how aspect-oriented programming can help to improve the design, implementation, and extension of object-oriented frameworks. We propose the concept of Extension Join Points (EJPs) as a way of designing and documenting existing crosscutting extension points. EJPs improve framework extensibility, including superior composability of the framework core functionality with other modules or frameworks. Four case studies of frameworks from diverse domains are presented to illustrate our proposal. This paper also discusses lessons learned on the application of our approach to the development and extension of these frameworks.

The manifestation of miscellaneous aspect-oriented extensions raises the question of how these extensions can be used together to combine their aspectual capabilities or reuse aspect code across extensions. While white-box composition of aspect mechanisms can produce an optimal compound mechanism, as exemplified by the merger of A spect J and A spect W erkz into A spect J 5, it comes with a high integration cost. Meanwhile, generic black-box composition can compose arbitrary aspect mechanisms, but may result in a compound mechanism that is suboptimal in comparison to white-box composition. For a particular family of aspect extensions, e.g.,A spect J-like mechanisms, glass-box composition offers the best of two worlds. Glass-box may rely on the internal structure of, e.g., a pointcut-and-advice mechanism, without requiring a change to the code of the individual mechanisms. In this paper we compare white-, black-, and glass-box composition of aspect mechanisms. We explain subtle composition issues using an example drawn from the domain of secure and dependable computing, deploying a fault-tolerance aspect written in A spect W erkz together with an access-control aspect written in A spect J. To compare the three composition methods, we integrate a TinyAJ extension with a TinyAW extension, and compare the results of running the aspects in a black-box framework and in a glass-box framework to the result of running these aspects in A spect J 5.

Due to the availability of components and the diversity of target applications, mismatches between pre-qualified existing components and the particular reuse context in applications are often inevitable and have been a major hurdle of component reusability and successful composition. Although component adaptation has acted as a key solution of eliminating these mismatches, existing practices are either only capable for adaptation at a rather simple level, or require too much intervention from software engineers. This paper presents a highly automatic approach to component adaptation at adequately deep level. The adaptability and automation is achieved in an aspect-oriented component reuse framework by generating and then applying the adaptation aspects under designed weaving process according to specific adaptation requirements. An expandable library of reusable adaptation aspects at multiple abstraction levels has been developed. A prototype tool is developed to scale up the approach.

True reusability of components assumes that they not only offer the functionality prescribed by their APIs, but also that they conform to a well-defined set of quality attributes so that we know if a component can be successfully reused in a new software product. One of the problems with quality attributes however is that it is hard to identify the characteristics of components that contribute to their emergence. End-user quality attributes are versatile and difficult to predict but their occurrence is not of an accidental nature. In this paper we propose a methodology for the exploration of candidate architectural tactics during component analysis and design for the achievement of desirable quality effects. Our approach is based on executable specifications of components that are augmented with the required tactic-related parameters to form a testbed for quality-driven experimentation. We believe that the proposed approach delivers both reusable components as well as reusable models.