This report investigates how a telecommunication company might reduce its resource usage in terms of execution time by using Rust for the decompilation of ASN.1 messages. To contrast these results and to offer insights into other factors for choosing a language, the developer experience of Rust was also studied. Interviews were conducted to get developers' input on aspects such as the learnability and ergonomics of Rust, and these were analyzed through a thematic analysis. This revealed that developers appreciated working with Rust, mainly due to its ease of use, its enforcement of good development standards, the helpfulness of the compiler, and the well-structured and understandable documentation. Two ASN.1 decompiler implementations were made, one in C++ and one in Rust. Both decompilers invoked third-party C++ functions: in Rust, this was done by first wrapping them in C. The performance of both decompilers was measured during two benchmarking sessions, between which additional optimization was performed on both. The results were then compared statistically using the Mann-Whitney rank sum test method. The first benchmarking session showed similar performance for both decompilers, despite the Rust implementation performing additional tasks by first wrapping the C++ functions in C. However, both decompilers contained unintentional copies of values in the C++ code, with the C++ decompiler containing the majority. In the second benchmarking session, the Mann-Whitney test showed that the Rust decompiler performed worse, with a mean difference of 85.19-91.36%. In practice, however, it is seldom efficient for most applications to try to optimize code to the point of being perfect. Therefore, the decompilers of the first benchmarking session are considered more representative of software in general as they had gone through a code check more like what is often performed in practice. The interview and benchmarking results together show that in practice, Rust would likely be more resource-efficient, safer and more maintainable. This is because it prevents many bugs and likely leads to more well-structured applications of higher long-term quality, that perform at a level similar to C++ implementations for applications not put under exceptional scrutiny. Still, organizations integrating Rust into their code base would need to further evaluate factors such as Rust's toolchain support and scalability as well as the potential risks of it being a newer language.

The use of AI tools for code generation is increasing in popularity, and two of these tools are ChatGPT and GitHub Copilot. These tools could potentially reduce development time and costs for developers and companies, however, ensuring the correctness and quality of AI-generated code is crucial for its adoption. This study conducted a quantitative controlled experiment to evaluate the code generation capabilities of Copilot and ChatGPT in terms of code correctness and quality. The experiment aimed to address research questions regarding the performance of these AI tools. The results indicate that both ChatGPT and Copilot can generate correct code from given instructions, though there is room for improvement. ChatGPT achieved a correctness rate of 87.33%, while Copilot performed slightly better at 89%. Statistical analysis revealed no significant difference in code correctness between the two tools. Regarding code quality, ChatGPT demonstrated impressive performance, with 98.52% of generated lines free from quality rule violations. Furthermore, 80.7% of ChatGPT-generated algorithms had no quality rule violations. Copilot generated correct lines for 94.07% of total lines but only achieved 64.7% of algorithms with no quality rule violations. The statistical analysis showed a statistically significant difference in code quality between ChatGPT and Copilot, indicating that ChatGPT generally produces higher quality code. This research contributes to understanding the capabilities of AI code generation tools and highlights their potential to produce correct and high-quality code.

Due to the surge in the development of software, people in the software industry have a need for higher coding quality in different programming languages. A “code with good quality” can be defined as code that is written in a way that follows the rules or, in other words, conventions for, i.e., comments, proper indentation, clear notations, simplicity, naming, etc. There are coding style guidelines extracted from Java and Oracle code conventions to have readable, maintainable source code; however, the current studies do not answer the question of to what extent the open-source systems follow these guidelines. Finding the violations of conventions at the early stages of software development is essential because the changes are costly and impossible in the later stages. As a result, adhering to coding conventions will facilitate code readability and maintainability. Thus, this study intends to analyze the results from several code quality tools, make a comparison among them and, based on the outcomes, develop a new tool that covers the probable missing conventions in the studied code-checking tools.

Context: Software quality has a multi-faceted description encompassing several quality attributes. Central to our efforts to enhance software quality is to improve the quality of the source code. Poor source code quality impacts the quality of the delivered product. Empirical studies have investigated how to improve source code quality and how to quantify the source code improvement. However, the reported evidence linking internal code structure information and quality attributes observed by users is varied and, at times, conflicting. Furthermore, there is a further need for research to improve source code quality by understanding trends in feedback from code review comments. Objective: This thesis contributes towards improving source code quality and synthesizes metrics to measure improvement in source code quality. Hence, our objectives are 1) To synthesize evidence of links between source code metrics and external quality attributes, & identify source code metrics, and 2) To identify areas to improve source code quality by identifying recurring code quality issues using the analysis of code review comments. Method: We conducted a tertiary study to achieve the first objective, an archival analysis and a case study to investigate the latter two objectives. Results: To quantify source code quality improvement, we reported a comprehensive catalog of source code metrics and a small set of source code metrics consistently linked with maintainability, reliability, and security. To improve source code quality using analysis of code review comments, our explored methodology improves the state-of-the-art with interesting results. Conclusions: The thesis provides a promising way to analyze themes in code review comments. Researchers can use the source code metrics provided to estimate these quality attributes reliably. In future work, we aim to derive a software improvement checklist based on the analysis of trends in code review comments.

One of the greatest achievements of Scratch as an educational tool is the eager willingness of programmers to use existing projects as the starting point for their own projects, a practice known as remixing. Despite the importance of remixing as a foundation of collaborative and communal learning, the practice remains poorly understood. Without a clear picture of how and why Scratch programmers remix a project as a starting point of their own projects, this programming community would remain in the dark about which programming practices encourage and facilitate remixing. The designers of programming environments for blocks lack feedback on how the remixing facility is used in the wild. To gain a deeper insight into remixing, this thesis presents the results of a comprehensive study of this practice in Scratch that investigates the following heretofore unexplored dimensions of remixing: (1) the prevailing modifications that remixes perform on existing projects, (2) the impact of the original project's code quality on the granularity, extent, and development time of the modifications in the remixes, and (3) the propensity of the dominant programming practices in the original project to remain so in the remixes. Our findings can be used to promote those programming practices in the Scratch community that encourage remixing while also improving this practice's effectiveness, thus benefiting the educational and end-user programming communities. / Master of Science / The Scratch programming language has become an intrinsically important tool in introductory CS education. A visual, block-based language, Scratch is web-based, featuring an enormous online programming community, through which projects are eagerly shared. One of the unique learning provisions of Scratch is the ability to easily start a project by modifying someone else’s project, a practice referred to as remixing. Despite the central role that remixing plays in enabling the communal and collaborative learning styles in the Scratch community, the practice of remixing remains inadequately understood. This knowledge gap leaves the Scratch community in the dark about which programming practices encourage and facilitate remixing, as well as deprives Scratch environment designers from actionable feedback on how the remixing facility is used in the wild. To address this problem, this thesis reports on the results of an exploratory study of remixing in Scratch that investigates three heretofore unexplored dimensions of this practice. First, we study the general remixing trends in terms of how remixes modify the original projects. Second, we infer the impact of a project’s code quality on the modifications in its remixes and the development time. Finally, we investigate whether programmers adopt the techniques and practices of the remixed projects. Computing educators can apply our findings to enhance the educational effectiveness of Scratch by encouraging the practice and magnitude of remixing.

Much of software engineering research and practice is concerned with improving software quality. While enormous prior efforts have focused on improving the quality of programs, this dissertation instead provides the means to educate the next generation of programmers who care deeply about software quality. If they embrace the culture of quality, these programmers would be positioned to drastically improve the quality of the software ecosystem. This dissertation describes novel methodologies, techniques, and tools for introducing novice programmers to software quality and its systematic improvement. This research builds on the success of Scratch, a popular novice-oriented block-based programming language, to support the learning of code quality and its improvement. This dissertation improves the understanding of quality problems of novice programmers, creates analysis and quality improvement technologies, and develops instructional approaches for teaching quality improvement. The contributions of this dissertation are as follows. (1) We identify twelve code smells endemic to Scratch, show their prevalence in a large representative codebase, and demonstrate how they hinder project reuse and communal learning. (2) We introduce four new refactorings for Scratch, develop an infrastructure to support them in the Scratch programming environment, and evaluate their effectiveness for the target audience. (3) We study the impact of introducing code quality concepts alongside the fundamentals of programming with and without automated refactoring support. Our findings confirm that it is not only feasible but also advantageous to promote the culture of quality from the ground up. The contributions of this dissertation can benefit both novice programmers and introductory computing educators. / Doctor of Philosophy / Software remains one of the most defect-prone artifacts across all engineering disciplines. Much of software engineering research and practice is concerned with improving software quality. While enormous prior efforts have focused on improving the quality of programs, this dissertation instead provides the means to educate the next generation of programmers who care deeply about software quality. If they embrace the culture of quality, these programmers would be positioned to drastically improve the quality of the software ecosystem, akin to professionals in traditional engineering disciplines. This dissertation describes novel methodologies, techniques, and tools for introducing novice programmers to software quality and its systematic improvement. This research builds on the success of Scratch, a popular visual programming language for teaching introductory students, to support the learning of code quality and its improvement. This dissertation improves the understanding of quality problems of novice programmers, creates analysis and quality improvement technologies, and develops instructional approaches for teaching quality improvement. This dissertation contributes (1) a large-scale study of recurring quality problems in Scratch projects and how these problems hinder communal learning, (2) four new refactorings, quality improving behavior-preserving program transformations, as well as their implementation and evaluation, (3) a study of the impact of introducing code quality concepts alongside the fundamentals of programming with and without automated refactoring support. Our findings confirm that it is not only feasible but also advantageous to promote the culture of quality from the ground up. The contributions of this dissertation can benefit both novice programmers and introductory computing educators.

Developers build an entire software by writing quality code, the failure of which can risk organizational reputation, financial wellbeing, and even the lives and security of people. The ability to develop high quality code is therefore a key learning goal of foundational undergraduate computing programmes. However, how effective these undergraduate computing curriculums are in teaching software code quality is a matter of concern as this leads to raising the knowledge of future software developers. Right now, there is a lack of models to evaluate this effectiveness of undergraduate curriculum in providing the knowledge of software code quality to students.In this thesis, we suggest a model for evaluating the effectiveness of undergraduate curriculum in teaching software code quality, which we call ScQUc (Software Code Quality in Undergraduate Curriculum). Our goal is to raise the knowledge and awareness of teaching software code quality in education and make the undergraduate computing curriculum more software code quality centric.Due to the fact that there is a lack of models for evaluating the effectiveness of undergraduate curriculum in teaching software code quality, we had no closely related work to base our research on. We had to rely on other works related to code quality in programming courses that were indirectly connected to our research field. Hence, we dare infer that the ScQUc model was created from scratch.The research method used was qualitative and followed the frame of design science. Data collection was conducted via literature study and via interviews with two experts in the field. The interviewees were selected with the convenience sampling method enhanced with a predefined selection criterion. Data evaluation, on the other hand, was conducted using an evaluation model. The evaluation model included the following evaluation criteria: (1) interviewee credibility, (2) correctness, (3) flexibility, (4) usefulness and (5) experience. One round of interview was conducted with each of the interviewees which resulted in the improvement of the ScQUc model.The ScQUc model consists of a checklist of code quality characteristics and a sequence of activities to be conducted in order to evaluate the effectiveness of an undergraduate curriculum in teaching software code quality. The results of the evaluation of the ScQUc model inferred that the ScQUc model was correct and useful for the academia. Hence, we believe that the ScQUc model is a valid solution for evaluating the effectiveness of undergraduate curriculum in teaching software code quality. Still, however, the ScQUc model needs further evaluation and extension in form of specifications aiding deeper understanding of code quality, how to teach code quality, and to what extent to teach code quality. / Utvecklare bygger hela programvaran genom att skriva kvalitetskod, vars fel kan riskera organisatoriskt rykte, ekonomiskt välbefinnande och till och med människors liv och säkerhet. Förmågan att utveckla kod av hög kvalitet är därför ett viktigt inlärningsmål för grundläggande grundutbildningsprogram. Hur effektiva dessa läroplaner för grundutbildning är för att undervisa programkodkvalitet är emellertid en oro eftersom det leder till att kunskapen hos framtida programutvecklare ökar. Just nu saknas modeller för att utvärdera denna effektivitet i grundutbildningen för att ge studenterna kunskap om mjukvarukodkvalitet.I den här avhandlingen föreslår vi en modell för att utvärdera effektiviteten för grundutbildningen i undervisning av programkodkvalitet, som vi kallar ScQUc (Software Code Quality in Undergraduate Curriculum). Vårt mål är att öka kunskapen och medvetenheten om att undervisa programvarukodkvalitet i utbildningen och göra grundutbildningsberäkningen mer programvarukodkvalitet centrerad.På grund av bristen på modeller för att utvärdera effektiviteten i grundutbildningen i undervisning av programvarukodkvalitet, hade vi inget nära besläktat arbete att basera vår forskning på. Vi var tvungna att lita på andra verk relaterade till kodkvalitet i programmeringskurser som indirekt var kopplade till vårt forskningsområde. Därför drar vi slutsatsen att ScQUc-modellen skapades från grunden.Den använda metoden var kvalitativ och följde ramverket för designvetenskap. Datainsamlingen genomfördes genom litteraturstudie och genom intervjuer med två experter på området. Intervjuerna valdes med hjälp av metoden för provtagning av bekvämlighet förbättrad med ett fördefinierat urvalskriterium. Datautvärdering genomfördes å andra sidan med hjälp av en utvärderingsmodell. Utvärderingsmodellen inkluderade följande utvärderingskriterier: (1) intervjuarens trovärdighet, (2) korrekthet, (3) flexibilitet, (4) användbarhet och (5) erfarenhet. En intervjuomgång genomfördes med var och en av de intervjuade som resulterade i förbättringen av ScQUc-modellen.ScQUc-modellen består av en checklista med egenskaper för kodkvalitet och en sekvens av aktiviteter som ska genomföras för att utvärdera effektiviteten hos en grundutbildningsprogram i undervisning av programkodkvalitet. Resultaten av utvärderingen av ScQUc-modellen drar slutsatsen att ScQUc-modellen var korrekt och användbar för akademin. Därför tror vi att ScQUc-modellen är en giltig lösning för att utvärdera effektiviteten för grundutbildningen i undervisning av programvarukodkvalitet. Men ändå behöver ScQUc-modellen ytterligare utvärdering och utvidgning i form av specifikationer som hjälper djupare förståelse för kodkvalitet, hur man undervisar i kodkvalitet och i vilken utsträckning man ska lära ut kodkvalitet.

Implementing new technology into a complex software developing environment comes with many challenges in terms of code, user interface design, and developer experience. It is well-established that the pressing demand for security and regulations within financial technology makes it even more essential to implement new technologies with care and minimised risks. This work aims to determine the effectiveness of such implementations. Specifically, it evaluates the effectiveness of implementing a UI library in a FinTech application to find the most suitable approach. In this context, a UI library defines as a robust set of user interface components available in one place and a FinTech application as an application in financial technology with complex developing infrastructure. In order to successfully evaluate the effectiveness of implementing a UI library in a FinTech application, a thorough literature survey was performed to identify decisive factors relating to code quality, user interface, and developer experience. In a case study in which a FinTech company served as an example, a solution consisting of their product and UI library was developed. The solution was tested by collecting data from code evaluation, questionnaires, and interviews. The result shows that the solution has higher code quality, fulfils the FinTech UI requirements, and perceived as an improvement of the development infrastructure.  On this basis, the utilised methodology and the recognised factors in this work should be taken into account to identify the most suitable approach when implementing a UI library in a FinTech application.

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.