Les systèmes logiciels sont devenus de plus en plus répondus et importants dans notre société. Ainsi, il y a un besoin constant de logiciels de haute qualité. Pour améliorer la qualité de logiciels, l’une des techniques les plus utilisées est le refactoring qui sert à améliorer la structure d'un programme tout en préservant son comportement externe. Le refactoring promet, s'il est appliqué convenablement, à améliorer la compréhensibilité, la maintenabilité et l'extensibilité du logiciel tout en améliorant la productivité des programmeurs. En général, le refactoring pourra s’appliquer au niveau de spécification, conception ou code. Cette thèse porte sur l'automatisation de processus de recommandation de refactoring, au niveau code, s’appliquant en deux étapes principales: 1) la détection des fragments de code qui devraient être améliorés (e.g., les défauts de conception), et 2) l'identification des solutions de refactoring à appliquer. Pour la première étape, nous traduisons des régularités qui peuvent être trouvés dans des exemples de défauts de conception. Nous utilisons un algorithme génétique pour générer automatiquement des règles de détection à partir des exemples de défauts. Pour la deuxième étape, nous introduisons une approche se basant sur une recherche heuristique. Le processus consiste à trouver la séquence optimale d'opérations de refactoring permettant d'améliorer la qualité du logiciel en minimisant le nombre de défauts tout en priorisant les instances les plus critiques. De plus, nous explorons d'autres objectifs à optimiser: le nombre de changements requis pour appliquer la solution de refactoring, la préservation de la sémantique, et la consistance avec l’historique de changements. Ainsi, réduire le nombre de changements permets de garder autant que possible avec la conception initiale. La préservation de la sémantique assure que le programme restructuré est sémantiquement cohérent. De plus, nous utilisons l'historique de changement pour suggérer de nouveaux refactorings dans des contextes similaires. En outre, nous introduisons une approche multi-objective pour améliorer les attributs de qualité du logiciel (la flexibilité, la maintenabilité, etc.), fixer les « mauvaises » pratiques de conception (défauts de conception), tout en introduisant les « bonnes » pratiques de conception (patrons de conception). / Software systems have become prevalent and important in our society. There is a constant need for high-quality software. Hence, to improve software quality, one of the most-used techniques is the refactoring which improves design structure while preserving the external behavior. Refactoring has promised, if applied well, to improve software readability, maintainability and extendibility while increasing the speed at which programmers can write and maintain their code. In general, refactoring can be performed in various levels such as the requirement, design, or code level. In this thesis, we mainly focus on the source code level where automated refactoring recommendation can be performed through two main steps: 1) detection of code fragments that need to be improved/fixed (e.g., code-smells), and 2) identification of refactoring solutions to achieve this goal. For the code-smells identification step, we translate regularities that can be found in such code-smell examples into detection rules. To this end, we use genetic programming to automatically generate detection rules from examples of code-smells. For the refactoring identification step, a search-based approach is used. The process aims at finding the optimal sequence of refactoring operations that improve software quality by minimizing the number of detected code-smells while prioritizing the most critical ones. In addition, we explore other objectives to optimize using a multi-objective approach: the code changes needed to apply refactorings, semantics preservation, and the consistency with development change history. Hence, reducing code changes allows us to keep as much as possible the initial design. On the other hand, semantics preservation insures that the refactored program is semantically coherent, and that it models correctly the domain-semantics. Indeed, we use knowledge from historical code change to suggest new refactorings in similar contexts. Furthermore, we introduce a novel multi-objective approach to improve software quality attributes (i.e., flexibility, maintainability, etc.), fix “bad” design practices (i.e., code-smells) while promoting “good” design practices (i.e., design patterns).

Bons códigos importam, mas como saber quando a qualidade está baixa? Maus cheiros de código, ou anomalias, auxiliam desenvolvedores na identificação de trechos de código problemáticos, porém a maioria dos maus cheiros catalogados são voltados para práticas e tecnologias tradicionais, criadas entre as décadas de 70 a 90, como orientação a objetos e Java. Ainda há dúvidas sobre maus cheiros em tecnologias que surgiram na última década, como o Android, principal plataforma móvel em 2017 com mais de 86% de participação de mercado. Alguns pesquisadores derivaram maus cheiros Android relacionados à eficiência e à usabilidade. Outros notaram que maus cheiros específicos ao Android são muito mais frequentes nos aplicativos do que maus cheiros tradicionais. Diversas pesquisas concluíram que os componentes Android mais afetados por maus cheiros tradicionais são Activities e Adapters, que pertencem à camada de apresentação. Notou-se também que em alguns aplicativos, códigos da camada de apresentação representam a maior parte do código do projeto. Vale ressaltar que a camada de apresentação Android também é composta por arquivos XML, chamados de recursos, usados na construção da interface do usuário (User Interface - UI), porém nenhuma das pesquisas citadas os considerou em suas análises. Nesta dissertação, investigamos a existência de maus cheiros relacionados à camada de apresentação Android considerando inclusive os recursos. Fizemos isso através de dois questionários e um experimento de código online, totalizando a participação de 316 desenvolvedores. Nossos resultados mostram a existência de uma percepção comum entre desenvolvedores sobre más práticas no desenvolvimento da camada de apresentação Android. Nossas principais contribuições são um catálogo com 20 maus cheiros da camada de apresentação Android e uma análise estatística da percepção de desenvolvedores sobre os 7 principais maus cheiros catalogados. Nossas contribuições servirão a pesquisadores como ponto de partida para a definição de heurísticas e implementação de ferramentas automatizadas e a desenvolvedores como auxílio na identificação de códigos problemáticos, ainda que de forma manual. / We are aware that good code matters, but how to know when quality is low? Code smells, or anomalies, help us identify problematic code snippets, but most of the code smells cataloged are based on traditional practices and technologies, created from the 70s through the 90s, such as object oriented programming and Java. There are still doubts about code smells in technologies that have emerged in the last decade, such as Android, the main mobile platform in 2017 with more than 86% market share. Some researchers have defined code smells related to Android efficiency and usability. Other research concludes that the components most affected by traditional code smells are related to the front-end components, such as Activities and Adapters. Also noticed in some applications, front-end code represent the larger part of the projects code. It is worth mentioning that the Android presentation layer is also composed of XML files, called resources, used to build the user interface (UI), but none of the cited research considered them in their analyzes. In this dissertation, we investigate the existence of code smells related to the Android front-end, including application resources. We performed two online surveys and one online code experiment, summing 316 developers. Our results show that there is a common perception among Android developers about bad practices on Android front-end. Our main contributions are a catalog of 20 code smells related to the Android front-end and a statistical analysis of the perceptions of developers about the 7 main code smells cataloged. Our contributions will provide to researchers a starting point for the definition of heuristics and implementation of automated tools and to developers as an aid in identifying problematic codes.

Bons códigos importam, mas como saber quando a qualidade está baixa? Maus cheiros de código, ou anomalias, auxiliam desenvolvedores na identificação de trechos de código problemáticos, porém a maioria dos maus cheiros catalogados são voltados para práticas e tecnologias tradicionais, criadas entre as décadas de 70 a 90, como orientação a objetos e Java. Ainda há dúvidas sobre maus cheiros em tecnologias que surgiram na última década, como o Android, principal plataforma móvel em 2017 com mais de 86% de participação de mercado. Alguns pesquisadores derivaram maus cheiros Android relacionados à eficiência e à usabilidade. Outros notaram que maus cheiros específicos ao Android são muito mais frequentes nos aplicativos do que maus cheiros tradicionais. Diversas pesquisas concluíram que os componentes Android mais afetados por maus cheiros tradicionais são Activities e Adapters, que pertencem à camada de apresentação. Notou-se também que em alguns aplicativos, códigos da camada de apresentação representam a maior parte do código do projeto. Vale ressaltar que a camada de apresentação Android também é composta por arquivos XML, chamados de recursos, usados na construção da interface do usuário (User Interface - UI), porém nenhuma das pesquisas citadas os considerou em suas análises. Nesta dissertação, investigamos a existência de maus cheiros relacionados à camada de apresentação Android considerando inclusive os recursos. Fizemos isso através de dois questionários e um experimento de código online, totalizando a participação de 316 desenvolvedores. Nossos resultados mostram a existência de uma percepção comum entre desenvolvedores sobre más práticas no desenvolvimento da camada de apresentação Android. Nossas principais contribuições são um catálogo com 20 maus cheiros da camada de apresentação Android e uma análise estatística da percepção de desenvolvedores sobre os 7 principais maus cheiros catalogados. Nossas contribuições servirão a pesquisadores como ponto de partida para a definição de heurísticas e implementação de ferramentas automatizadas e a desenvolvedores como auxílio na identificação de códigos problemáticos, ainda que de forma manual. / We are aware that good code matters, but how to know when quality is low? Code smells, or anomalies, help us identify problematic code snippets, but most of the code smells cataloged are based on traditional practices and technologies, created from the 70s through the 90s, such as object oriented programming and Java. There are still doubts about code smells in technologies that have emerged in the last decade, such as Android, the main mobile platform in 2017 with more than 86% market share. Some researchers have defined code smells related to Android efficiency and usability. Other research concludes that the components most affected by traditional code smells are related to the front-end components, such as Activities and Adapters. Also noticed in some applications, front-end code represent the larger part of the projects code. It is worth mentioning that the Android presentation layer is also composed of XML files, called resources, used to build the user interface (UI), but none of the cited research considered them in their analyzes. In this dissertation, we investigate the existence of code smells related to the Android front-end, including application resources. We performed two online surveys and one online code experiment, summing 316 developers. Our results show that there is a common perception among Android developers about bad practices on Android front-end. Our main contributions are a catalog of 20 code smells related to the Android front-end and a statistical analysis of the perceptions of developers about the 7 main code smells cataloged. Our contributions will provide to researchers a starting point for the definition of heuristics and implementation of automated tools and to developers as an aid in identifying problematic codes.

Technical debt is used to describe the changing or to maintain a system due to expedient shortcuts done during its development. In the context of the software development industry, technical debt is regarded as a critical issue in terms of the negative consequences such as increased software development cost, low product quality, decreased maintainability, and slowed progress to the long-term success of developing software. Code Smells are well informed in the domain of Technical Debt. They indicate to the common bad practices that may impair the future quality of the software system. By identifying those Code Smells, it is possible to give an improved solution or make the developers aware of a possible deficiency. I explore the premise that technical debt within the enterprise should be viewed as a tool. Extensible and Appropriate tools can check the Code Smells automatically and improve the quality assessment accordingly. However, in the field of Enterprise Architecture(EA), common bad habits in EA can be called EA Smells. EA Smells itself can be a component of EA Debt. Enterprise Architecture Debt can be defined as such a metric that depicts the deviation of the currently present state of an enterprise from a hypothetical ideal state.In this thesis, we introduce SmellCull as an extensible tool for capturing, tracking and managing Enterprise Architecture debt in the EA field. SmellCull allows measuring different kinds of Enterprise Architecture debts for EA Model. SmellCull is extensible since different types of Model can be integrated as input into the tool environment and provides developers with a lightweight tool to capture EA debt and make it easier to understand them indicating corresponding parts in the implementation. The tool is used to create propagation paths for the EA debt. This allows for an up-to-date and accurate presentation of EA debt to be upheld, which enables developer conducted implementation-level micromanagement as well as higher-level debt management.Since the tool is sophisticated enough, automated detection supports the design process and ongoing change of EAS(Enterprise Architecture System). This includes the strategic development of EAS with the corresponding roadmaps, as well as design assurance and performance monitoring to assess the quality of data in EA repositories and the compliance with certain standards defined by EA Smells. Due to the limited scope of master thesis, the tool will identify a few number of EA debt. At the end, some future work suggestions in the context of identifying more salable Enterprise Architecture Debts with this tool are given. / Teknisk skuld dvs dålig eller kortsiktig programutveckling som belastning på IT-system måste förr eller senare återbetalas. I industrin betraktas teknisk skuld som en kritisk fråga när det gäller de negativa konsekvenserna som ökad mjukvaruutvecklingskostnad, låg produktkvalitet, minska underhåll och långsammare framsteg till den långsiktiga framgången med att utveckla programvara. Dålig kodkvalitet “code smell” är vanligt förekommande teknisk skuld. Det uppkommer i vanliga dåliga metoder “anti-patterns” som försämrar programvarans framtida kvalitet. För att kunna identifiera bristande kodkvalitet är det möjligt att skapa en förbättrad lösning eller göra utvecklare medvetna om de möjliga bristerna. Jag undersöker förutsättningarna att en sådan teknisk skuld i företag bör undersökas med en programvara. Utbyggbara och ändamålsenliga programvaror kan analysera källkod och hitta var kvaliteten behöver förbättras. Företagens tekniska skuld kan definieras som ett mått som visar avvikelsen från ett hypotetiskt idealtillstånd genom att jämföra det aktuella tillståndet med praktiska rekommendationer “best practice”. I detta examensarbete introducerar jag SmellCull som ett utbyggbart verktyg för att hitta, spåra och hantera bristfällig kodkvalitet inom företagsarkitektur (EA). SmellCull tillåter mätning av olika typer av tekiska skulder för EA modellen. SmellCull är utbyggbart genom att olika typer av datamodeller kan integreras som indata i miljön, och det ger utveck-lare ett lätt verktyg för att hantera teknisk skuld i programmeringsprojekt och hjälpa projektdeltagarna i programmeringsprojekt att förstå vad orsakar brister i kodkvalitet.  Eftersom verktyget är tillräckligt sofistikerat finns det automatiserad spårning, designprocess och kontinuerlig förbättring av EAS (Enterprise Architecture System). Detta inkluderar strategisk utveckling av EAS med motsvarande färdplan, samt konstruktionssäkerhet och prestandäovervakning för att bedöma kvaliteten på data i EA förvar och efterlevnaden av vissa standarder som definieras av EA code smell detection. På grund av den begränsade omfattningen av examensarbetet kommer verktyget att  identifiera några få EA skuld. I slutet, några framtida arbetsförslag i samband med identifiering mer säljbara företagsarkitekturskulder med detta verktyg ges.

Refactoring wird angewandt, wenn eine Software-Inspektion Defekte im Programmcode feststellt. Code-Smells sind Beispiele solcher Defekte im Programmcode. Clean-Code ist ein neuerer Ansatz, der genauso wie das Code-Smell-Konzept festlegt, wann Defekte im Programmcode vorliegen. Für Code-Smells gibt es bereits zahlreiche Code-Analyse-Tools, die die automatische Erkennung solcher Defekte ermöglicht. Die vorliegende Arbeit implementiert ein Clean-Code-Analyse-Tool für Programmcode mithilfe von statischer Code-Analyse, das Refactoring-Hinweise ausgibt. Für diesen Zweck werden ein Lexer und ein Parser zur syntaktischen Analyse eines Subsets der Programmiersprache C++ implementiert. Die Evaluation durch quantitative Datenanalyse zeigt, wie nützlich die automatische Erkennung von Clean-Code mithilfe eines statischen Code-Analyse-Tools bei der Erstellung von Programmcode mit höherer Lesbarkeit für Entwicklerinnen und Entwickler ist.:Inhaltsverzeichnis 6 Abbildungsverzeichnis 9 Tabellenverzeichnis 10 Akronyme 13 1. Einleitung 14 2. Theoretische Grundlagen 17 2.1. Wichtige Begriffe und Definitionen 17 2.1.1. Software-Inspektion 17 2.1.2. Fagan-Inspektion 18 2.1.3. Checklistenbasiertes Code-Review 19 2.1.4. Statische vs. dynamische Code-Analyse-Tools 21 2.1.5. Refactoring 24 2.1.6. Code-Smells 24 2.1.7. Clean-Code 25 2.2. Code-Smell-Heuristiken im Detail 27 2.3. Einführung in den Compilerbau 32 2.3.1. Kurze Einführung in die Sprachtheorie 32 2.3.2. Die lexikalische Analyse 34 2.3.3. Die syntaktische Analyse 35 3. Forschungsstand 38 3.1. Code-Smell-Analyse-Tools auf Grundlage von Strukturinformationen 42 3.2. Code-Smell-Analyse durch maschinelles Lernen 50 3.3. Code-Smell-Suche mithilfe von Änderungsdaten 52 3.4. Code-Smell-Erkennung durch Textanalyse 54 4. Forschungsfragen und Konzeptentwicklung 56 4.1. Clean-Code: Welche Teile sind messbar? - Die Konzeptionalisierung hin zu einem maschinenlesbaren Ansatz 56 4.1.1. Größe von Entitäten im Clean-Code 57 4.1.2. Clean-Code und Zugriffsmodifikatoren 59 4.1.3. Bezeichner von Entitäten im Clean-Code 60 4.1.4. Formatierungskonventionen des Clean-Codes 62 4.1.5. Funktionsparameterübergabe im Clean-Code-Konzept 63 4.1.6. Clean-Code-Kommentare 65 4.1.7. Clean-Code — Was nicht geht 66 4.1.8. Platzierung von Entitäten im Clean-Code 67 4.2. Forschungsfragen und Hypothesen 69 5. Methodik 71 5.1. Implementierung des statischen Clean-Code-Analyse-Tools 71 5.1.1. Abhängigkeiten 72 5.1.2. Umsetzung des statischen Clean-Code-Analyse-Tools 72 5.1.3. Abhängige Variablen 78 5.2. Checklistenbasiertes Code-Review 80 5.2.1. Begründung der Methodenauswahl 80 5.2.2. Fragebogen 81 5.2.3. Unabhängige Variablen 85 5.2.4. Ablauf der Studie 86 6. Ergebnisse 87 6.1. Populationsbeschreibung 88 6.2. Deskriptive Werte der Evaluationsitems aus der Lesbarkeitsstudie 88 6.3. Deskriptive Werte der Evaluation des statischen Clean-Code-Analyse-Tools 90 6.4. Inferenzstatistik 91 7. Diskussion 96 7.1. Beantwortung der Forschungsfrage 96 7.2. Bedrohungen der Validität 97 7.3. Ausblick und Vergleich mit ähnlichen Code-Analyse-Tools 98 8. Fazit 100 Literaturverzeichnis 102 A. Anhang 112 A.1. Tabellen 112 A.2. Clean-Code Analyse-Tool Ein- und Ausgabe 124 A.3. Lesbarkeitsstudie 135 A.4. Regressionsergebnisse 144 B. CD 148 C. Selbstständigkeitserklärung 148

A common challenge in organizations is a perception of that different languages are spoken among IT and other departments. Co-workers come from different background, have different knowledge base and sometimes even different objectives which can make an alignment more challenging. Enterprise Architecture (EA) can align IT investments with business directions and potentially solve issues regarding business-IT misalignments and bring value to organizations. Technical Debt (TD) is a well-established concept in software development and means that a solution that is “quick and dirty” is applied in order to earn time in short term and be able to provide a function in a system more quickly. This primitive implementation will at a later stage need to be corrected and rewritten, and the longer it takes, the more advanced, complex and time-consuming the correction will be. As EA has grown, major scientific and academic contributions have been developed. What is still missing is insight and ability to include a debt concept, which not only address TD but also business aspects. By adapting the TD concept in the EA domain, a new metaphor, providing a holistic perspective, has been proposed; Enterprise Architecture Debt (EAD). Up to the present debts for measuring EAD has been identified, but current research projects has not yet identified when a certain measure is to be considered of high or low quality. There is a need to develop a process for deriving such thresholds and identifying them. To be able to communicate the severity of an EAD to stakeholders, thresholds for EAD measures plays an important role. These thresholds will in the long term play a role in providing a tool for computer scientist working in organizations exploiting EA, and also contribute to current research within the field of IT-management and EA. By adopting a systematic process for defining expert driven thresholds a first version of a process for defining EAD thresholds could be presented and tested with domain experts. Five common opinions were detected, regarding the process, among the experts. The process could potentially facilitate useful communication and it was considered positive that it highlighted the context of the EAD. Also, that clearer process description and real-world EA model examples was needed, and that the moment of selecting membership function was unnecessary came up. Further, drivers for EAD thresholds and areas where it is perceived as important to have thresholds for EADs was a focus during the study. Cost and time, responsibility and engagement and context are perceived to be important drivers for EAD thresholds. While the business-it alignment and master data are seen as important areas. Also, context can play an important role when determine important areas. / En vanlig utmaning inom organisationer är uppfattningen av att olika språka talas på IT-avdelningen och övriga avdelningar. Medarbetare kommer från olika bakgrund, har olika kunskapsbas och ibland till och med olika mål, vilket kan göra fastställandet av riktning mer utmanande. Enterprise Architecture (EA) kan säkerställa att IT investeringar och affärs direktiv går i samma riktning och kan därmed potentiellt lösa problem i anslutning till IT och övrig affärsverksamhet som uppstått på grund av detta och skapa värde till organisationen. Teknisk skuld är ett väletablerat koncept inom mjukvaruutveckling och syftar till att enlösning som är ”quick and dirty” tillämpas för att vinna tid på kort sikt och kunna tillämpa en funktionalitet i ett system snabbare. Denna primitiva implementation kommer vid senare tillfälle behöva korrigeras och skrivas om. Ju längre tid det tar desto mer avancerad, komplex och tidskrävande kommer ändringen att bli. I takt med att EA har vuxit har stora vetenskapliga och akademiska bidrag utvecklats. Vad som fortfarande saknas är insikt och förmåga att inkludera ett skuldkoncept som inte bara adresserar tekniks skuld utan även affärsaspekter. Genom att introducera konceptet teknisk skult i EA domänen har en ny metafor, som tillhandahåller ett helhetsperspektiv, föreslagits; Enterprise Architecture Debt (EA Debt). Fram tills idag har skulder för att mäta EA Debt blivit identifierade, men aktuella forskningsprojekt har ännu inte identifierat när en viss EA Debt är hög eller låg. Det finns ett behov av att utveckla en process för att härleda sådana gränsvärden och identifiera dem. För att kunna kommunicera all varlighetsgraden för en EA Debt till intressenter kan gränsvärden för EA Debt spela en viktig roll. Dessa gränsvärden kommer på lång sikt spela en roll när det kommer till att tillhandahålla verktyg för datavetare som arbetar i organisationer som tillämpar EA, och också bidra till aktuell forskning inom IT-förvaltning och EA. Genom att anta en systematisk process för att definiera expertdrivna gränsvärden har en första version av en process för att definiera EA Debt-gränsvärden kunnat presenteras och testas med domän-experter. Fem vanliga uppfattningar, gällande processen, kunde uppräckas bland experterna. Processens skulle också potentiellt kunna främja användbar kommunikation och det ansågs positivt att den belysta och tog hänsyn till kontext gällande EA Debt. Att tydligare processbeskrivning och verklighetstrogna EA-modeller som exempel behövdes samt att momentet där medlemsfunktion skulle väljas var onödigt kom också upp. Vidare så fokuserade studien på drivkrafter för att ta fram gränsvärden för EA Debt och områden där uppfattningen är att detta är viktigt. Kostnad och tid, ansvar och engagemang och kontext är uppfattade som viktiga drivkrafter när det kommer till gränsvärden för EA skuld, medan inriktningen för IT och övrig affärsverksamhet och basdata ses som viktiga områden. Även kontexten kan ha en viktig roll när det kommer till att avgöra vilka områden som är viktiga.

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.

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.

Les changements sont faits de façon continue dans le code source des logiciels pour prendre en compte les besoins des clients et corriger les fautes. Les changements continus peuvent conduire aux défauts de code et de conception. Les défauts de conception sont des mauvaises solutions à des problèmes récurrents de conception ou d’implémentation, généralement dans le développement orienté objet. Au cours des activités de compréhension et de changement et en raison du temps d’accès au marché, du manque de compréhension, et de leur expérience, les développeurs ne peuvent pas toujours suivre les normes de conception et les techniques de codage comme les patrons de conception. Par conséquent, ils introduisent des défauts de conception dans leurs systèmes. Dans la littérature, plusieurs auteurs ont fait valoir que les défauts de conception rendent les systèmes orientés objet plus difficile à comprendre, plus sujets aux fautes, et plus difficiles à changer que les systèmes sans les défauts de conception. Pourtant, seulement quelques-uns de ces auteurs ont fait une étude empirique sur l’impact des défauts de conception sur la compréhension et aucun d’entre eux n’a étudié l’impact des défauts de conception sur l’effort des développeurs pour corriger les fautes. Dans cette thèse, nous proposons trois principales contributions. La première contribution est une étude empirique pour apporter des preuves de l’impact des défauts de conception sur la compréhension et le changement. Nous concevons et effectuons deux expériences avec 59 sujets, afin d’évaluer l’impact de la composition de deux occurrences de Blob ou deux occurrences de spaghetti code sur la performance des développeurs effectuant des tâches de compréhension et de changement. Nous mesurons la performance des développeurs en utilisant: (1) l’indice de charge de travail de la NASA pour leurs efforts, (2) le temps qu’ils ont passé dans l’accomplissement de leurs tâches, et (3) les pourcentages de bonnes réponses. Les résultats des deux expériences ont montré que deux occurrences de Blob ou de spaghetti code sont un obstacle significatif pour la performance des développeurs lors de tâches de compréhension et de changement. Les résultats obtenus justifient les recherches antérieures sur la spécification et la détection des défauts de conception. Les équipes de développement de logiciels doivent mettre en garde les développeurs contre le nombre élevé d’occurrences de défauts de conception et recommander des refactorisations à chaque étape du processus de développement pour supprimer ces défauts de conception quand c’est possible. Dans la deuxième contribution, nous étudions la relation entre les défauts de conception et les fautes. Nous étudions l’impact de la présence des défauts de conception sur l’effort nécessaire pour corriger les fautes. Nous mesurons l’effort pour corriger les fautes à l’aide de trois indicateurs: (1) la durée de la période de correction, (2) le nombre de champs et méthodes touchés par la correction des fautes et (3) l’entropie des corrections de fautes dans le code-source. Nous menons une étude empirique avec 12 défauts de conception détectés dans 54 versions de quatre systèmes: ArgoUML, Eclipse, Mylyn, et Rhino. Nos résultats ont montré que la durée de la période de correction est plus longue pour les fautes impliquant des classes avec des défauts de conception. En outre, la correction des fautes dans les classes avec des défauts de conception fait changer plus de fichiers, plus les champs et des méthodes. Nous avons également observé que, après la correction d’une faute, le nombre d’occurrences de défauts de conception dans les classes impliquées dans la correction de la faute diminue. Comprendre l’impact des défauts de conception sur l’effort des développeurs pour corriger les fautes est important afin d’aider les équipes de développement pour mieux évaluer et prévoir l’impact de leurs décisions de conception et donc canaliser leurs efforts pour améliorer la qualité de leurs systèmes. Les équipes de développement doivent contrôler et supprimer les défauts de conception de leurs systèmes car ils sont susceptibles d’augmenter les efforts de changement. La troisième contribution concerne la détection des défauts de conception. Pendant les activités de maintenance, il est important de disposer d’un outil capable de détecter les défauts de conception de façon incrémentale et itérative. Ce processus de détection incrémentale et itérative pourrait réduire les coûts, les efforts et les ressources en permettant aux praticiens d’identifier et de prendre en compte les occurrences de défauts de conception comme ils les trouvent lors de la compréhension et des changements. Les chercheurs ont proposé des approches pour détecter les occurrences de défauts de conception, mais ces approches ont actuellement quatre limites: (1) elles nécessitent une connaissance approfondie des défauts de conception, (2) elles ont une précision et un rappel limités, (3) elles ne sont pas itératives et incrémentales et (4) elles ne peuvent pas être appliquées sur des sous-ensembles de systèmes. Pour surmonter ces limitations, nous introduisons SMURF, une nouvelle approche pour détecter les défauts de conception, basé sur une technique d’apprentissage automatique — machines à vecteur de support — et prenant en compte les retours des praticiens. Grâce à une étude empirique portant sur trois systèmes et quatre défauts de conception, nous avons montré que la précision et le rappel de SMURF sont supérieurs à ceux de DETEX et BDTEX lors de la détection des occurrences de défauts de conception. Nous avons également montré que SMURF peut être appliqué à la fois dans les configurations intra-système et inter-système. Enfin, nous avons montré que la précision et le rappel de SMURF sont améliorés quand on prend en compte les retours des praticiens. / Changes are continuously made in the source code to take into account the needs of the customers and fix the faults. Continuous change can lead to antipatterns and code smells, collectively called “design smells” to occur in the source code. Design smells are poor solutions to recurring design or implementation problems, typically in object-oriented development. During comprehension and changes activities and due to the time-to-market, lack of understanding, and the developers’ experience, developers cannot always follow standard designing and coding techniques, i.e., design patterns. Consequently, they introduce design smells in their systems. In the literature, several authors claimed that design smells make object-oriented software systems more difficult to understand, more fault-prone, and harder to change than systems without such design smells. Yet, few of these authors empirically investigate the impact of design smells on software understandability and none of them authors studied the impact of design smells on developers’ effort. In this thesis, we propose three principal contributions. The first contribution is an empirical study to bring evidence of the impact of design smells on comprehension and change. We design and conduct two experiments with 59 subjects, to assess the impact of the composition of two Blob or two Spaghetti Code on the performance of developers performing comprehension and change tasks. We measure developers’ performance using: (1) the NASA task load index for their effort; (2) the time that they spent performing their tasks; and, (3) their percentages of correct answers. The results of the two experiments showed that two occurrences of Blob or Spaghetti Code design smells impedes significantly developers performance during comprehension and change tasks. The obtained results justify a posteriori previous researches on the specification and detection of design smells. Software development teams should warn developers against high number of occurrences of design smells and recommend refactorings at each step of the development to remove them when possible. In the second contribution, we investigate the relation between design smells and faults in classes from the point of view of developers who must fix faults. We study the impact of the presence of design smells on the effort required to fix faults, which we measure using three metrics: (1) the duration of the fixing period; (2) the number of fields and methods impacted by fault-fixes; and, (3) the entropy of the fault-fixes in the source code. We conduct an empirical study with 12 design smells detected in 54 releases of four systems: ArgoUML, Eclipse, Mylyn, and Rhino. Our results showed that the duration of the fixing period is longer for faults involving classes with design smells. Also, fixing faults in classes with design smells impacts more files, more fields, and more methods. We also observed that after a fault is fixed, the number of occurrences of design smells in the classes involved in the fault decreases. Understanding the impact of design smells on development effort is important to help development teams better assess and forecast the impact of their design decisions and therefore lead their effort to improve the quality of their software systems. Development teams should monitor and remove design smells from their software systems because they are likely to increase the change efforts. The third contribution concerns design smells detection. During maintenance and evolution tasks, it is important to have a tool able to detect design smells incrementally and iteratively. This incremental and iterative detection process could reduce costs, effort, and resources by allowing practitioners to identify and take into account occurrences of design smells as they find them during comprehension and change. Researchers have proposed approaches to detect occurrences of design smells but these approaches have currently four limitations: (1) they require extensive knowledge of design smells; (2) they have limited precision and recall; (3) they are not incremental; and (4) they cannot be applied on subsets of systems. To overcome these limitations, we introduce SMURF, a novel approach to detect design smells, based on a machine learning technique—support vector machines—and taking into account practitioners’ feedback. Through an empirical study involving three systems and four design smells, we showed that the accuracy of SMURF is greater than that of DETEX and BDTEX when detecting design smells occurrences. We also showed that SMURF can be applied in both intra-system and inter-system configurations. Finally, we reported that SMURF accuracy improves when using practitioners’ feedback.

No description available.