A crescente demanda por novas aplicações informatizadas, e a evolução da sua complexidade, faz com que seja cada vez mais importante a correta aplicação de esforços no processo de desenvolvimento de software. Apesar da dificuldade em se obter dados, estudos empíricos sobre a evolução do software podem auxiliar na criação de modelos e teorias que aperfeiçoem os esforços de desenvolvimento. Tendo acesso a uma base de informações de mais de cinco anos de solicitações de mudanças (que incluem melhorias e correções) de uma mesma organização de desenvolvimento, o problema da pesquisa era obter indicadores dos projetos de desenvolvimento que estivessem relacionados aos maiores custos de mudanças. A partir dessa formulação, foi definido como objetivo efetuar a análise dos custos de mudanças e, para isso, os casos com os maiores tempos de desenvolvimento foram classificados (utilizando a classificação ODC – Orthogonal Defect Classification), analisados individualmente, comparados entre si e com outros estudos. Como resultado do trabalho de análise dos custos de mudanças de software, são apresentadas faixas de valores (no início de entrada em produção e ao final de vinte meses de utilização em produção) de métricas de software pela quais são efetuadas comparações e que, eventualmente, podem ser utilizadas como comparação para outros projetos da mesma ou de outras empresas. Foram identificadas características em um projeto em específico que propõe associar a métrica de entrelaçamento de pacotes, no momento de entrada em produção, com o principal impacto da dimensão ODC. Essa associação pode ser considerada como a principal indicação relacionada aos custos de manutenção do software e, por meio do estabelecimento dessa associação entre métricas observadas durante o processo de desenvolvimento de sistemas, pode-se diminuir custos futuros na etapa de manutenção de software. / The increasing demand for new computer applications and the evolution of its complexity makes increasingly important the correct application of effort in the process of software development. Despite the difficulty in obtaining data, empirical studies on the evolution of software can assist in the creation of models and theories that enhance development efforts. Having access to a database of information of more than five years of change requests (including improvements and fixes) of the same development organization, the research problem was to obtain indicators of development projects that were related to higher costs of change. From this formulation, was set to perform the objective analysis of the costs of change and, therefore, the cases with the greatest development times were classified (using the ODC - Orthogonal Defect Classification) analyzed individually, compared with each other and with other studies. Resulting of the work for examining costs of software changes, ranges of values are presented (early start of production and at the end of twenty months of production use) software metrics for which comparisons are made and eventually may be used as a comparison to other projects of the same or other companies. There were characteristics, in a specific project, that proposes to associate the Package tangle index at the time of entry into production, with the main impact of the size ODC. This association can be regarded as the main indication related to software maintenance costs, and by establishing an association between this metric observed during the development of systems, can reduce future costs in the software maintenance phase.

A classificação das issues ou questões nos repositórios de manutenção de software é realizada atualmente pelos desenvolvedores de software. Entretanto, essa classificação manual não é livre de erros, os quais geram problemas na distribuição das issues para as equipes de tratamento. Isso acontece porque os desenvolvedores, geralmente os propositores das issues, possuem o mal hábito de classificá-las como bugs. Essas classificações errôneas produzem a distribuição de issues para uma equipe de tratamento de outro tipo de issue, gerando retrabalho para as equipes entre outras desvantagens. Por isso, o principal objetivo almejado com o estudo é a melhoria dessa classificação, utilizando de uma abordagem de classificação das issues realizada de maneira automatizada. Essa abordagem foi implementada com técnicas de Aprendizado de Máquina. Estas técnicas mostram que as palavras-chave discriminantes dos tipos de issues podem ser utilizadas como atributos de classificadores automáticos para a predição dessas issues. A abordagem foi avaliada sobre 5 projetos open source extraídos de 2 issue trackers conhecidos, Jira e Bugzilla. Por se tratarem de issue trackers de longa data, os projetos escolhidos forneceram boa quantidade de issues para este estudo. Essas issues, cerca de 7000, foram classificadas por especialistas humanos no trabalho [Herzig, Just e Zeller 2013], produzindo um gabarito utilizado para a realização deste estudo. Este trabalho produziu um classificador automático de issues, com acurácia de 81%, capaz de discriminá-las nos tipos bug, request for enhancement e improvement. O bom resultado de acurácia sugere que o classificador concebido possa ser utilizado em sistemas de encaminhamento de issues para as equipes de tratamento, com a Ąnalidade de diminuir retrabalho dessas equipes que ocorre em virtude da má classificação. / The classification of issues in software maintenance repositories is currently done by software developers. However, this classification is conducted manually and is not free of errors, which cause problems in the distribution of issues to the maintenance teams. This happen because the developers, which usually are the proponents of the issues, have the bad habit of classifying them as bugs. This erroneous rating generates rework and other disadvantages to the teams. Therefore, the main objective of this study is to improve this classification, using an issue classification approach conducted in an automated manner. In turn, this approach was implemented based on machine learning tecniques. These tecniques show that keywords discriminant of issues types can be used as attributes of automatic classifiers for prediction of these issues. The approach was evaluated on five open source projects extracted from two widely used issue trackers, Jira and Bugzilla. Because they are old issue trackers, the chosen projects provided good number of issues for this study. These issues, about 7.000, were classified by human experts at work [Herzig, Just e Zeller 2013], producing a feedback which was used for this study. This present work produced an automatic issues classifier, with 81% of accuracy, able to predict them in types of bug, request for enhancement and improvement. The result of accuracy obtained by this classifier suggests that it can be used in delivery systems to treatment teams with the purpose of reducing rework that occurs in these teams because of the poor issues rating. / Dissertação (Mestrado)

Submitted by Nayara Passos (nayara.passos@ufpe.br) on 2015-03-13T13:04:40Z No. of bitstreams: 2 TESE Yaguaratã Cerqueira Cavalcanti.pdf: 2989671 bytes, checksum: cdde3d6cea6de1cabb90748865421b78 (MD5) license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) / Made available in DSpace on 2015-03-13T13:04:40Z (GMT). No. of bitstreams: 2 TESE Yaguaratã Cerqueira Cavalcanti.pdf: 2989671 bytes, checksum: cdde3d6cea6de1cabb90748865421b78 (MD5) license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) Previous issue date: 2014 / The efficient management of Change Requests (CRs) is fundamental for successful software maintenance; however the assignment of CRs to developers is an expensive aspect in this regard, due to the time and expertise demanded. To overcome this, researchers have proposed automated approaches for CR assignment. Although these proposals present advances to this topic, they do not consider many factors inherent to the assignments, such as: developers’ workload, CRs severity, interpersonal relationships, and developers know-how. Actually, as we demonstrate in this work, CR assignment is a complex activity and automated approaches cannot rely on simplistic solutions. Ideally, it is necessary to consider and reason over contextual information in order to provide an effective automation. In this regarding, this work proposes, implements, and validates a context-aware architecture to automate CR assignment. The architecture emphasizes the need for considering the different information available at the organization to provide a more context-aware solution to automated CR assignment. The development of such architecture is supported by evidence synthesized from two empirical studies: a survey with practitioners and a systematic mapping study. The survey provided us with a set of requirements that automated approaches should satisfy. In the mapping study, in turn, we figured out how state-of-the-art approaches are implemented in regarding to these requirements, concluding that many of them are not satisfied. In addition, new requirements were identified in this mapping study. For the implementation of the proposed architecture, we developed a strategy to automate CR assignments which is based on two main components: a Rule-Based Expert System (RBES) and an Information Retrieval (IR) model. The strategy coordinately applies these two components in different steps to find the potential developer to a CR. The RBES takes care of the simple and complex rules necessary to consider contextual information in the assignments, e.g., to prevent assigning a CR to a busy or unavailable developer. Since these rules vary from one organization/project to another, the RBES facilitates their modification for different contexts. On the other hand, the IR model is useful to make use of the historical information of CR assignments to match CRs and developers. Results from the validation study showed that our solution is promising. It is, by comparing the solution with an approach that uses only a machine learning algorithm, such as the Support Vector Machine (SVM), we could improve the accuracy of assignments by almost 50%. The analysis of the solution’s payoff also pointed that such an accuracy is able to pay for the efforts necessary to deploy the solution.-------------------------------------O gerenciamento eficiente de solicitações de mudança (SM) é fundamental para o sucesso das atividades de manutenção e evolução de software. Entretanto, a atribuição de SMs a desenvolvedores é um aspecto custoso desse gerenciamento, pois demanda tempo e conhecimento apropriado do projeto de software. Várias pesquisas já propuseram métodos de atribuição automática de SMs. Embora representem avanços na área, existem fatores inerentes a atribuição de SMs que não são considerados nessas pesquisas e são essenciais para a automação. Como demonstrado nesse trabalho, a atribuição automática deve, por exemplo, considerar a carga de trabalho, a experiência e o conhecimento dos desenvolvedores, a prioridade e a severidade das SMs, a afinidade dos desenvolvedores com os problemas descritos nas SMs, e até mesmo os relacionamentos interpessoais. Para tornar esse cenário ainda mais complexo, esses fatos podem variar de acordo com o projeto de software que está sendo desenvolvido. Assim, uma solução para o problema de atribuição de SMs depende de informações contextuais. Assim, esse trabalho propõe, implementa e valida uma solução arquitetural sensível ao contexto para atribuição automática de SMs. Dado o aspecto contextual da solução, a arquitetura considera diversas fontes de informações presentes na organização, assim como a necessidade de se desenvolver algorítimos que implementem diferentes estratégias de atribuição. Nossa proposta de solução é embasada em resultados de duas pesquisas quantitativas: um estudo de mapeamento sistemático da literatura, e uma pesquisa de questionário com desenvolvedores de software. Esse último forneceu um conjunto de requisitos que a solução automatizada deve satisfazer para que as estratégias de atribuição sejam atendidas, enquanto o mapeamento da literatura identificou técnicas, algoritmos, e outros requisitos necessários a automação. A implementação da arquitetura segue uma estratégia de automação, definida nesse trabalho, que possui dois componentes principais: um sistema especialista baseado em regras (SEBR); e um modelo de recuperação de informação (MRI) com técnicas de aprendizagem. Em nossa estratégia, esses dois componentes são executados alternadamente em momentos diferentes a fim de atribuir uma SM automaticamente. O SEBR processa regras, considerando informações contextuais do projeto de software e da organização que o desenvolve. O MRI é utilizado para fazer o casamento entre SMs e desenvolvedores de acordo com o histórico de atribuições. Os resultados do estudo de validação apontaram que a solução é promissora. Isto é, ao compararmos nossa solução com uma abordagem que utiliza apenas um algoritmo de aprendizado de máquina, como o Support Vector Machine (SVM), pudemos melhorar em quase 50% a acurácia de atribuição. Já a análise de custo de implantação apontou que a acurácia atingida pela solução possui um bom custo benefício.

Submitted by Renata Lopes (renatasil82@gmail.com) on 2017-01-16T13:41:31Z No. of bitstreams: 1 marcosalexandremiguel.pdf: 10203756 bytes, checksum: 35844967ee919f58955320a1c591c5dc (MD5) / Approved for entry into archive by Diamantino Mayra (mayra.diamantino@ufjf.edu.br) on 2017-01-31T10:34:46Z (GMT) No. of bitstreams: 1 marcosalexandremiguel.pdf: 10203756 bytes, checksum: 35844967ee919f58955320a1c591c5dc (MD5) / Made available in DSpace on 2017-01-31T10:34:46Z (GMT). No. of bitstreams: 1 marcosalexandremiguel.pdf: 10203756 bytes, checksum: 35844967ee919f58955320a1c591c5dc (MD5) Previous issue date: 2016-09-01 / Muitas organizações encontram problemas na tentativa de estimar esforço em atividades de manutenção de software. Quando a estimativa de esforço não está bem definida ou é imprecisa, os resultados obtidos podem refletir diretamente na entrega do software, causando insatisfação do cliente ou diminuição da qualidade do produto. O sucesso ou fracasso de projetos depende da precisão do esforço e do cronograma das atividades envolvidas. O surgimento de métodos ágeis no campo de desenvolvimento de software tem apresentado muitas oportunidades e desafios para pesquisadores e profissionais da área. Um dos principais desafios é a estimativa de esforço para as atividades de manutenção no desenvolvimento ágil de software. Nesse contexto, este trabalho apresenta um framework, nomeado GiveMe Effort, o qual objetiva apoiar as atividades de estimativa de esforço na manutenção de software usando dados históricos e informações de compreensão de software. / Many organizations encounter problems when estimating effort for software maintenance activities. When estimating effort is not well defined or are inaccurate, the results may reflect directly into the software delivery, causing customer dissatisfaction or decreased product quality. The success or failure of projects depends on the accuracy of the effort and the schedule of involved activities. The rise of agile methods in software development has presented many opportunities and challenges for researchers and professionals. In this context, a key challenge is the effort estimate for maintenance activities in the agile software development context. This work presents a framework, called GiveMe Effort, to support the effort estimation activities in software maintenance. It is based on historical data and software comprehension information.

Submitted by Geandra Rodrigues (geandrar@gmail.com) on 2018-10-30T13:39:57Z No. of bitstreams: 1 helenodesouzacamposjunior.pdf: 1434985 bytes, checksum: 4307be9bfd2ca9825bcd2ce10bfc824e (MD5) / Approved for entry into archive by Adriana Oliveira (adriana.oliveira@ufjf.edu.br) on 2018-11-23T12:26:30Z (GMT) No. of bitstreams: 1 helenodesouzacamposjunior.pdf: 1434985 bytes, checksum: 4307be9bfd2ca9825bcd2ce10bfc824e (MD5) / Made available in DSpace on 2018-11-23T12:26:30Z (GMT). No. of bitstreams: 1 helenodesouzacamposjunior.pdf: 1434985 bytes, checksum: 4307be9bfd2ca9825bcd2ce10bfc824e (MD5) Previous issue date: 2018-09-19 / CAPES - Coordenação de Aperfeiçoamento de Pessoal de Nível Superior / Testes de regressão são executados após cada mudança no software. Em ambientes de desenvolvimento de software que adotam práticas da Engenharia de Software Contínua, como a Integração contínua, por exemplo, software é modificado, e testado diversas vezes em curtos prazos. Cada execução dos testes pode levar horas para terminar, gerando atraso em relação à descoberta de falhas no projeto. Para prevenir esse atraso, técnicas de otimização são utilizadas. Uma delas é a priorização de casos de testes (TCP). Nessa técnica, a execução dos testes é reordenada de acordo com um objetivo, que normalmente é a detecção de falhas. Dessa forma, testes que têm maior probabilidade de falhas são executados primeiro. Um problema com essa abordagem é que existem diversas técnicas na literatura, mas pouca evidência em relação ao seu uso. Além disso, quase não existe infra estrutura para apoiar a adoção dessas técnicas no contexto industrial. O objetivo deste trabalho é planejar e implementar um framework que permita o uso, experimentação e implementação de técnicas de TCP. Esperamos que isso ajude praticantes a adotar essas técnicas no contexto industrial, principalmente da engenharia de software continua. Esperamos também que a criação dessa infra estrutura ajude pesquisadores a executar mais estudos experimentais sobre a eficiência do uso dessas técnicas. Para mostrar a viabilidade do framework proposto, é executado um estudo experimental com 16 técnicas de priorização diferentes, executadas em um total de 22 versões de 2 projetos open source. Os resultados coletados sugerem que o uso das técnicas de priorização resultam em retornos mais rápidos em relação à existência de falhas nos projetos, possivelmente resultando em ciclos mais rápidos de desenvolvimento. / Regression tests are executed after every change in software. In a software development environment that adopts Continuous Software Engineering practices such as Continuous Integration, software is changed, built and tested many times in a short period. Each execution can take hours to finish, delaying feedback about failures to the developer. To prevent this, regression test optimization techniques are used. One such technique is test case prioritization (TCP), which reorder the execution of the test cases according to some goal. The most common goal is fault detection, in which test cases are ordered so that those that have higher probability of detecting faults are executed first. One problem with this approach is that there are lots of different available techniques in the literature, but the amount of evidence of its use is low. Furthermore, there is almost no infrastructure support to adopt those techniques at the industry context. The goal of this work is to design and implement a framework that allows the use, experimentation and implementation of TCP techniques. We hope that this will help practitioners on adopting these techniques at the industry context, more specifically, in the continuous software engineering environment. We also hope that creating this infrastructure will encourage researchers on performing more empirical studies regarding test case prioritization techniques effectiveness. In order to show the feasibility of the proposed framework, we perform an empirical study with 16 different TCP techniques executed on a total of 22 versions of 2 different open source projects. Results suggest that using those TCP techniques result in faster feedback about the existence of failures in the projects, possibly resulting in shorter development cycles.

Orientador: Cecília Mary Fischer Rubira / Tese (doutorado) ¿ Universidade Estadual de Campinas, Instituto de Computação / Made available in DSpace on 2018-08-21T03:56:22Z (GMT). No. of bitstreams: 1 Tizzei_LeonardoPondian_D.pdf: 4801081 bytes, checksum: 4be6c243f0c9f62c50e330561161fcdd (MD5) Previous issue date: 2012 / Resumo: Arquiteturas de linhas de produtos são essenciais para facilitar a evolução das linhas, pois ajudam a lidar com sua complexidade, abstraindo seus detalhes de implementação. A variabilidade arquitetural difere arquiteturas de linhas de produtos de arquiteturas de sistemas únicos. Ela reflete a existência de alternativas de projeto arquitetural e é expressa por meio de um conjunto de pontos de variação e variantes arquiteturais. A variabilidade arquitetural pode dificultar a evolução de arquiteturas de linhas produtos, pois a implementação da variabilidade software pode aumentar a complexidade da arquitetura com a possível adição de elementos e dependências extras. A variabilidade de linhas de produtos é usualmente capturada modelo de características e implementado pela arquitetura de linha de produtos. Entretanto, a implementação de características, pontos de variação e variantes podem estar espalhados por diversos elementos arquiteturais, o que dificulta a sua evolução. Em geral, cenários de evolução de linhas de produto envolvem adição e/ou remoção de características, mudança de uma característica obrigatória para opcional, entre outros. Quando cenários de evolução afetam características cujas implementações estão espalhadas na arquitetura, eles podem causar impacto de mudança em vários elementos arquiteturais. Estudos recentes exploram o uso de aspectos para modularizar a implementação de características em arquiteturas de linhas de produtos. Aspectos são usados para modularizar interesses transversais que, no contexto de linhas de produtos, são interesses que afetam diversas características. Contudo, esses estudos não consideram (i) arquiteturas componentizadas com interfaces explícitas e (ii) o uso integrado de componentes e aspectos para modularizar a implementação da variabilidade arquitetural. Idealmente aspectos devem ser modelados o mais cedo possível, de preferência, junto com o modelo de características para possibilitar a criação de arquiteturas bem estruturadas com aspectos. Todavia, não existem modelos que integrem o modelo de características e aspectos, nem métodos que consideram aspectos para gerar arquiteturas de linhas produtos a partir do modelo de características. A solução proposta nesta tese envolve inicialmente um estudo comparativo para mostrar a facilidade de evolução de arquiteturas de linhas de produtos propiciada pelo uso integrado de componentes e aspectos. Em seguida, é proposta uma visão estendida do modelo de características que permite representar características transversais. Essa visão, chamada de visão de características orientada a aspectos, é usada para criar arquiteturas de linhas de produtos orientadas a aspectos. Além disso, um modelo arquitetural de componentes é estendido para integrar aspectos para modularizar a variabilidade arquitetural. Por fim, o método FArM, que provê o mapeamento de modelo de características para modelos de arquitetura de linha de produtos, é estendido para considerar características transversais. Foram conduzidos dois estudos empíricos: um para avaliar se o uso integrado de componentes e aspectos facilita ou não a evolução de arquiteturas de linhas de produtos. O outro estudo empírico avalia a modelagem de características transversais e a extensão do método FArM propostos para projetar arquiteturas de linhas de produtos que sejam fáceis de evoluir. Os dois estudos apresentaram resultados promissores indicando que a solução proposta nesta tese facilita a evolução de arquiteturas de linhas de produtos / Abstract: Product line architectures are essential to facilitate the evolution of product lines, as they handle their complexity by abstracting implementation details. Architectural variability is what differs product line architectures from single system architectures. It reflects the existence of alternative design options and it is expressed by a set of architectural variation points and variants. Architectural variability can hinder product line architecture evolution because the implementation of software variability can increase architecture complexity by possibly adding extra elements and dependencies. Product line variability is usually captured in the feature model and it is implemented by product line architectures. However, the implementation of features, variation points, and variants may be scattered over architectural elements, which can hinder its evolution. In general, product line evolution scenarios involve feature addition/removal, changing a mandatory feature to an optional feature, and so forth. When evolution scenarios affect features whose implementations are scattered over architecture, they can cause a great change impact on several architectural elements. Recent studies have explored the use of aspects to modularize feature implementation in product line architectures. Aspects can modularize crosscutting concerns, which, in the context of product lines, are concerns that affect several features. Nevertheless, these studies do not consider (i) componentized architectures with explicit interfaces, and (ii) the integration of aspects and components to modularize the implementation of architectural variability. Ideally, aspects should be modeled as soon as possible, preferably, together with the feature model in order to enable the design of well structured product line architectures with aspects. However, there are neither models which integrate features and aspects, nor methods that considers aspects to design product line architectures from the feature model. The solution proposed in this thesis involves a comparative study that presents the support for product line architecture evolution provided by the integration of components and aspects. Then, it is proposed an extended view of the feature model which enables to represent crosscutting features. This view, called aspect-oriented feature view, is used to design product line architectures with aspects. Lastly, the FArM method, which provides guidelines to map from the feature model to the product line architecture model, is extended to consider crosscutting features. Two empirical studies were conducted: one to assess whether the integration of components and aspects facilitates product line architecture evolution. The other empirical study evaluates whether the crosscutting feature modeling and the FArM method extension proposed supports the design of evolvable product line architectures. Both studies presented promising results which indicate that the solution proposed in this thesis facilitates product line architecture evolution / Doutorado / Ciência da Computação / Doutor em Ciência da Computação

No description available.

Le contrôle de version est la pierre angulaire des processus de développement de logiciels modernes. Tout en construisant des logiciels de plus en plus complexes, les développeurs doivent comprendre des sous-systèmes de code source qui leur sont peu familier. Alors que la compréhension de la logique d'un code étranger est relativement simple, la compréhension de sa conception et de sa genèse est plus compliquée. Elle n'est souvent possible que par les descriptions des révisions et de la documentation du projet qui sont dispersées et peu fiables -- quand elles existent. Ainsi, les développeurs ont besoin d'une base de référence fiable et pertinente pour comprendre l'historique des projets logiciels. Dans cette thèse, nous faisons les premiers pas vers la compréhension des motifs de changement dans les historiques de révision. Nous étudions les changements prenant place dans les métriques logicielles durant l'évolution d'un projet. Au travers de multiples études exploratoires, nous réalisons des expériences quantitatives et qualitatives sur plusieurs jeux de données extraits à partir d'un ensemble de 13 projets. Nous extrayons les changements dans les métriques logicielles de chaque commit et construisons un jeu de donnée annoté manuellement comme vérité de base. Nous avons identifié plusieurs catégories en analysant ces changements. Un motif en particulier nommé "compromis", dans lequel certaines métriques peuvent s'améliorer au détriment d'autres, s'est avéré être un indicateur prometteur de changements liés à la conception -- dans certains cas, il laisse également entrevoir une intention de conception consciente de la part des auteurs des changements. Pour démontrer les observations de nos études exploratoires, nous construisons un modèle général pour identifier l'application d'un ensemble bien connu de principes de conception dans de nouveaux projets. Nos résultats suggèrent que les fluctuations de métriques ont le potentiel d'être des indicateurs pertinents pour gagner des aperçus macroscopiques sur l'évolution de la conception dans l'historique de développement d'un projet. / Version control is the backbone of the modern software development workflow. While building more and more complex systems, developers have to understand unfamiliar subsystems of source code. Understanding the logic of unfamiliar code is relatively straightforward. However, understanding its design and its genesis is often only possible through scattered and unreliable commit messages and project documentation -- when they exist. Thus, developers need a reliable and relevant baseline to understand the history of software projects. In this thesis, we take the first steps towards understanding change patterns in commit histories. We study the changes in software metrics through the evolution of projects. Through multiple exploratory studies, we conduct quantitative and qualitative experiments on several datasets extracted from a pool of 13 projects. We mine the changes in software metrics for each commit of the respective projects and manually build oracles to represent ground truth. We identified several categories by analyzing these changes. One pattern, in particular, dubbed "tradeoffs", where some metrics may improve at the expense of others, proved to be a promising indicator of design-related changes -- in some cases, also hinting at a conscious design intent from the authors of the changes. Demonstrating the findings of our exploratory studies, we build a general model to identify the application of a well-known set of design principles in new projects. Our overall results suggest that metric fluctuations have the potential to be relevant indicators for valuable macroscopic insights about the design evolution in a project's development history.

[pt] A refatoração de código é uma transformação de código que visa aprimorar a estrutura interna do código. Uma refatoração isolada raramente é suficiente para remover completamente uma estrutura de código ruim, como uma anomalia de código. Os desenvolvedores então aplicam refatorações compostas para remover totalmente uma anomalia de código. Uma refatoração composta consiste em duas ou mais refatorações inter-relacionadas. Um refatoração composta é considerada completa quando elimina totalmente a anomalia de código alvo. Estudos relatam que os desenvolvedores geralmente falham em remover completamente as anomalias de código alvo por meio de refatorações compostas. Refatorações compostas concluídas podem não ser totalmente benéficas para a estrutura do código. Pois, estas podem induzir efeitos colaterais, como a introdução de anomalias de código ou a propagação de anomalias existentes. Há uma compreensão limitada sobre a completude das refatorações compostas e seus possíveis efeitos colaterais. Esta tese investiga como as refatorações compostas removem totalmente as anomalias de código sem induzir efeitos colaterais. Descobrimos que 64 por cento das refatorações compostas completas são formadas por tipos de refatoração não recomendados anteriormente. Dessa forma, derivamos um catálogo de recomendações para apoiar os desenvolvedores na aplicação de refatorações compostas. Na avaliação do catálogo, 85 por cento de 21 desenvolvedores relataram que usariam as recomendações do catálogo e que suas próprias soluções de refatoração teriam induzido efeitos colaterais. Também avaliamos qualitativamente três abordagens existentes para recomendar automaticamente refatorações compostas. Nesse estudo, a maioria (80 por cento) dos 10 desenvolvedores relatou que as abordagens existentes frequentemente induzem efeitos colaterais. No geral, as descobertas e o catálogo proposto podem ajudar os desenvolvedores a realizar refatorações compostas completas. / [en] Code refactoring is a code transformation that aims to enhance the internal code structure. A single refactoring is rarely sufficient to achieve the full removal of a poor code structure, such as a code smell. Developers then apply composite refactorings to fully remove a code smell. A composite refactoring (or, simply, composite) consists of two or more interrelated single refactorings. A composite is considered complete when it fully eliminates the target smell. However, studies report that developers often fail in completely removing target code smells through composites. Even when composite refactorings are complete they may still not be entirely beneficial to the code structure. They may induce side effects, such as the introduction of new smells or the propagation of existing ones. There is a limited understanding of the completeness of composite refactorings and their possible effects on structural quality. This thesis investigates whether and how composite refactorings fully remove smells without inducing side effects. We found that 64 per cent of complete composites in several software projects are formed of refactoring types not previously recommended in the literature. Based on this study, we derived a catalog of recommendations for supporting developers in applying composite refactorings. Out of twenty one developers evaluating our catalog, 85 per cent reported that they would use the catalog recommendations and that their own refactoring solutions would have induced side effects. We also qualitatively evaluated three existing approaches to automatically recommend composite refactorings. In our study with ten developers, most (80 per cent) developers reported that existing approaches frequently induce side effects. Overall, the findings and the proposed catalog can help developers to perform complete composite refactorings with better awareness of possible side effects.

[ES] Vivimos en una sociedad donde la digitalización está presente en nuestro día a día. Nos despertamos con la alarma de nuestro teléfono móvil, apuntamos nuestras reuniones en nuestro calendario digital, guardamos nuestros archivos en el almacenamiento en la nube, y entramos a las redes sociales prácticamente a diario. Cada una de estas acciones se ejecuta sobre un sistema software que asegura su correcto funcionamiento. Esta digitalización masiva ha hecho que el desarrollo de software se dispare en los últimos años. Durante el ciclo de vida de un sistema software, la etapa de mantenimiento supone un gasto de billones de dólares anuales. La razón detrás de este gasto es la aparición de bugs o errores que no fueron detectados durante la fase de producción del software, y que se traducen en un mal funcionamiento del sistema. Por este motivo, las técnicas de detección y localización de errores como el testeo, la verificación o la depuración son un factor clave para asegurar la calidad del software. Aunque son muchas las técnicas que se utilizan para la depuración, testeo y verificación de sistemas software, esta tesis se centra solo en algunas de ellas. En concreto, esta tesis presenta mejoras en la técnica de fragmentación de programas (depuración), una nueva metodología para hacer testeo de regresión (testeo) y una nueva implementación del modelo de verificación de diseño-por-contrato para el lenguaje de programación Erlang (verificación). Las mejoras propuestas para la técnica de fragmentación de programas incluyen diversas propuestas aplicables a diferentes escenarios: (i) mejoras en la representación y fragmentación de programas orientados a objetos, (ii) mejoras en la representación y fragmentación de estructuras de datos complejas (objetos, vectores, listas, tuplas, registros, etc.), (iii) un nuevo modelo de grafo basado en una representación más detallada de programas, aumentando la expresividad del grafo y generando fragmentos de código más precisos como resultado, y (iv) una nueva técnica para calcular fragmentos mínimos de un programa dado un conjunto específico de posibles valores de entrada. Por otro lado, la nueva metodología para hacer testeo de regresión se denomina testeo de punto de interés, e introduce la posibilidad de comparar automáticamente el comportamiento de un punto cualquiera del código dadas dos versiones del mismo sistema software. Por último, la tesis contiene la nueva implementación del modelo de verificación de programas diseño-por-contrato para el lenguaje de programación Erlang, donde se explican en detalle los nuevos tipos de contratos diseñados para las partes secuencial y concurrente de Erlang. Todos los análisis presentados en esta tesis han sido formalmente definidos y su corrección ha sido probada, asegurando de esta manera que los resultados tendrán el grado de fiabilidad necesario para ser aplicados a sistemas reales. Otra contribución de esta tesis es la implementación de dos herramientas de fragmentación de programas para dos lenguajes de programación diferentes (Java y Erlang), una herramienta para realizar testeo de punto de interés para el lenguaje de programación Erlang y un sistema para ejecutar verificación de diseño-por-contrato en Erlang. Es de destacar que todas las herramientas implementadas a lo largo del desarrollo de esta tesis son herramientas de código abierto y públicamente accesibles, de manera que pueden ser usadas o extendidas por cualquier investigador interesado en este area. / [CA] Vivim en una societat on la digitalització està present al nostre dia a dia. Ens alcem amb l'alarma del nostre telèfon mòbil, apuntem les nostres reunions al nostre calendari digital, guardem els nostres arxius al emmagatzematge al núvol, i entrem a las xarxes socials pràcticament a diari. Cadascuna d'aquestes accions s'executa sobre un sistema programari que assegura el seu correcte funcionament. Aquesta digitalizació massiva ha fet que el desenvolupament de programari es dispare en els últims anys. Durant el cicle de vida de un sistema programari, l'etapa de manteniment suposa una despesa de bilions de dòlars anuals. La raó darrere d'aquesta despesa és l'aparició de bugs o errors que no van ser detectats durant la fase de producció del programari, i que es traduïxen en un mal funcionament del sistema Per este motiu, les tècniques de detecció i localització d'errors com el testeig, la verificació o la depuració són un factor clau per a assegurar la qualitat del programari. Encara que són moltes les tècniques utilitzades per a la depuració, testeig i verificació de sistemes programari, esta tesi es centra només en algunes d'elles. En concret, esta tesi presenta millores en la tècnica de fragmentació de programes (depuració), una nova metodologia per a fer testeig de regressió (testeig) i una nova implementació del model de verificació de disseny-per-contracte per al llenguatge de programació Erlang (verificació). Les millores proposades per a la tècnica de fragmentació de programes inclouen diverses propostes aplicables a diferents escenaris: (i) millores en la representació i fragmentació de programes orientats a objectes, (ii) millores en la representació i fragmentació d'estructures de dades complexes (objectes, vectors, llistes, tuples, registres, etc.), (iii) un nou model de graf basat en una representació més detallada de programes, augmentant l'expressivitat del graf i generant fragments de codi més precisos com a resultat, i (iv) una nova tècnica per a calcular fragments mínims d'un programa donat un conjunt específic de possibles valors d'entrada. D'altra banda, la nova metodologia per a fer testeig de regressió es denomina testeig de punt d'interés, i introduïx la possibilitat de comparar automàticament el comportament d'un punt qualsevol del codi donades dos versions del mateix sistema programari. Finalment, la tesi conté la nova implementació del model de verificació de programes disseny-per-contracte per al llenguatge de programació Erlang, on s'expliquen en detall els nous tipus de contractes dissenyats per a les parts seqüencial i concurrent d'Erlang. Totes les anàlisis presentades en aquesta tesi han sigut formalment definides i la seua correcció ha sigut provada, assegurant d'aquesta manera que els resultats tindran el grau de fiabilitat necessari per a ser aplicats a sistemes reals. Una altra contribució d'aquesta tesi és la implementació de dos ferramentes de fragmentació de programes per a dos llenguatges de programació diferents (Java i Erlang), una ferramenta per a realitzar testeig the punt d'interés per al llenguatge de programació Erlang i un sistema per a executar verificació de disseny-per-contracte a Erlang. Cal destacar que totes les ferramentes implementades al llarg del desenvolupament d'aquesta tesi són ferramentes de codi obert i públicament accessibles, de manera que poden ser usades o esteses per qualsevol investigador interessat en el tema. / [EN] We live in a society where digitalisation is present in our everyday life. We wake up with the alarm of our mobile phone, book our meetings in our digital calendar, save all our media in the cloud storage, and spend time in social networks almost daily. Every one of these tasks is run over a software system that ensures its correct functionality. This massive digitalisation has made software development to shoot up in the last years. During the lifetime of software systems, the maintenance process entails a waste of billions of dollars every year. The cause of this waste is the occurrence of bugs or errors undetected during the software production, which result in a malfunction of the system. For this reason, error detection and localisation techniques, such as testing, verification, or debugging, are a key factor to ensure software quality. Although many different techniques are used for the debugging, testing, and verification of software systems, this thesis focus on only some of them. In particular, this thesis presents improvements in the program slicing technique (debugging field), a new approach for regression testing (testing field), and a new implementation of the design-by-contract verification model for the Erlang programming language (verification field). The improvements proposed for the program slicing technique include several enhancements applicable to different scenarios: (i) improvements in the representation and slicing of object-oriented programs, (ii) enhancements in the representation and slicing of (possibly recursive) complex data structures (objects, arrays, lists, tuples, records, etc.), (iii) a new graph model based on a fine-grained representation of programs that augments the expressivity of the graph and provides more accurate slicing results, and (iv) a new technique to compute minimal slices for a program given a set of specific program inputs. On the other side, the new approach for regression testing is called point of interest testing, and it introduces the possibility of automatically comparing the behaviour of any arbitrary point in the code given two versions of the same software system. Finally, the thesis presents a new implementation of the design-by-contract verification model for the Erlang programming language, where new types of contracts are explained in detail for both the sequential and concurrent parts of Erlang. All the analyses presented here have been formally defined and their correctness have been proved, ensuring that the results will have the reliability degree needed for real-life systems. Another contribution of this thesis is the implementation of two program slicers for two different programming languages (Java and Erlang), a tool to perform point of interest testing for the Erlang programming language, and a system to run design-by-contract verification in Erlang. It is worth mentioning that all the tools implemented in this thesis are open source and publicly available, so they can be used or extended by any interested researcher. / Pérez Rubio, S. (2023). Analysis Techniques for Software Maintenance [Tesis doctoral]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/193146