Although software architecture aims for long-term stability, architectural migrations may be necessary to adapt to evolving business needs and resource availability. In recent years, numerous migrations have occurred within backend architectures. While many of these migrations partition monoliths into microservices, several prominent enterprises have reported having to unite microservices into monoliths to reduce management and communication overheads. The required unification is typically manual, substantial, tedious, and error-prone for complex systems. This thesis presents a novel automated architectural refactoring that transforms a microservice system into a functionally equivalent monolith. Our refactoring relies on abstract syntax tree merging and control flow bridging to unite distributed components into a centralized system. We have implemented our approach as μJUNITER, an automated refactoring tool that operates on Java source files of Spring Boot microservices, producing Spring Boot modular monoliths. Evaluations conducted with third-party and synthetically generated microservice applications, with up to 100 microservices, demonstrate that μJUNITER's refactoring preserves the original system's functionality, as verified by end-to-end and back-end unit testing. The refactoring also reduced latency in certain cases and resource consumption in all cases. μJUNITER's refactoring saves manual programming effort proportional to the number of microservices and their level of inter-service interaction. As software architectures must adapt to changing trends, our approach can complement and enhance the existing automated toolset for architectural migration. / Master of Science / Modern software must constantly evolve to remain useful, reliable, and efficient. Sometimes, these changes affect small parts of the software, while in other cases, the entire architecture needs to be reworked. Enterprise software architecture typically follows two main styles: monolithic systems, in which all features are bundled together, or microservices, in which features are broken into separate, remotely interacting components. While many companies have shifted from monolithic systems to microservices, some are now moving back to monolithic structures to simplify management and reduce overhead. This thesis introduces a tool called μJUNITER that automates the process of merging microservices into a single, cohesive system, saving time and reducing errors. The evaluation shows that μJUNITER preserves the original functionality while improving performance and reducing resource usage. With the continuous changes in the software landscape, μJUNITER provides an effective solution for organizations seeking to restructure the architecture of their enterprise systems.

La maintenance consomme une grande partie du coût de développement des logiciels ce qui rend l’optimisation de ce coût parmi les enjeux importants dans le monde du génie logiciel. Dans cette thèse nous visons à optimiser ce coût par rendre ces maintenances modulaires. Pour atteindre cet objectif, nous définissons des transformations des architectures des programmes qui permettent de transformer le programme à maintenir vers une architecture qui facilite la tâche de maintenance voulue. Nous nous concentrons plus sur la transformation entre les architectures à propriétés de modularité duales tels que les patrons de conception Composite et Visiteur. Dans ce contexte, nous définissons une transformation automatique et réversible basée sur le refactoring entre un programme structuré selon le Composite et sa structureVisiteur correspondante. Cette transformation est validée par la génération d’une précondition qui garantit statiquement sa réussite. Elle est aussi adaptée afin qu’elle prenne en compte la transformation de quatre variations du patron Composite et est validée sur le programme JHotDraw qui comporte ces quatre variations. Nous définissons aussi une transformation réversible au sein du patron Singleton afin de pouvoir bénéficier de l’optimisation par l’introduction de ce patron et la souplesse par sa suppression selon les exigences de l’utilisateur du logiciel. / Maintenance consumes a large part of the cost of software development which makes the optimization of that cost among the important issues in the world of software engineering. In this thesis we aim to optimize this cost by making these maintenances modular. To achieve this goal, we define transformations of program architectures that allow to transform a program to maintain into an architecture that facilitates the maintenance tasks required. We focus on transformation between architectures having dual modularity properties such as Composite and Visitor designpatterns. In this context, we define an automatic and reversible transformation based on refactoring between a program structured according to the Composite structure and its corresponding Visitor structure. This transformation is validated by generating a precondition which guarantees statically its success. It is also adapted to take into account the transformation of four variations of Composite pattern and it is then applied to JHotDraw program in which these four variations occur. We define also a reversible transformation in the Singleton pattern to benefit from optimization by introducing this pattern and flexibility by its suppression according to the requirements of the software user.

It is difficult to maintain and to adapt poorly written code presenting shortcomings in its structure. Refactoring techniques are used to improve the source code and the structure of applications, making them better and easier to modify. Design patterns are reusable solutions used in similar problems in object-oriented systems, so there is no need to recreate the solutions. Applying design patterns in the context of refactoring in a corrective way becomes a desired activity in the life cycle of a specific software system. However, for medium and large-scale projects, the manual examination of artifacts to find problems and opportunities to apply a design pattern is a hard task. In this context, we present a set of metric-based heuristic functions to detect where a design pattern can be applied in a given project, more specifically, the Strategy, Factory Method, Template Method, Creation Method and Chain Constructors patterns. To evaluate the heuristic functions and its results we have also built a tool to show the results. This tool can examine source code traversing ASTs (Abstract Syntax Trees), searching for opportunities to apply the patterns, indicating the exact location in the source code where the pattern is suggested, also showing some evidences used in the detection. / Manter e adaptar código mal escrito, com problemas estruturais, é uma tarefa difícil. As técnicas de refatoração são usadas para melhorar o código e a estrutura de aplicações, aumentando sua qualidade e tornando-as mais fáceis de serem modificadas. Padrões de projeto são soluções reutilizáveis usadas para resolver problemas comumente encontrados em sistemas orientados a objetos. A aplicação de padrões de projeto no contexto de refatoração usando uma abordagem corretiva torna-se uma atividade interessante no ciclo de vida de um sistema de software. Contudo, para projetos de média e larga-escala, examinar manualmente os artefatos de software na busca por problemas e oportunidades para aplicar um determinado padrão de projeto é uma tarefa árdua e difícil. Nesse contexto, apresentamos um conjunto de funções heurísticas baseadas em métricas que permitem detectar onde um padrão de projeto pode ser aplicado nos artefatos de código de um determinado projeto, mais especificamente, os padrões de projeto Strategy, Factory Method, Template Method, Creation Method e Chain Constructors. Para avaliar as funções propostas, desenvolvemos uma ferramenta que avalia código-fonte e exibe possíveis oportunidades para aplicar uma refatoração rumo a tais padrões. Essa ferramenta foi desenvolvida usando-se ASTs (Abstract Syntax Trees), procurando por oportunidades de refatoração, indicando os locais no código fonte onde o padrão é sugerido e mostrando algumas evidências usadas para a detecção.

Denna rapport har sitt ursprung i det kodefaktoriseringsarbete som utfärdats våren 2013 som examensarbete i dataingenjörsprogrammet vid Örebro Universitet. Arbetet utfärdades på Nethouse i Örebro, och hade stort fokus på koddesign och kodkvalitet. I rapporten diskuteras vilka faktorer som påverkar hur underhållbar och läsbar en kod är, men också hur man på ett rimligt sätt kan utvärdera och mäta kodkvalitet. Den teoretiska biten blandas med den praktiska, där läsaren introduceras för ett flertal metoder, och hur dessa sedan implementerades i det faktiska projektet som Nethouse tillhandahöll. / This report has its origins in the code refactoring work issued in spring 2013 as a Degree Project in the Computer Engineering Programme, at Örebro University. The work took place at Nethouse in Örebro, and had a major focus on code design, and code quality. The report discusses the factors that affect how maintainable and readable a code is, but also how to reasonably evaluate and measure code quality. The theory is mixed with the practical, where the reader is introduced to a variety of methods, and how these were then implemented in the actual project that Nethouse provided.

Per pastaruosius metus, lankstaus programavimo metodikos sulaukė daug dėmesio. Programų kodo pertvarkymas tapo viena iš labiausiai naudojamų praktikų, ypač ekstremaliame programavime. Todėl poreikis turėti programos kodo pertvarkymų įrankį išaugo iki tokio lygio, kad pertvarkymo įrankiai tapo reikalaujama priemone šiuolaikinėse programų kūrimo aplinkose. Tyrimo sritis – abstrakčios sintaksės medžių pertvarkymo algoritmai. Tyrimo objektas – abstrakčios sintaksės medžių pertvarkymo procesai skirtingose programavimo kalbose (C++ ir Java). Šio darbo tikslas – ištirti, kaip efektyviai būtų galima vykdyti pertvarkymus bendriniam AST, tam sukuriant pertvarkymų biblioteką ir atliekant eksperimentus įvairių kalbų atvejais. / Over the past years, agile development methodologies have attracted a lot of attention. Refactoring has become one of the most heavily used practices, especially in Extreme Programming. Therefore the need to have powerful refactoring tools has grown to such an extent, that there is a required feature for modern-day IDEs to have implemented refactoring tools. The aim of this work is to build a refactoring library for the generic abstract syntax tree and test the algorithms for speed. Generic abstract syntax tree (GAST) is a tree structure that can store elements of several programming language. Achieving this goal required doing certain tasks that you find in this document: analysis of technologies and existing software; several algorithms for refactoring; user need and specification of requirements; library model, expressed in UML diagrams; test plan and test procedure. Experiments have shown that it is necessary to improve the refactoring algorithms. But the library and the AST structure is worth further development.

Evolutionary changes applied to a framework API may invalidate existing framework-based applications. While manually adapting applications is expensive and error-prone, automatic adaptation demands cumbersome specifications, which the developers are reluctant to write and maintain. Considering structural changes (so-called refactorings) of framework APIs, our adaptation technology supports backward-compatible framework upgrade. The technology is rigorous defining precisely the structure and automatic derivation of compensating adapters. It is also practical compensating for most application-breaking API changes automatically, while requiring neither manual adaptation nor recompilation of existing application code.

[pt] Desenvolvedores frequentemente aplicam refatoração para melhorar os atributos internos de qualidade em projetos de software, tais como acoplamento e tamanho. Chamamos de rerrefatoração quando desenvolvedores refatoram um elemento de código-fonte previamente refatorado. O conhecimento empírico é limitado acerca de até que ponto refatoração e rerrefatoração de fato melhoram os atributos internos de qualidade. Nesta dissertação, nós investigamos a limitação supracitada com base em cinco atributos internos de qualidade conhecidos: acoplamento, coesão, complexidade, herança e tamanho. Também nos baseamos no histórico de versionamento de 23 projetos de software de código-fonte aberto, os quais possuem 29,303 operações de refatoração e 49.55 por cento de rerrefatorações. Nossa análise revelou descobertas interessantes apresentadas como segue. Primeiro, desenvolvedores aplicam mais de 93.45 por cento de operações de refatoração e rerrefatoração sobre elementos de código-fonte com ao menos um atributo interno de qualidade crítico, contrariando trabalhos anteriores. Segundo, para 65 por cento das operações, os atributos internos de qualidade relacionados melhoram, enquanto que os demais 35 por cento permanecem não-afetados. Terceiro, sempre que operações de refatoração são aplicadas sem mudanças adicionais no código fonte, o que chamamos de operação de refatoração root-canal, os atributos internos de qualidade frequentemente melhoram, ou ao menos, não pioram. Ao contrário, 55 por cento das operações de refatoração aplicadas com mudanças adicionais, tais como correção de bugs, surpreendentemente melhoram os atributos internos de qualidade, com somente 10 por cento de piora, o que também é válido para rerrefatoração. Nós sumarizamos nossas descobertas na forma de recomendações para desenvolvedores e pesquisadores. / [en] Developers often apply code refactoring to improve the internal quality attributes of a program, such as coupling and size. Given the structural decay of certain program elements, developers may need to apply multiple refactorings to these elements to achieve quality attribute improvements. We call re-refactoring when developers refactor again a previously refactored element in a program, such as a method or a class. There is limited empirical knowledge on to what extent developers successfully improve internal quality attributes through (re-)refactoring in their actual software projects. This dissertation addresses this limitation by investigating the impact of (re-)refactoring on five well-known internal quality attributes: cohesion, complexity, coupling, inheritance, and size. We also rely on the version history of 23 open source projects, which have 29,303 refactoring operations and 49.55 percent of re-refactoring operations. Our analysis revealed relevant findings. First, developers apply more than 93.45 percent of refactoring and re-refactoring operations to code elements with at least one critical internal quality attribute, as oppositely found in previous work. Second, 65 percent of the operations actually improve the relevant attributes, i.e. those attributes that are actually related to the refactoring type being applied; the remaining 35 percent operations keep the relevant quality attributes unaffected. Third, whenever refactoring operations are applied without additional changes, which we call root-canal refactoring, the internal quality attributes are either frequently improved or at least not worsened. Contrarily, 55 percent of the refactoring operations with additional changes, such as bug fixes, surprisingly improve internal quality attributes, with only 10 percent of the quality decline. This finding is also valid for re-refactoring. Finally, we also summarize our findings as concrete recommendations for both practitioners and researchers.

No description available.

Evolutionary changes applied to a framework API may invalidate existing framework-based applications. While manually adapting applications is expensive and error-prone, automatic adaptation demands cumbersome specifications, which the developers are reluctant to write and maintain. Considering structural changes (so-called refactorings) of framework APIs, our adaptation technology supports backward-compatible framework upgrade. The technology is rigorous defining precisely the structure and automatic derivation of compensating adapters. It is also practical compensating for most application-breaking API changes automatically, while requiring neither manual adaptation nor recompilation of existing application code.

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