Catálogo de publicaciones - libros

The improvement of the software development process through the development and utilization of high quality and reusable software components has been advocated for a long time. Agile Methods promote some interesting practices, in particular the practice of refactoring, which are supposed to improve understandability and maintainability of source code. In this research we analyze if refactoring promotes ad-hoc reuse of object-oriented classes by improving internal quality metrics. We conduct a case study in a close-to industrial, agile environment in order to analyze the impact of refactoring on internal quality metrics of source code. Our findings sustain the hypothesis that refactoring enhances quality and reusability of – otherwise hard to reuse – classes in an agile development environment. Given such promising results, additional experimentation is required to validate and generalize the results of this work.

Software reuse is widely recognized as an effective way of increasing the quality of software systems whilst lowering the effort and time involved in their development. Although most of the basic techniques for software retrieval have been around for a while, third party reuse is still largely a “hit and miss” affair and the promise of large case component marketplaces has so far failed to materialize. One of the key obstacles to systematic reuse has traditionally been the set up and maintenance of up-to-date software repositories. However, the rise of the World Wide Web as a general information repository holds the potential to solve this problem and give rise to a truly ubiquitous library of (open source) software components. This paper surveys reuse repositories on the Web and estimates the amount of software currently available in them. We also briefly discuss how this software can be harvested by means of general purpose web search engines and demonstrate the effectiveness of our implementation of this approach by applying it to reuse examples presented in earlier literature.

Software frameworks offer sets of reusable and adaptable compo-nents embedded within an architecture optimized for a given target domain. This paper introduces an approach to the design of software frameworks for real-time applications. Real-Time applications are characterized by functional and non-functional (e.g. timing) requirements. The proposed approach separates the treatment of these two aspects. For functional issues, it defines an extensible state machine concept to define components that encapsulate functional behaviour and offer adaptation mechanisms to extend this behaviour which warrant preservation of the functional properties that characterize the framework. For timing issues, it defines software structures that are provably endowed with specific timing properties and which encapsulate functional activity in a way that warrants their enforcement. A UML2 profile is defined that formally captures both aspects and allows the proposed strategy to be deployed at design level.

The Model Driven Architecture (MDA) promotes the use of models and model transformations for developing software systems. The idea behind MDA is to manage the evolution from Platform Independent Models to Platform Specific Models that can be used to generate executable components and applications. The concepts of metamodels and metamodel-based model transformations are critical in MDA. In this paper, we propose a metamodeling technique to reach a high level of reusability and adaptability of MDA components. In particular, we analyze how to define reusable components for the standard design patterns in a way that fits MDA very closely. To define families of reusable components we describe a “megamodel” that refers to metamodels and model transformations organized into an architectural framework. We propose a “megamodel” formalization that focuses on interoperability of formal languages in Model Driven Development (MDD).

One of Software Engineering’s main goals is to build complex applications in a simple way. For that, software components must be described by its functional and non-functional properties. Then, the problem is to know which component satisfies a specific need in a specific composition context, during software conception or maintenance. We state that this is a substitution problem in any of the two cases. From this statement, we propose a need-aware substitution model that takes into account functional and non-functional properties.

The literature on mobile middleware is extensive. Numerous aspects of the mobility’s effect on middleware have been analysed and the amount of previous work allowed to identify the most important patterns. Although the notion of “most important middleware” depends on the application supported by the middleware, there are traits that can be discovered in most of the connected mobile applications. Based on the experience of several authors, these traits are context-awareness, reflectivity, support for off-line operation and asynchronous (message-based) communication. This paper presents a mobile middleware system built to support these patterns and demonstrates, how the OSGi service platform can be used to realize these patterns. It will be demonstrated that although OSGi was built to support manageability requirements, the resulting platform is suitable for implementing the 4 major middleware patterns too. The paper presents the components of this context-aware, reflective middleware framework and evaluates its footprint.

To establish software reuse successfully in the long run, it is crucial for providers of reusable components to continuously react on problems or future trends arising around their component. In practice, however, many providers of reusable components are not able to do so due to insufficient feedback and details from reusers. Additionally, they often have too little knowledge on system context and constraints that may lead to major deficits of the reusable component especially with respect to non-functional aspects. This paper presents an approach for systematically engineering performance of reusable components that has been validated in an industrial context.

Component-based software engineering (CBSE) for companies active in custom solutions development is far from being reality. To make progress more industrial research as well as accordant technology management is needed. In this contribution we introduce a classification of components in terms of component’s scale and in terms of functional vs. technical concerns. From this basis we argue that only some areas of software reuse promise substantial growth in delivery efficiency and show how this is related to the extra organizational reuse approach.

Current reuse techniques disincentive their mass practice in software development organizations because of their large initial investments, the changes they required in ways of developing software, and their fragility in front of domain evolutions.  We argue that the root of these problems is the poor resolution of retrieval techniques to identify candidate artifacts to utilize in new projects. We sketch an approach to reuse based on artifacts retrieval by content, which allows incremental adoption at low cost.  The Incremental Reuse Method (IRM), founded on these principles, can solve the big problems of traditional reuse, allowing their application in all manner of organizations.

The aim of the paper is to present a framework to contribute to the improvement of requirements elicitation by reusing domain models. In our approach, a domain model gathers goals organized in goal hierarchies associated with domain rules and materialized in conceptual fragments. A conceptual fragment represents an abstract view of the specification allowing the realization of a given goal. To construct a system, the designer will extract requirements from the domain model and adapt the obtained conceptual fragments to the context of the system. Two principles are used to represent domain models: abstraction, which allows the description of common properties of a given domain, and variability, which allows the description of discriminatory properties of the domain. In our approach, variability is applied on the three levels: goal, domain rule and conceptual fragment.