An Instance-Oriented Approach to Constructing Product Lines from Layers

The Model/View/Controller (MVC) paradigm, and its many variants, is a cornerstone of decoupling within object-oriented design. MVC leads to clear reuse benefits regarding the class hierarchies for the model and view elements. In practice, however, the controllers appear to defy reuse, most likely because they encapsulate specialized business logic. Within an effective product line, however, such specialized logic must be reused. We combine the MVC paradigm with feature-oriented programming (FOP) to produce a novel instance-oriented design pattern for layers that brings reusability back to controllers. We demonstrate the effectiveness of our approach using a product-line example of a solitaire game engine

Managing Product Line Asset Bases

Product lines are predicated on collecting assets common to the desired product portfolio, commonly known as the asset base. For many product lines, the size of asset base has become large enough to create a variety of difficulties. The techniques for managing large product line asset bases are unaddressed in the literature. This research presents new techniques that take advantage of asset base characteristics, unavailable in more general collections, to both reduce the number of assets and to organize the asset base that go beyond what is possible with other software collections. The result is an asset base that is more efficient to use. Research related to improving the organization of the asset base was performed by taking the component assets of a research SPL and arranging them based on three different organizational criteria - according to the structure of the architecture, important abstractions (Key Domain Abstractions), and product features. The three resulting organizations were then studied using four evaluation criteria - natural division of assets into groups (assets fit into the groups provided by the organization), easy to map assets to organization criteria (mapping between the selection of a particular product variant and the assets needed to produce it), reasonably sized groups, and similarly sized groups. The effectiveness of the different organizations was then compared and recommendations concerning asset base organization provided. The literature indicates that large product lines are likely to contain multiple assets that provide the same functionality, but that differ in the program context that they support. The presence of the duplicative assets creates a number of problems including organization difficulties. In a SPL these differences in program context are the result of requirements expressed at the product`s variation points. The limited differences in program context make it practical to attempt to provide a modular solution which permits the desired variation to be assembled as needed. The research explored a number of different implementation mechanisms to provide these modular variation points. The result is a recommendation on how to implement SPL variation points provided in the form of a pattern language

Analysis and Transformation of Configurable Systems

Static analysis tools and transformation engines for source code belong to the standard equipment of a software developer. Their use simplifies a developer's everyday work of maintaining and evolving software systems significantly and, hence, accounts for much of a developer's programming efficiency and programming productivity. This is also beneficial from a financial point of view, as programming errors are early detected and avoided in the the development process, thus the use of static analysis tools reduces the overall software-development costs considerably. In practice, software systems are often developed as configurable systems to account for different requirements of application scenarios and use cases. To implement configurable systems, developers often use compile-time implementation techniques, such as preprocessors, by using #ifdef directives. Configuration options control the inclusion and exclusion of #ifdef-annotated source code and their selection/deselection serve as an input for generating tailor-made system variants on demand. Existing configurable systems, such as the linux kernel, often provide thousands of configuration options, forming a huge configuration space with billions of system variants. Unfortunately, existing tool support cannot handle the myriads of system variants that can typically be derived from a configurable system. Analysis and transformation tools are not prepared for variability in source code, and, hence, they may process it incorrectly with the result of an incomplete and often broken tool support. We challenge the way configurable systems are analyzed and transformed by introducing variability-aware static analysis tools and a variability-aware transformation engine for configurable systems' development. The main idea of such tool support is to exploit commonalities between system variants, reducing the effort of analyzing and transforming a configurable system. In particular, we develop novel analysis approaches for analyzing the myriads of system variants and compare them to state-of-the-art analysis approaches (namely sampling). The comparison shows that variability-aware analysis is complete (with respect to covering the whole configuration space), efficient (it outperforms some of the sampling heuristics), and scales even to large software systems. We demonstrate that variability-aware analysis is even practical when using it with non-trivial case studies, such as the linux kernel. On top of variability-aware analysis, we develop a transformation engine for C, which respects variability induced by the preprocessor. The engine provides three common refactorings (rename identifier, extract function, and inline function) and overcomes shortcomings (completeness, use of heuristics, and scalability issues) of existing engines, while still being semantics-preserving with respect to all variants and being fast, providing an instantaneous user experience. To validate semantics preservation, we extend a standard testing approach for refactoring engines with variability and show in real-world case studies the effectiveness and scalability of our engine. In the end, our analysis and transformation techniques show that configurable systems can efficiently be analyzed and transformed (even for large-scale systems), providing the same guarantees for configurable systems as for standard systems in terms of detecting and avoiding programming errors

Middleware e ferramentas para desenvolvimento de sistemas de vigilância para segurança, controlo e conforto (SVSC 2 - M Toolkit)

Tese de doutoramento em Informática IndustrialDevido a vários fatores socioeconómicos, existe atualmente uma enorme necessidade de se utilizarem sistemas de videovigilância inteligentes. O desenvolvimento deste tipo de sistemas tem-se tornado numa tarefa complexa, devido à necessidade de desenvolver novos produtos com um elevado número de diferentes requisitos. A complexidade está relacionada com o elevado nível de variabilidade/heterogeneidade que necessita de ser gerida. A complexidade deve-se à gestão da variabilidade em tarefas relacionada com: a captura de imagens, processamento, compressão, comunicações e visão por computador. Mais, os sistemas atuais devem correr em diferentes plataformas de hardware, que vão desde os PCs desktop até sistemas embebidos, telefones móveis, etc. Para resolver o problema da complexidade e a enorme necessidade de sistemas de videovigilância adaptados à aplicação, com um reduzido time-to-market, esta tese propõe explorar o domínio da videovigilância como uma família de produtos, que podem ser desenvolvidos seguindo uma filosofia pay-as-you-go ao invés de desenvolver produtos ex-nihilo. De forma a satisfazer os requisitos apresentados anteriormente, é proposta uma framework generativa de videovigilância. Na fase de modelação da framework generativa, é usada uma combinação de tecnologias e técnicas tais como, Software Product Line (SPL), Model Driven Development (MDD) e Agile, de modo a gerir a variabilidade existente ao nível das funcionalidades do sistema. Na fase da implementação das funcionalidades, são utilizados componentes totalmente configuráveis, desenvolvidos em C++ template metaprogramming, de modo a gerir a variabilidade do código do sistema e a reutilização dos componentes. A framework de videovigilância proposta apresenta vantagens comparativamente com os métodos tradicionais, principalmente, reduz o time-to-market, causa baixo impacto no desempenho e permite gerir melhor a variabilidade.Due to a variety of socio-economic factors, currently there is a growing demand for intelligent video surveillance systems. The development of such systems is becoming increasingly complex since there is a high demand for rapid deployment of novel products with a rising number of different requirements. The complexity arises from the high level of variability/heterogeneity that needs to be managed. The increasing complexity is induced by the variability in tasks related to image capturing, processing, compression, communications and computer vision. Furthermore, it is now expected that systems should run in different hardware platforms, ranging from desktop PCs to low cost embedded boards, mobile phones, etc. To tackle the growing complexity and huge demand for application-tailored video surveillance systems, along with very tight time-to-market expectations, this thesis proposes exploiting the video surveillance domain as families of systems that can be developed following a pay-as-you-go fashion rather than developing products ex-nihilo. To better accommodate all the above listed requirements, a new video surveillance fully-reconfigurable generative framework is proposed. In the framework’s modeling stage, the combination and interoperability of Software Product Line (SPL) technologies, Model-Driven Development (MDD) and Agile Development were promoted, in order to manage the existing variability at the system functionality level. At the framework’s implementation stage, fully-customizable components, developed in C++ template metaprogramming, were used, in order to provide code variability management mechanisms and to promote high component re-use. The proposed video surveillance generative framework presents several advantages when compared to the traditional methods, namely, short time-to-market, low performance overhead, and variability management

Generic Implementation of Product Line Components

An argument pro component-based software development is the idea of constructing software systems by assembling preexisting components instead of redeveloping similar or identical functionality always from scratch. Unfortunately, integrating existing components practically means adaptation and use rather than use only, which makes an ideal component-based development hard to realize in practice. Product line engineering, however, tackles this problem by making components as generic as needed for a particular product family and thus allows component reuse. Such a component covers variabilities and thus its implementation must consider variabilities as well