A Software Product Line (SPL) is a family of related programs, which of each is defined by a combination of features. By developing related programs together, an SPL simultaneously reduces programming effort and satisfies multiple sets of requirements. Testing an SPL efficiently is challenging because a property must be checked for all the programs in the SPL, the number of which can be exponential in the number of features. In this dissertation, we present a suite of complementary static and dynamic techniques for efficient testing and runtime monitoring of SPLs, which can be divided into two categories. The first prunes programs, termed configurations, that are irrelevant to the property being tested. More specifically, for a given test, a static analysis identifies features that can influence the test outcome, so that the test needs to be run only on programs that include these features. A dynamic analysis counterpart also eliminates configurations that do not have to be tested, but does so by checking a simpler property and can be faster and more scalable. In addition, for runtime monitoring, a static analysis identifies configurations that can violate a safety property and only these configurations need to be monitored. When no configurations can be pruned, either by design of the test or due to ineffectiveness of program analyses, runtime similarity between configurations, arising due to design similarity between configurations of a product line, is exploited. In particular, shared execution runs all the configurations together, executing bytecode instructions common to the configurations just once. Deferred execution improves on shared execution by allowing multiple memory locations to be treated as a single memory location, which can increase the amount of sharing for object-oriented programs and for programs using arrays. The techniques have been evaluated and the results demonstrate that the techniques can be effective and can advance the idea that despite the feature combinatorics of an SPL, its structure can be exploited by automated analyses to make testing more efficient. / text

This thesis presents the development of a prototype of the Baseline Oriented Modeling (BOM) approach, called protoBOM. BOM is a framework that semi-automatically generates Decision Support Systems in a specific domain, based on Software Product Lines. protoBOM semi-automatically generates applications as PRISMA architectural models by using Model-Driven Architecture and Software Product Line techniques. These models are automatically compiled and the object code (C#, in .NET) is generated obtaining an executable application. In protoBOM, the user constructs Decision Support Systems in a simpler way by using the ontologies of the diagnosis and the application domains by means of Domain Specific Languages. The interfaces will be closer to the problem domain, which will facilitate user interaction in a manner simple and intuitive.

Background: A key idea of feature orientation is to decompose a software product line along the features it provides. Feature decomposition is orthogonal to object-oriented decomposition it crosscuts the underlying package and class structure. It has been argued often that feature decomposition improves system structure (reduced coupling, increased cohesion). However, recent empirical findings suggest that this is not necessarily the case, which is the motivation for our empirical investigation. Aim: In fact, there is little empirical evidence on how the alternative decompositions of feature orientation and object orientation compare to each other in terms of their association with observable properties of system structure (coupling, cohesion). This motivated us to empirically investigate and compare the properties of three decompositions (object-oriented, feature-oriented, and their intersection) of 28 feature-oriented software product lines. Method: In an exploratory, observational study, we quantify internal attributes, such as import coupling and cohesion, to describe and analyze the different decompositions of a feature-oriented product line in a systematic, reproducible, and comparable manner. For this purpose, we use three established software measures (CBU, IUD, EUD) as well as standard distribution statistics (e.g., Gini coefficient). Results: First, feature decomposition is associated with higher levels of structural coupling in a product line than a decomposition into classes. Second, although coupling is concentrated in feature decompositions, there are not necessarily hot-spot features. Third, the cohesion of feature modules is not necessarily higher than class cohesion, whereas feature modules serve more dependencies internally than classes. Fourth, coupling and cohesion measurement show potential for sampling optimization in complex static and dynamic product-line analyses (product-line type checking, feature-interaction detection). Conclusions: Our empirical study raises critical questions about alleged advantages of feature decomposition. At the same time, we demonstrate how the measurement of structural attributes can facilitate static and dynamic analyses of software product lines. (authors' abstract) / Series: Technical Reports / Institute for Information Systems and New Media

Many organizations specialize in the development of families of software systems, called software product lines (SPLs), for one or more domains (e.g., automotive, telephony, health care). SPLs are commonly developed as a shared set of assets representing the common and variable aspects of an SPL, and individual products are constructed by assembling the right combinations of assets. The feature-oriented software development (FOSD) paradigm advocates the use of system features as the primary unit of commonality and variability among the products of an SPL. A feature represents a coherent and identifiable bundle of system functionality, such as call waiting in telephony and cruise control in an automobile. Furthermore, FOSD aims at feature-oriented artifacts (FOAs); that is, software-development artifacts that explicate features, so that a clear mapping is established between a feature and its representation in different artifacts. The thesis first identifies the problem of developing a suitable language for expressing feature-oriented models of the functional requirements of an SPL, and then presents the feature-oriented requirements modelling language (FORML) as a solution to this problem. FORML's notation is based on standard software-engineering notations (e.g., UML class and state-machine models, feature models) to ease adoption by practitioners, and has a precise syntax and semantics to enable analysis. The novelty of FORML is in adding feature-orientation to state-of-the-art requirements modelling approaches (e.g., KAOS), and in the systematic treatment of modelling evolutions of an SPL via enhancements to existing features. An existing feature can be enhanced by extending or modifying its requirements. Enhancements that modify a feature's requirements are called intended feature interactions. For example, the call waiting feature in telephony intentionally overrides the basic call service feature's treatment of incoming calls when the subscriber is already involved in a call. FORML prescribes different constructs for specifying different types of enhancements in state-machine models of requirements. Furthermore, unlike some prominent approaches (e.g., AHEAD, DFC), FORML's constructs for modelling intended feature interactions do not depend on the order in which features are composed; this can lead to savings in analysis costs, since only one rather than (possibly) multiple composition orders need to be analyzed. A well-known challenge in FOSD is managing feature interactions, which, informally defined, are ways in which different features can influence one another in defining the overall properties and behaviours of their combination. Some feature interactions are intended, as described above, while other feature interactions are unintended: for example, the cruise control and anti-lock braking system features of an automobile may have incompatible affects on the automobile's acceleration, which would make their combination inconsistent. Unintended feature interactions should be detected and resolved. To detect unintended interactions in models of feature behaviour, we must first define a taxonomy of feature interactions for the modelling language: that is, we must understand the different ways that feature interactions can manifest among features expressed in the language. The thesis presents a taxonomy of feature interactions for FORML that is an adaptation of existing taxonomies for operational models of feature behaviour. The novelty of the proposed taxonomy is that it presents a definition of behaviour modification that generalizes special cases found in the literature; and it enables feature-interaction analyses that report only unintended interactions, by excluding interactions caused by FORML's constructs for modelling intended feature interactions.

[pt] Nesta tese investigou-se o desenvolvimento de software no contexto de groupware, especificamente para apoiar a aprendizagem colaborativa. O desenvolvimento de groupware, entretanto, não é trivial. Como todo software, há aspectos tecnológicos e sociais envolvidos no desenvolvimento. Quanto aos aspectos tecnológicos, o desenvolvimento de artefatos de infraestrutura ocupam grande parte do esforço destinado à implementação dessas aplicações, sobrando pouco tempo para a implementação de soluções inovadoras para as questões da colaboração propriamente ditas. Com respeito aos aspectos sociais, deve-se levar em conta que o trabalho em grupo é dinâmico e a composição dos grupos, bem como suas características, se alteram com o passar do tempo. Assim, desenvolveu-se uma linha de produtos de software para groupware baseado no Modelo 3C de Colaboração, onde os groupware são derivados a partir da formalização de técnicas de aprendizagem colaborativa em scripts de colaboração. Foi desenvolvido um protótipo, o GroupwareBuilder para interpretar o script de colaboração e derivar o groupware para suporte específico das suas atividades. Uma avaliação funcional e um estudo de caso foram realizados. Na avaliação funcional, buscou-se obter uma prova de conceito do GroupwareBuilder, na qual dois groupware foram derivados para apoiar os scripts de colaboração Debate Crítico e Buzz Groups. O estudo de caso foi realizado para observar como se daria a derivação de groupware para técnicas de aprendizagem colaborativa modeladas por diferentes professores. A principal contribuição deste trabalho é uma abordagem que possibilita a derivação e adaptação de groupware a partir de scripts de colaboração elaborados pelos usuários e não a partir de uma lista de requisitos funcionais, como em LPS’s tradicionais. / [en] In this thesis we explore software development on the context of groupware, specifically on supporting collaborative learning. Groupware development is not a trivial task given that technological and social issues are involved. Considering the technological issues, a huge amount of time is wasted on implementing infrastructure aspects leaving little time for implementation of innovative solutions on collaboration. Considering the social issues, we should take into account that group work is dynamic and that group composition changes over time. So, we developed a software product line for groupware based on the 3C Collaboration Model. The groupware derivation process starts with the formalization of the collaborative learning techniques in collaboration scripts. In order to support this collaboration process we developed the GroupwareBuilder, that reads the collaboration script and derives groupware tailored to the tasks described on the script. We made a functional evaluation and a case study. On the functional evaluation, we aimed on getting a proof of concept for GroupwareBuilder by deriving groupware for supporting the Critical Debate and Buzz Groups collaboration scripts. In order to analyze how GroupwareBuilder derives groupware from other collaborative learning techniques described by different teachers we made a case study. The main contribution of this thesis is an approach that enables the derivation of groupware and the customization of groupware in runtime from collaboration scripts written by the users, and not from a list of software requirements as used in other SPLs approaches.

Submitted by Kleber Silva (kleberbs@ufba.br) on 2017-06-01T20:36:17Z No. of bitstreams: 1 2015_Thesis_Final_v01.pdf: 25381943 bytes, checksum: cf9b5a7ab05c5f433c6abe06c7c8815e (MD5) / Approved for entry into archive by Vanessa Reis (vanessa.jamile@ufba.br) on 2017-06-07T11:38:56Z (GMT) No. of bitstreams: 1 2015_Thesis_Final_v01.pdf: 25381943 bytes, checksum: cf9b5a7ab05c5f433c6abe06c7c8815e (MD5) / Made available in DSpace on 2017-06-07T11:38:56Z (GMT). No. of bitstreams: 1 2015_Thesis_Final_v01.pdf: 25381943 bytes, checksum: cf9b5a7ab05c5f433c6abe06c7c8815e (MD5) / Software Product Line (SPL) has emerged as an important strategy to cope with the increasing demand of large-scale products customization. SPL has provided companies with an efficient and effective means of delivering products with higher quality at a lower cost, when compared to traditional software engineering strategies. However, such benefits do not come for free. There is a necessity in SPL to deal with the evolution of its assets to support changes within the environment and user needs. These changes in SPL are firstly represented by requirements. Thus, SPL should manage the commonality and variability of products by means of a “Requirements Engineering (RE) - change management” process. Hence, besides dealing with the reuse and evolution of requirements in an SPL, the RE for SPL also needs an approach to represent explicitly the commonality and variability information (e.g., through feature models and use cases). To understand the evolution in SPL, this Thesis presents two empirical studies within industrial SPL projects and a systematic mapping study on SPL evolution. The two empirical studies evaluated Lehman’s laws of software evolution in two industrial SPL projects,demonstrating that most of the laws are supported by SPL environments. The systematic mapping study on SPL evolution identified approaches in the area and revealed gaps for researching, such as, that most of the proposed approaches perform the evolution of SPL requirements in an ad-hoc way and were evaluated through feasibility studies. These results led to systematize, through guidelines, the SPL processes by starting with the SPL requirements. Thus, it was proposed an approach to specify SPL requirements called Feature-Driven Requirements Engineering (FeDRE). FeDRE specifies SPL requirements in a systematic way driven by a feature model. To deal with the evolution of FeDRE requirements, a new approach called Feature-Driven Requirements Engineering Evolution (FeDRE2) was presented. FeDRE2 is responsible for guiding, in a systematic way, the SPL evolution based on activities from RE. Both proposed approaches, FeDRE and and FeDRE2, were evaluated and the results, besides being preliminaries, shown that the approaches were perceived as easy to use and also useful, coping with the improvement and systematization of SPL processes.

abstract: Affect signals what humans care about and is involved in rational decision-making and action selection. Many technologies may be improved by the capability to recognize human affect and to respond adaptively by appropriately modifying their operation. This capability, named affect-driven self-adaptation, benefits systems as diverse as learning environments, healthcare applications, and video games, and indeed has the potential to improve systems that interact intimately with users across all sectors of society. The main challenge is that existing approaches to advancing affect-driven self-adaptive systems typically limit their applicability by supporting the creation of one-of-a-kind systems with hard-wired affect recognition and self-adaptation capabilities, which are brittle, costly to change, and difficult to reuse. A solution to this limitation is to leverage the development of affect-driven self-adaptive systems with a manufacturing vision. This dissertation demonstrates how using a software product line paradigm can jumpstart the development of affect-driven self-adaptive systems with that manufacturing vision. Applying a software product line approach to the affect-driven self-adaptive domain provides a comprehensive, flexible and reusable infrastructure of components with mechanisms to monitor a user’s affect and his/her contextual interaction with a system, to detect opportunities for improvements, to select a course of action, and to effect changes. It also provides a domain-specific architecture and well-documented process guidelines, which facilitate an understanding of the organization of affect-driven self-adaptive systems and their implementation by systematically customizing the infrastructure to effectively address the particular requirements of specific systems. The software product line approach is evaluated by applying it in the development of learning environments and video games that demonstrate the significant potential of the solution, across diverse development scenarios and applications. The key contributions of this work include extending self-adaptive system modeling, implementing a reusable infrastructure, and leveraging the use of patterns to exploit the commonalities between systems in the affect-driven self-adaptation domain. / Dissertation/Thesis / Doctoral Dissertation Computer Science 2016

This report presents the results of a thesis project that surveys and designs about the issue “Feature Model for Adaptive Computing”. In this project, there are two main issues, first one is about the Feature Modeling, and the second is how to use this Feature Modeling for adaptive computing. In this thesis report, at the beginning, we present the problem we expected to solve and introduce some background information, including the knowledge of feature model and adaptive computing. Then we explain our solution and evaluate this solution. At the end of this report, we give a short conclusion about our thesis project and feature work.

Submitted by Nayara Passos (nayara.passos@ufpe.br) on 2015-03-10T13:51:24Z No. of bitstreams: 2 DISSERTAÇÃO Jean Carlos de Carvalho Melo.pdf: 1961390 bytes, checksum: d66fd564809f98e0c5bd50687923f9e0 (MD5) license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) / Made available in DSpace on 2015-03-10T13:51:24Z (GMT). No. of bitstreams: 2 DISSERTAÇÃO Jean Carlos de Carvalho Melo.pdf: 1961390 bytes, checksum: d66fd564809f98e0c5bd50687923f9e0 (MD5) license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) Previous issue date: 2014 / INES, CNPq / Diante do ambiente complexo e dinâmico encontrado nas empresas atualmente, o sistema tradicional de Workflow não está sendo flexível suficiente para modelar Processos de Negócio. Nesse contexto, surgiram os Processos Flexíveis que tem por principal objetivo suprir a necessidade de modelar processos menos estáticos. Processo declarativo é um tipo de processo flexível que permite os participantes decidirem a ordem em que as atividades são executadas através de regras de negócio. As regras de negócio determinam as restrições e obrigações que devem ser satisfeitas durante a execução. Tais regras descrevem o que deve ou não deve ser feito durante a execução do processo, mas não definem como. Os métodos e ferramentas atualmente disponíveis para modelar e executar processos declarativos apresentam várias limitações que prejudicam a sua utilização para este fim. Em particular, a abordagem que emprega lógica temporal linear (LTL) sofre do problema de explosão de estados a medida que o tamanho do modelo do processo cresce. Embora mecanismos eficientes em relação a memória terem surgido, eles não são capazes de adequadamente garantir a conclusão correta do processo, uma vez que permitem o usuário alcançar estados proibidos ou que causem deadlock. Além disso, as implementações atuais de ferramentas para execução de processos declarativos se concentram apenas em atividades manuais. Comunicação automática com aplicações externas para troca de dados e reutilização de funcionalidade não é suportado. Essas oportunidades de automação poderiam ser melhor exploradas por uma engine declarativa que se integra com tecnologias SOC existentes. Este trabalho propõe uma nova engine de regras baseada em grafo, chamado de REFlex. Tal engine não compartilha os problemas apresentados pelas abordagens disponíveis, sendo mais adequada para modelar processos de negócio declarativos. Além disso, REFlex preenche a lacuna entre os processos declarativos e SOC. O orquestrador REFlex é um orquestrador de serviços declarativo, eficiente e dependente de dados. Ele permite que os participantes chamem serviços externos para executar tarefas automatizadas. Diferente dos trabalhos relacionados, o algoritmo de REFlex não depende da geração de todos os estados alcançáveis, o que o torna adequado para modelar processos de negócios grandes e complexos. Além disso, REFlex suporta regras de negócio dependentes de dados, o que proporciona sensibilidade ao contexto. / Declarative business process modeling is a flexible approach to business process management in which participants can decide the order in which activities are performed. Business rules are employed to determine restrictions and obligations that must be satisfied during execution time. Such business rules describe what must or must not be done during the process execution, but do not prescribe how. In this way, complex control-flows are simplified and participants have more flexibility to handle unpredicted situations. The methods and tools currently available to model and execute declarative processes present several limitations that impair their use to this application. In particular, the well-known approach that employs Linear Temporal Logic (LTL) has the drawback of the state space explosion as the size of the process model grows. Although approaches proposing memory efficient methods have been proposed in the literature, they are not able to properly guarantee the correct termination of the process, since they allow the user to reach deadlock states. Moreover, current implementations of declarative business process engines focus only on manual activities. Automatic communication with external applications to exchange data and reuse functionality is barely supported. Such automation opportunities could be better exploited by a declarative engine that integrates with existing SOC technologies. This work proposes a novel graph-based rule engine called REFlex that does not share the problems presented by other engines, being better suited to model declarative business processes than the techniques currently in use. Additionally, such engine fills this gap between declarative processes and SOC. The REFlex orchestrator is an efficient, data-aware declarative web services orchestrator. It enables participants to call external web services to perform automated tasks. Different from related work, the REFlex algorithm does not depend on the generation of all reachable states, which makes it well suited to model large and complex business processes. Moreover, REFlex is capable of modeling data-dependent business rules, which provides unprecedented context awareness and modeling power to the declarative paradigm.

Made available in DSpace on 2014-06-12T15:54:05Z (GMT). No. of bitstreams: 2 arquivo6551_1.pdf: 2254714 bytes, checksum: 89a6702d1c801f178299f95585aac5ab (MD5) license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5) Previous issue date: 2007 / Linha de Produtos de Software (LPS) é uma aborgadem promissora para o desenvolvimento de um conjunto de produtos focados em um segmento de mercado e desenvolvidos a partir de um conjunto comum de artefatos. Possíveis benefícios incluem reuso em larga escala e significativa melhoria em produtividade. Um problema-chave associado, no entanto, é o tratamento de estratégias de implantação, em que uma organização decide iniciar uma LPS a partir do zero, fazer bootstrap de produtos existentes em uma LPS, ou evoluir uma LPS. Em particular, no nível de implementação e de modelo de features, métodos de desenvolvimento carecem de apoio adequado para extração e evolução de LPSs. Neste contexto, apresentamos um m´etodo original provendo diretrizes concretas para extração e evolução de LPSs no nível de implementação e de modelo de features, nos quais proporciona reuso e segurança. O método primeiro faz o bootstrap da LPS e então a evolui com uma abordagem reativa. O método se baseia em uma coleção de refatoramentos tanto na implementação (refatoramentos orientados a aspectos) como no modelo de features. O método foi avaliado no domínio altamente variável de jogos móveis