Spelling suggestions: "subject:"pode complexity"" "subject:"mode complexity""
1 |
Progressive Web Applications and Code Complexity : An analysis of the added complexity of making a web application progressiveJohannsen, Fabian January 2018 (has links)
Web applications have a common code base across multiple platforms, but have previously lacked some core features compared to native applications. However, recent web technology advancements have, in terms of functionality and user experience, reduced the gap between the two development approaches. Applications that leverages these technology advancements are dubbed progressive web applications, or PWA. This thesis explores the concepts of PWA and how it, in terms of code complexity, affects an Angular web application. The results show that implementing considered PWA features does not excessively increase the size of the application and that the overall added complexity is low. The complexity of PWA lies in all the new technology concepts, which are probably unfamiliar to most developers. To reduce this complexity, automated PWA tooling shows great promise, and using Angular PWA tooling when building Angular applications seems to minimize this complexity.
|
2 |
An empirical investigation on modern code review focus areasJiang, Zhiyu, Ma, Bowen January 2020 (has links)
Background: In a sustaining, durable project, an effective code review process is key to ensuring the long-term quality of the code base. As the size of the software continues to increase, although the code inspections have many benefits, the time it takes, the manpower makes it not a good method in some larger projects. Nowadays more and more industry performs modern code reviews for their project in order to increase the quality of the program. Only a few papers have studied the relationship between code reviewers and code review quality. We need to explore the relationships among code review, code complexity, and reviewers. Finding out which part of the code the reviewers pay more attention to in the code review and how much effort it takes to review. This way we can conduct code reviews more effectively. Objectives: The objective of our study is to investigate if code complexity relates to how software developers to review code in terms of code review length, review frequency, review text quality, reviewer’s sentiment. What’s more, we want to research if the reviewer’s experience will have an impact on code review quality. In order to find a suitable way to conduct a code review for different complexity codes. Methods: We conduct an exploratory case study. The case and unit of analysis is the open-source project, Cassandra. We extract data from Cassandra Jira (a proprietary issue tracking product), the data are the reviewer’s name, review content, review time, reviewer’s comments, reviewer’s sentiment, comment length, and the review file(java file). Then we use CodeMR to calculate the complexity of the file, it uses some coupling and code complexity metrics. The reviewer’s sentiment is analyzed by a text analysis API. After we collect all these data we use SPSS to do a statistic analysis, to find whether there are relationships between code complexity and these factors. What’s more, we have a workshop and send out questionnaires to collect more input from Cassandra developers. Results: The results show that code review frequency is related to code complexity, complex code requires more review. Reviewer’s sentiment is related to code complexity, reviewer’s sentiment towards complex code is more positive or negative rather than neutral. Code review text quality is related to the reviewer’s experience, experienced reviewers leave a comment with higher quality than novice reviewers. On the other hand, the code review length and review text quality are not related to code complexity. Conclusions: According to the results, the code with higher code complexity related to the more frequent review, and the reviewer's emotions are more clear when reviewing more complex code. Training experienced reviewers are also very necessary because the results show that experienced reviewers review the code with higher quality. From the questionnaire, we know developers believe that more complex code needs more iterations of code review and experienced reviewers do have a positive effect on code review, which gives us a guide on how to do code review based on a different level of code complexity.
|
3 |
Bobox Runtime Optimization / Bobox Runtime OptimizationKrížik, Lukáš January 2015 (has links)
The goal of this thesis is to create a tool for an optimization of code for the task-based parallel framework called Bobox. The optimizer tool reduces a number of short and long running tasks based on a static code analysis. Some cases of short-running tasks cause an unnecessary scheduling overhead. The Bobox scheduler can schedule a task even though the task does not have all input data. Unless, the scheduler has enough information not to schedule such task. In order to remove such short-running task, the tool analyses its input usage and informs the scheduler. Long-running tasks inhibit a parallel execution in some cases. A bigger task granularity can significantly improve execution times in a parallel environment. In order to remove a long-running task, the tool has to be able to evaluate a runtime code complexity and yield a task execution in the appropriate place. Powered by TCPDF (www.tcpdf.org)
|
4 |
The impact of reactive programming on code complexity and readability: A Case StudyHolst, Gustaf, Gillberg, Alexander January 2020 (has links)
Reaktiv programmering är ett programmeringsparadigm som har utvecklats för att underlätta byggande av händelsedrivna reaktiva applikationer. Dess förespråkare hävdar att det kan leda till ökad kodkvalitet, men få studier har utförts för att underbygga dessa påståenden empiriskt. Denna studie syftade till att undersöka skillnaden i kodkomplexitet och kodläsbarhet mellan traditionell imperativ programmering och reaktiv programmering. En fallstudie utfördes där koden för ett befintligt öppen källkodsprojekt omstrukturerades, vilket resulterade i en imperativ version och en reaktiv version av samma kod. Verktyg för statisk källkodsanalys användes för att undersöka om några förändringar i kodläsbarhet och kodkomplexitet kunde upptäckas. Vidare diskuteras huruvida resultaten av den senaste teknikens läsbarhetsmätvärden ger en exakt förutsägelse av kodläsbarheten i reaktiva kodbaser, eller om kanske dessa mätvärden behöver modifieras för att göra dem tillämpliga på det reaktiva paradigmet. Våra resultat visar att läsbarheten påverkades negativt av reaktiv programmering när den mättes med senaste teknikens läsbarhetsmätvärden, men kodkomplexiteten minskades betydligt. / Reactive programming is a programming paradigm that has been proposed to facilitate building eventdriven reactive applications. It is claimed by its proponents to increase code quality, but few studies have been performed to substantiate these claims empirically. This study aimed to explore the difference in code complexity and code readability between traditional imperative programming and reactive programming. A case study was performed where the code of an existing open source project was restructured, resulting in an imperative version and a reactive version of the same code. Static analysis tools were used to investigate if any changes in code readability and code complexity could be detected. Furthermore, it is discussed whether the results of the state-of-the-art readability metrics give an accurate prediction of code readability in reactive code bases, or if perhaps these metrics need to be modified to make them applicable to the reactive paradigm. Our findings show that the readability was negatively affected by reactive programming when measured with state-of the-art readability metrics, however code complexity was decreased significantly
|
5 |
Repository Mining : Användbarheten av Repository Mining för effektivisering av mjukvaruutvecklingEngblom Sandin, John January 2022 (has links)
Mjukvaruföretag idag söker alltid nya metoder för att effektivisera sin utveckling och att förbättra sin produkt. Denna studie undersöker användbarheten av en sådan ny metod kallad repository mining. Inom mjukvaruutveckling är repository mining en metod av kodanalys som utförs för att få ut metadata från ett versionshanteringssystem. Processen utförs med hjälp av ett kodanalysverktyg som i denna studie är verktyget CodeScene. Målet med denna fallstudie är att undersöka vad det finns för användningsfall för repository mining i ett utvecklingssyfte. Studiens syfte är att få förståelse för vilka typer av metadata som är relevanta och vad för faktorer det finns som kan påverka eventuella resultat. Syftet är även att studera om hur repository mining kan hjälpa företag i deras arbete med att öka eller upprätthålla kvaliteten på deras system. Studien utförs i samband med företaget Sandvik Coromant och deras avdelning Machining Foresight för att analysera deras kodbas. Kodbasen analyseras med hjälp av kodanalysverktyget CodeScene för att utvinna metadata som sedan presenteras till utvecklare inom Machining Foresight. Sedan utförs en kvalitativ studie som består av intervjuer och gruppdiskussioner i syfte av att få utvecklarnas reflektioner och tankegångar angående användbarheten av repository mining. Resultatet visar på att det finns användningsfall hos repository mining men dessa kräver att vissa faktorer är bestämda. Första användningsfallet är en analys på ändring i kodkomplexitet som hjälper att förutspå framtida refaktoreringar. Det andra användningsfallet är en analys på författarskap inom systemet för att hitta möjliga platser känsliga för kunskapsförlust, därmed hjälpa i planering av kunskapsdelning. Detta är dock en fallstudie och dessa resultat ska inte användas för att dra generella slutsatser om repository mining i sin helhet. Resultaten ska endast tas som vägriktning och indikation för framtida studier.
|
6 |
N-Grams as a Measure of Naturalness and ComplexityRandák, Richard January 2019 (has links)
We live in a time where software is used everywhere. It is used even for creating other software by helping developers with writing or generating new code. To do this properly, metrics to measure software quality are being used to evaluate the final code. However, they are sometimes too costly to compute, or simply don't have the expected effect. Therefore, new and better ways of software evaluation are needed. In this research, we are investigating the usage of the statistical approaches used commonly in the natural language processing (NLP) area. In order to introduce and evaluate new metrics, a Java N-gram language model is created from a large Java language code corpus. Naturalness, a method-level metric, is introduced and calculated for chosen projects. The correlation with well-known software complexity metrics are calculated and discussed. The results, however, show that the metric, in the form that we have defined it, is not suitable for software complexity evaluation since it is highly correlated with a well-known metric (token count), which is much easier to compute. Different definition of the metric is suggested, which could be a target of future study and research.
|
7 |
Integrated Source Code and Architectural Quality Analysis Using Neo4j Graph Database / Integrerad källkod och arkitektonisk kvalitetsanalys med hjälp av Neo4jGraph DatabaseAbdu, Mohammed January 2024 (has links)
In the realm of software engineering, understanding the architecture and measuringthe quality of a source code is essential for maintaining and enhancing softwaresystems. However, many existing tools fall short in evaluating architectural aspects,such as detecting architectural erosion or addressing architecture-related metrics andconstraints tailored to the unique context of their systems or organisations. Thisdeficiency restricts proactive architecture governance and hinders the mitigation ofarchitecture-related risks, creating a critical gap in the analysis of software sourcecode. This thesis presents a novel approach to tackle these challenges. It proposes a graphdatabase as a data structure for analysing the source code and architecture quality andcalculating various architectural metrics of interest. The tool developed in this thesisrepresents the source code structural elements and their relationships in the graphdatabase, enabling an intuitive analysis of the source code architecture. The tool also integrates different code quality metrics parsed from Visual Studiocode metrics results, mapped to their correspondent nodes to assess the source codeoverall quality and identify potential areas of improvement. This empowers softwareengineers and developers to make informed decisions regarding refactoring, codeoptimisation, and architectural enhancements. Furthermore, the tool allows users to define the intended architecture in terms ofmodules to reveal any Architecture erosion (AEr). It also provides the flexibility toestablish custom constraints and metrics through tailored queries, accommodating theunique requirements of their system and company. A case study conducted on a real-world software project validates the effectivenessand usefulness of the proposed approach. The case study demonstrates how the toolanalysis reveals valuable insights into the source code health and identifies patternsthat can impact maintainability and scalability. The results of this research showcasethe potential of our tool as a powerful instrument for analysing the code qualityand architecture of source code, fostering more resilient and sustainable softwaresystems.
|
Page generated in 0.0835 seconds