No description available.

No description available.

[pt] Refatorar código-fonte consiste em aplicar transformações sobre a estrutura de código-fonte de projetos de software. Refatoração é bastante usada para remover estruturas pobres que dificultam a manutenção de sistemas de software. Poucas transformações isoladas são capazes de remover por completo estruturas pobres, mesmo as mais simples. Por exemplo, encurtar um método longo usualmente requer a extração de vários métodos. Até 60 por cento das transformações são inter-relacionadas e aplicadas em lotes, durante a dita refatoração em lote, ao invés de aplicadas isoladamente. Embora lotes serão frequentes na prática, o conhecimento sobre as características que constituem lotes está fragmentado na literatura. Qual o tamanho usual de lotes? As transformações internas a lotes costumam variar? Não há uma sumarização de conhecimento que responda tais questões. Ademais, são poucas as evidências sobre o efeito de lotes sobre a manutenção de sistemas. Lotes tendem a introduzir ou remover estruturas pobres, especialmente aquelas indicadas por anomalias de código-fonte? A resposta a perguntas como essa é insuficiente para apoiar a aplicação de lotes. Esta dissertação de mestrado apresenta dois estudos experimentais complementares visando resolver as limitações supracitadas. A dissertação começa com uma revisão da literatura sobre refatoração em lote baseada em 29 estudos. Nós identificamos sete características de lotes tais como o escopo de código-fonte afetado pela aplicação de um lote, mais sete tipos de efeito de lotes sobre a manutenção de sistemas, tais como a remoção de anomalias. As características e tipos de efeito identificadas foram sumarizadas por um mapa conceitual. A dissertação encerra-se com uma análise quantitativa de 57 projetos de sistemas abertos e fechados. Ao computar 4.607 lotes com uma heurística, nós descobrimos que a maioria dos lotes leva um único commit para ser aplicada (93 por cento) mas afeta mais do que um só método (90 por cento). Surpreendentemente, a maioria dos lotes introduz (51 por cento) ou não remove (38 por cento) anomalias. Revelamos também lotes até então desconhecidos mas capazes de remover por completo certas anomalias. Esta dissertação sugere trabalhos futuros com base em conflitos identificados na literatura quanto a características e tipos de efeito de lotes. / [en] Code refactoring means applying transformations on the code structure of a software project. Refactoring usually intends to remove poor code structures that harm the software maintenance. Each single transformation rarely suffices to fully remove poor code structures, even the simplest ones. For instance, shortening a long method often requires many method extractions. Up to 60 percent of the refactorings in software projects are constituted of a set of interrelated transformations, the so-called batches, rather than single transformations applied in isolation. Although batches are frequent in practice, the knowledge of batch characteristics is fragmented across studies. What is the usual size of batches? How do transformations vary within a batch? There is no summary that helps to address these questions. More critically, there is little empirical evidence of the batch effect on maintenance. Are batches more likely to introduce or remove poor code structures, especially those spotted by code smells? The current answer to questions like this is insufficient to support the batch application in practice. This Master s dissertation presents two complementary empirical studies that address both aforementioned literature gaps. The dissertation starts with a literature review of batch refactoring with 29 studies. We identified seven batch characteristics such as the scope in which batches are applied to code structures, plus seven types of batch effect on software maintenance, including code smell removal. All batch characteristics and types of effect were summarized in a conceptual map. The dissertation ends with the quantitative analysis of 57 open and closed software projects. From 4,607 heuristic-computed batches, we found that most batches occur entirely within one commit (93 percent) but affect more than just one method (90 percent). Surprisingly, batches mostly end up introducing (51 percent) or not removing (38 percent) code smells. Our results enabled us to reveal certain forms of batches, not documented by previous studies, that are useful to fully remove certain types of code smells.

Visualization of software systems is mainly used for understanding and modeling software architecture. Examples of what can be visualized are source code, systems during execution together with manipulated data or system architecture on either a detailed or a general level. The connection between all of these types of visualization is that they help computer engineers maintain or develop software systems. The largest challenge with visualizing software systems is when the systems in question are exceedingly large and containing an abundance of relations. A problem of this kind arise at the company DGC, where this study is performed. The company manages at present more than a couple hundred systems with over ten thousand relations between each other. The problem with the company’s existing visualization is that they are very difficult to follow and understand, since they mainly present raw data in the form of tables that do not show all relations optimally, and which can also easily distract the company stakeholders from their intended task. The aim of this study is to find a visualization method where a system and its underlying parts are shown together with their relations to other systems. The created visualization will be able to be used by several different stakeholders and will as clearly as possible present relevant information to them. Furthermore, it should also aim to contribute to a better understanding of the complex software systems and their relations. After the implementation of the chosen visualization method, a time-based study is performed to determine whether it poses an improvement of perception among the stakeholders or not. An interview is also conducted where these stakeholders provide their opinion on the created visualization and if they think it presents the necessary information in a pedagogical way. Analysis of the result of the timekeeping and the interview answers indicate that the aim of the study is met. The majority of the resulting times show that the created visualization is more efficient than the original ones, and the interview answers furthermore show how different stakeholders all together agree that the visualization can be used in both future development and maintenance. / Visualisering av mjukvarusystem används i stor utsträckning för att förstå och modellera mjukvaruarkitektur. Ett par exempel på vad som kan visualiseras är: källkod, system under exekvering tillsammans med manipulerat data eller systemarkitektur på detaljerad eller övergripande nivå. Sambandet mellan alla dessa typer av visualiseringar är att de hjälper dataingenjörer att underhålla och utveckla mjukvarusystem. Den största utmaningen i att visualisera mjukvarusystem är när systemen i fråga är väldigt stora och har många beroenden. Ett sådant problem uppstår på företaget DGC där denna undersökning utförs. Företaget hanterar i dagsläge mer än hundratals mjukvarusystem med över tiotusentals beroenden sinsemellan. Problemet med företagets befintliga visualiseringar är att dessa är väldigt svåra att följa eftersom de oftast presenterar rådata i form av tabeller som inte visar alla relationer på ett optimalt sätt och distraherar lätt intressenter på företaget från sin avsedda uppgift. Undersökningen syftar på att finna en visualiseringsmetod där ett system och dess underliggande systemdelar visas tillsammans med deras beroenden till andra. Den framtagna visualiseringen skall kunna användas av flera olika intressenter, och i högsta möjliga mån presentera relevant information för dem på ett tydligt sätt. Vidare ska den skapade visualiseringen också bidra till bättre förståelse för komplexa mjukvarusystem och deras beroenden. Efter framtagandet av visualiseringen utförs en tidsundersökning, för att avgöra huruvida den skapade visualiseringen stimulerar förståelse hos de olika intressenterna på företaget. Det utförs även en intervju där intressenterna på företaget lämnar sina synpunkter angående den skapade visualiseringen och om den kan presentera nödvändig information på ett pedagogiskt sätt. Analys av resultaten av tidtagningarna och svaren på intervjuerna visar tydligt att undersökningens syften nåtts. Majoriteten av tidtagningarna visade att den skapade visualiseringen är effektivare än de ursprungliga och intervjusvaren uppvisar hur olika intressenter ser att den kan användas vid vidareutvecklingen eller underhåll, vilket alla intressenter höll med om.

Les logiciels sont de plus en plus complexes et leur développement est souvent fait par des équipes dispersées et changeantes. Par ailleurs, de nos jours, la majorité des logiciels sont recyclés au lieu d’être développés à partir de zéro. La tâche de compréhension, inhérente aux tâches de maintenance, consiste à analyser plusieurs dimensions du logiciel en parallèle. La dimension temps intervient à deux niveaux dans le logiciel : il change durant son évolution et durant son exécution. Ces changements prennent un sens particulier quand ils sont analysés avec d’autres dimensions du logiciel. L’analyse de données multidimensionnelles est un problème difficile à résoudre. Cependant, certaines méthodes permettent de contourner cette difficulté. Ainsi, les approches semi-automatiques, comme la visualisation du logiciel, permettent à l’usager d’intervenir durant l’analyse pour explorer et guider la recherche d’informations. Dans une première étape de la thèse, nous appliquons des techniques de visualisation pour mieux comprendre la dynamique des logiciels pendant l’évolution et l’exécution. Les changements dans le temps sont représentés par des heat maps. Ainsi, nous utilisons la même représentation graphique pour visualiser les changements pendant l’évolution et ceux pendant l’exécution. Une autre catégorie d’approches, qui permettent de comprendre certains aspects dynamiques du logiciel, concerne l’utilisation d’heuristiques. Dans une seconde étape de la thèse, nous nous intéressons à l’identification des phases pendant l’évolution ou pendant l’exécution en utilisant la même approche. Dans ce contexte, la prémisse est qu’il existe une cohérence inhérente dans les évènements, qui permet d’isoler des sous-ensembles comme des phases. Cette hypothèse de cohérence est ensuite définie spécifiquement pour les évènements de changements de code (évolution) ou de changements d’état (exécution). L’objectif de la thèse est d’étudier l’unification de ces deux dimensions du temps que sont l’évolution et l’exécution. Ceci s’inscrit dans notre volonté de rapprocher les deux domaines de recherche qui s’intéressent à une même catégorie de problèmes, mais selon deux perspectives différentes. / Software systems are getting more and more complex and are developed by teams that are constantly changing and not necessarily working in the same location. Moreover, most software systems, nowadays, are recycled rather than being developed from scratch. A comprehension task is crucial when performing maintenance tasks; it consists of analyzing multiple software dimensions concurrently. Time is one of these dimensions, as software changes its state with time in two manners: during their execution and during their evolution. These changes make sense only when analyzed within the context of other software dimensions, such as structure or bug information. Multidimensional analysis is a difficult problem to solve. However, there are certain methods that bypass this difficulty, such as semi-automatic approaches. Software visualization is one of them, as it allows being part of the analysis by exploring and guiding information search. The first stage of the thesis consists of applying visualization techniques to better understand software dynamicity during execution and evolution. Changes over time are represented by heat maps. Hence, we utilize the same graphical representation to visualize both change types over time. Other approaches that permit the analysis of a program’s dynamic behavior over time involve the use of heuristics. In the thesis’ second stage, we are interested in the identification of the programs’ execution phases and evolution patterns using the same approach, i.e. search-based optimisation. In this context, the premise is the existence of internal cohesion between change events that allow the clustering in phases. This hypothesis of cohesion is defined specifically for change events in the code during software evolution and state changes during program execution. This thesis’ main objective is to study the unification of these two time dimensions, evolution and execution, in an attempt to bring together two research domains that work on the same set of problems, but from two different perspectives.

Two tasks that software engineers constantly perform are writing code that is easy to evolve and maintain, and detecting poorly written pieces of code. For the former, software engineers commonly rely on well-known software architecture styles, such as Model-View-Controller (MVC). To the latter, they rely on code metrics and code smell detection approaches. However, up to now, these code metrics and code smell approaches do not take into account underlying architectureall classes are assessed as if they were the same. In practice, software developers know that classes differ in terms of responsibilities and implementation, and thus, we expect these classes to present different levels of coupling, cohesion, and complexity. As an example, in an MVC system, Controllers are responsible for the flow between the Model and the View, and Models are responsible for representing the systems business concepts. Thus, in this thesis, we evaluate the impact of architectural roles within a system architecture on code metrics and code smells. We performed an empirical analysis in 120 open source systems, and interviewed and surveyed more than 50 software developers. Our findings show that each architectural role has a different code metric values distribution, which is a likely consequence of their specific responsibilities. Thus, we propose SATT, an approach that provides specific thresholds for architectural roles that are significantly different from others in terms of code smells. We also show that classes that play a specific architectural role contain specific code smells, which developers perceive as problems, and can impact class\' change- and defect-proneness. Based on our findings, we suggest that developers understand the responsibilities of each architectural role in their system architecture, so that code metrics and code smells techniques can provide more accurate feedback. / Duas tarefas que desenvolvedores de software constantemente fazem são escrever código fácil de ser mantido e evoluído, e detectar pedaços de código problemáticos. Para a primeira tarefa, desenvolvedores comumente fazem uso de conhecidos padrões arquiteturais, como Model-View-Controller (MVC). Para a segunda tarefa, desenvolvedores fazem uso de métricas de código e estratégias de detecção de maus cheiros de código (code smells). No entanto, até o momento, métricas de código e estratégias de detecção de maus cheiros de código não levam em conta a arquitetura do software em análise. Isso significa que todas classes são avaliadas como se umas fossem iguais às outras. Na prática, sabemos que classes são diferentes em suas responsibilidades e implementação, e portanto, esperamos que elas variem em termos de acoplamento, coesão e complexidade. Por exemplo, em um sistema MVC, Controladores são responsáveis pelo fluxo entre a camada de Modelo e a camada de Visão, e Modelos representam a visão de negócios do sistema. Nesta tese, nós avaliamos o impacto dos papéis arquiteturais em técnicas de medição de métricas de código e de detecção de maus cheiros de código. Nós realizamos um estudo empírico em 120 sistemas de código aberto, e entrevistamos e realizamos questionários com mais de 50 desenvolvedores. Nossos resultados mostram que cada papel arquitetural possui distribuições diferentes de valores de métrica de código, consequência das diferentes responsabilidades de cada papel. Como consequência, propomos SATT, uma abordagem que provê thresholds específicos para papéis arquiteturais que são significantemente diferentes de outros em termos de métricas de código. Mostramos também que classes que cumprem um papel arquitetural específico também contêm maus cheiros de código específicos. Esses maus cheiros são percebidos por desenvolvedores como problemas reais e podem fazer com que essas classes sejam mais modificadas e apresentem mais defeitos do que classes limpas. Sugerimos então que desenvolvedores entendam a arquitetura dos seus sistemas, bem como as responsabilidades de cada papel arquitetural que as classes desempenham, para que tanto métricas de código quanto estratégias de detecção de maus cheiros de código possam prover um melhor retorno.

Degradação do design é um problema central investigado na área de evolução de software. A densa rede de interdependências que emerge entre classes e módulos ao longo do tempo resulta em código difícil de mudar, não reutilizável e que não comunica por si só sua intenção. Dentre outros motivos, designs degradam porque requisitos mudam de maneiras não antecipadas pelo design inicial, ou seja, as modificações no código introduzem dependências novas e não planejadas entre classes e módulos do sistema. A gerência de dependências visa reduzir a degradação do design por meio de uma série de mecanismos que auxiliam na administração da complexidade estrutural inerente de sistemas orientados a objetos. Neste trabalho, investigamos as técnicas de identificação de dependências estruturais e lógicas. Em particular, por meio de um estudo de larga escala, comparamos os conjuntos desses dois tipos de dependências. Em seguida, conduzimos um estudo de caso a fim de identificar as origens de dependências lógicas. Por fim, fazemos um levantamento das técnicas de visualização de dependências e mostramos a ferramenta XFlow. / Design degradation is a central problem investigated in the area of software evolution. The dense web of interdependencies that emerges among classes and modules over time results in code that is hard to change, not reusable and that does not communicate its intention. Among other reasons, designs degrade because requirements changes in ways that were not anticipated by the initial design, i.e. the changes in code introduce new and unplanned dependencies among classes and modules of the system. Dependency management aims to reduce design degradation by means of a series of mechanisms that helps in the management of the inherent structural complexity of object oriented systems. In this work, we investigate structural and logical dependencies identification techniques. In particular, by means of a large scale study, we compare the sets of these two kinds of dependencies. Afterwards, we conduct a case study in order to uncover the origins of logical dependencies. Finally, we survey dependency visualization techniques and present the XFlow tool.

The constant modification of software during its life cycle poses many challenges for developers and testers because changes might not behave as expected or may introduce erroneous side effects. For those reasons, it is of critical importance to analyze, test, and validate software every time it changes. The most common method for validating modified software is regression testing, which identifies differences in the behavior of software caused by changes and determines the correctness of those differences. Most research to this date has focused on the efficiency of regression testing by selecting and prioritizing existing test cases affected by changes. However, little attention has been given to finding whether the test suite adequately tests the effects of changes (i.e., behavior differences in the modified software) and which of those effects are missed during testing. In practice, it is necessary to augment the test suite to exercise the untested effects. The thesis of this research is that the effects of changes on software behavior can be computed with enough precision to help testers analyze the consequences of changes and augment test suites effectively. To demonstrate this thesis, this dissertation uses novel insights to develop a fundamental understanding of how changes affect the behavior of software. Based on these foundations, the dissertation defines and studies new techniques that detect these effects in cost-effective ways. These techniques support test-suite augmentation by (1) identifying the effects of individual changes that should be tested, (2) identifying the combined effects of multiple changes that occur during testing, and (3) optimizing the computation of these effects.

Several attempts to facilitate understanding the behavior of software systems have been proposed. Perfective changes in well-established software systems are easier to perform when the development team has a solid understanding of the internals. However, it is reasonable to assume that the use of an open source system to incorporate new features and obtain a new software product is an appealing approach instead of coding a new product from scratch. Considering this scenario, and considering that it is not uncommon that systems are poorly documented, there is no widely accepted approach to guide the perfective maintenance for developers with low understanding of the system or that recovers high-level information about both the structure and the behavior of large systems. This work proposes a new approach to simplify comprehension tasks of object oriented programs through the analysis of summarized execution traces. The approach is perfomed on two techniques: The rst technique enables the separation of common parts of source code from specic parts related to important features that drive the addition of the new one. An evaluation is done to verify if the summarized execution traces helps the technique to locate potential elements of code that can guide the development of a new feature. The evaluation was conducted with real-world systems and with meaningful evolution tasks. The second is based on a technique that reconstructs structural and behavioral highlevel diagrams by the analysis of summarized execution traces. Precision and recall were evaluated using two third-party open-source systems, including the webserver Tomcat. The result suggests the feasibility for using the approach on real world large scale systems. / Várias abordagens para facilitar a compreensão do comportamento de sistemas de software têm sido propostas. Mudanças perfectivas em sistemas de software bem estabelecidos são mais fáceis de executar quando a equipe de desenvolvimento tem um entendimento sólido do código fonte. Mas é razoável assumir que o uso de um sistema de código aberto para incorporar novas características e obter um novo produto de software é uma abordagem interessante, ao invés de codificar um novo produto a partir do zero. Em consideração a este cenário e considerando que não é incomum sistemas pobres em documentação, não existe uma abordagem amplamente aceita para guiar em mudanças perfectivas desenvolvedores com baixo conhecimento do sistema ou que recupera informações em alto nível de abstração sobre a estrutura e comportamento de sistemas complexos. Este trabalho propõe uma nova abordagem para simplificar tarefas de compreensão de programas orientados a objetos através da análise de rastros de execução sumarizados. A abordagem é aplicada sobre duas técnicas: a primeira permite a separação de partes comuns do código fonte das partes específicas relacionadas a características importantes que conduz a adição de uma nova. Uma avaliação é feita para verificar se os rastros de execução sumarizados ajudam a técnica na localização de elementos potenciais de código que podem guiar o desenvolvimento de uma nova característica. A avaliação foi realizada com sistemas do mundo real e com tarefas de evolução significativas. A segunda é baseada na reconstrução de diagramas estruturais e comportamentais de alto nível baseada na análise de rastros de execução sumarizados. É apresentada uma avaliação do desempenho da abordagem em termos de precisão e recall em dois sistemas públicos de terceiros, dentre eles o servidor Web Tomcat. O resultado sugere a viabilidade da abordagem para uso em sistemas reais de larga escala. / Mestre em Ciência da Computação

Submitted by Johnny Rodrigues (johnnyrodrigues@ufcg.edu.br) on 2018-09-28T14:01:43Z No. of bitstreams: 1 DIEGO TAVARES CAVALCANTI - DISSERTAÇÃO PPGCC 2012..pdf: 11733349 bytes, checksum: 59909ce95d6ea71dea6e9686d3d20c33 (MD5) / Made available in DSpace on 2018-09-28T14:01:43Z (GMT). No. of bitstreams: 1 DIEGO TAVARES CAVALCANTI - DISSERTAÇÃO PPGCC 2012..pdf: 11733349 bytes, checksum: 59909ce95d6ea71dea6e9686d3d20c33 (MD5) Previous issue date: 2012-11-26 / Localizar e corrigir defeitos são tarefas comuns no processo de manutenção de software. Entretanto, a atividade de localizar entidades de código que são possivelmente defeituosas e que necessitam ser modificadas para a correção de um defeito, não é trivial. Geralmente, desenvolvedores realizam esta tarefa por meio de um processo manual de leitura e inspeção do código, bem como de informações cadastradas em relatórios de defeitos. De fato, é necessário que os desenvolvedores tenham um bom conhecimento da arquitetura e do design do software a fim de realizarem tal tarefa. Entretanto, este conhecimento fica espalhado por entre a equipe e requer tempo para ser adquirido por novatos. Assim, é necessário o desenvolvimento de técnicas que auxiliem na tarefa de análise de impacto de relatórios de defeitos no código, independente da experiência do desenvolvedor que irá executá-la. Neste trabalho, apresentamos resultados de um estudo empírico no qual avaliamos se a análise automática de vocabulários de relatórios de defeitos e de software pode ser útil na tarefa de localizar defeitos no código. Nele, analisamos similaridade de vocabulários como fator para sugerir classes que são prováveis de serem impactadas por um dado relatório de defeito. Realizamos uma avaliação com oito projetos maduros de código aberto, desenvolvidos em Java, que utilizam Bugzilla e JIRA como seus repositórios de defeitos. Nossos resultados indicam que a análise de ambos os vocabulários é, de fato, uma fonte valiosa de informação, que pode ser utilizada para agilizar a tarefa de localização de defeitos. Para todos os sistemas estudados, ao considerarmos apenas análise de vocabulário, vimos que, mesmo com um ranking contendo apenas 8% das classes de um projeto, foi possível encontrar classes relacionadas ao defeito buscado em até 75% dos casos. Portanto, podemos concluir que, mesmo que não possamos utilizar vocabulários de software e de relatórios de defeitos como únicas fontes de informação, eles certamente podem melhorar os resultados obtidos, ao serem combinados com técnicas complementares. / Locating and fixing bugs described in bug reports are routine tasks in software development processes. A major effort must be undertaken to successfully locate the (possibly faulty) entities in the code that must be worked on. Generally, developers map bug reports to code through manual reading and inspection of both bug reports and the code itself. In practice, they must rely on their knowledge about the software architecture and design to perform the mapping in an efficient and effective way. However, it is well known that architectural and design knowledge is spread out among developers. Hence, the success of such a task is directly depending on choosing the right developer. In this paper, we present results of an empirical study we performed to evaluate whether the automated analysis of bug reports and software vocabularies can be helpful in the task of locating bugs. We conducted our study on eight versions of six mature Java open-source projects that use Bugzilla and JIRA as bug tracking systems. In our study, we have used Information Retrieval techniques to assess the similarity of bug reports and code entities vocabularies. For each bug report, we ranked ali code entities according to the measured similarity. Our results indicate that vocabularies are indeed a valuable source of information that can be used to narrow down the bug-locating task. For ali the studied systems, considering vocabulary similarity only, a Top 8% list of entities has about 75% of the target entities. We conclude that while vocabularies cannot be the sole source of information, they can certainly improve results if combined with other techniques.