The goal of the project is to evaluate three different methods of authenticating users on the Internet. These three methods are: login with username and password, two-factor authentication, and Freja eID. The login systems are evaluated in terms of usability, accessibility, security, and complexity. Usability and accessibility refer to how easy these systems are to use for different types of users and how well they work on various types of devices. This is determined through tests with programs and user tests. Security is evaluated through theory about Internet security, and complexity is measured by determining the cyclomatic complexity of the code. This means that the fewer paths there are through a code and the less complex these paths are, the less complex the code is. All code is written in JavaScript. Node.js was used for backend and Vue.js was used for frontend. A website has been constructed to test the login systems where the user can create an account, log in with password or two-factor authentication. In addition, there is a separate page for using the Freja eID's test API. The user tests that have been conducted show that testers preferred to log in with Freja eID and found it difficult to use two-factor authentication. Freja eID and two-factor authentication are considerably more secure than logging in with just a password and a username. In terms of code complexity, Freja eID was the solution that was the least complex and required the least amount of work. This makes Freja eID the solution that is ultimately recommended despite the cost per login. If a more economical alternative is desired, two-factor authentication is recommended. / Projektets mål är att utvärdera tre olika sätt att autentisera användare på Internet. Dessa tre sätt är inloggning med användarnamn och lösenord, tvåfaktorsautentisering och Freja eID. Inloggningssystemen utvärderas inom användbarhet, tillgänglighet, säkerhet och komplexitet. Användbarhet och tillgänglighet syftar till hur lätt dessa system är att använda för olika typer av användare och hur väl de fungerar på olika typer av enheter. Detta åstadkoms genom tester med program och användartester. Säkerheten utvärderas med hjälp av teori om säkerhet på Internet och komplexiteten mäts med hjälp av analys av den cyklomatiska komplexiteten i koden. Det innebär att ju färre vägar det finns genom en kod och ju mindre komplexa dessa vägar är, desto mindre komplex är koden. All kod är skriven i JavaScript. Node.js användes för backend och Vue.js användes för frontend. En webbplats har konstruerats för att testa inloggningssystemen där användaren kan skapa ett konto, logga in med lösenord eller tvåfaktorsautentisering. Dessutom finns det en separat sida för inloggning mot Freja eIDs test-API. De användartester som utförts visade att användare hade svårt att använda sig av tvåfaktorsautentisering och att inloggning med Freja eID var krångligare än inloggning med bara lösenord. När det gäller kodens komplexitet var Freja eID-lösningen den minst komplexa och krävde minst arbete. Det gör Freja eID till den rekommenderade lösningen trots att det kostar pengar vid varje inloggningstillfälle. Om man vill ha ett mer kostnadseffektivt alternativ rekommenderas tvåfaktorsautentisering.

Background - Web browsers and and the web programs on them are being used now more than ever in a manner similar to traditional software. But with the increase in the demand for performance on bigger and bigger web applications, there is a need for making the web applications perform faster and better. Introducing parallelism to a normally single threaded system is one popular way of introducing more performance. Objectives - We will implement proven and workable programs, created with OpenMP, that will be translated to JavaScript. These JavaScript applications will use the WebWorkers API to achieve similar levels of parallelism as the OpenMP applications. Methods - To implement and gather results from the all of the various programs, we will be using visual studio code and its live server extension that it hosts to run and compare the JavaScript implementations. The selected OpenMP applications to be measured and translated were primarily taken and selected from a benchmark suite that hosts programs that have already been written in a traditional parallel computing model, such as OpenMP. The performance of these OpenMP programs and Web Workers applications will be analyzed and compared in the second portion of the research where results will be gathered. Results - JavaScript was proven to perform worse than OpenMP in every situation tested. Though this was expected, there were also some situations where JavaScript applications were performing close to the OpenMP programs. Conclusions - Ultimately, using Web Workers is recommended for what they were designed to do. To help alleviate the main thread to keep the web program running smoothly. For the heavy computational tasks that we were experimenting on, JavaScript did not do a sufficient enough job compared against the OpenMP applications. When measuring the workers we did not get any results for any applicationsthat was very close to what OpenMP achieved. Thus Web Workers are really only suited for easy problems that needs to be done repeatedly. They lack the efficiency for any complicated algorithms to be worth implementing

Background. Using JavaScript frameworks has become a popular approach for developing web applications. However, the large bundle sizes associated with framework usage may not always be necessary from a sustainability standpoint. Utilizing a framework or not could potentially impact a web application’s performance and carbon emissions.  Objectives. This study aims to identify sustainable approaches to frontend web development and investigate whether a comparable difference in performance, energy consumption, and carbon emissions exists between applications built using a framework like React.js versus those developed using vanilla JavaScript.  Methods. A literature review was conducted to identify important factors for creating sustainable web applications from previously published materials. An empirical study was performed where two test applications were created; one developed in vanilla JavaScript and one using the React.js framework. Experiments on these prototypes compared performance and estimated carbon emissions on the applied technologies.  Results. When researching literature published on sustainability within web development, the factor most frequently mentioned was web performance optimization. The results of the empirical study found that the application written in vanilla JavaScript achieved higher performance metrics and lower estimated carbon emissions than the prototype developed with React.js.  Conclusions. This thesis has found that web performance optimization is an important, powerful, and easy-to-use approach for achieving more sustainable web applications. This study has found several important factors for creating sustainable web applications, which can significantly impact an application’s carbon emissions. The study found that the best-performing test application achieved the lowest estimated carbon footprint. This thesis recommends that developers make informed decisions and consider sustainability when choosing a development strategy, like using a framework or not for future projects.

WebAssembly is Assembly-like code that is created by compiling other languages into Wasm. The Wasm file can then be run on the web at near native speed. The objective of this study is to find how WebAssemblys runtime compares to JavaScript and native. The study will also see if different browsers impact WebAssembly runtime. To get the information two different methods were used. Firstly literature and articles were used to gather data on JavaScript and native runtime compared to WebAssembly. Secondly an empirical study was conducted to compare four different browsers WebAssembly runtime.  When comparing WebAssembly and JavaScript it was found that WebAssembly isn't always the fastest alternative due to many reasons but some major ones were how they were compiled and optimised.  When looking at WebAssembly compared to native we could clearly see that WebAssembly was slower. These slowdowns came primarily from the increase in code size but the virtual environment and security checks also contributed to this.  After the empirical study we could see some differences between browsers both in compilation speed and execution time. Between the chromium browsers the difference in execution time was very small and Firefox was always faster. But when looking at compilation time Chrome was faster with the other browsers having varying results. The research could conclude that WebAssembly can provide a useful boost to runtime on websites when used correctly. It is not something that is going to replace JavaScript but can be used together with it. We could also conclude that the user's choice of browser has a small impact on WebAssembly and can cause differences in runtime.

Dagens webbläsare uppdaterar sitt utseende mer än någonsin och att kunna utföra det på ett effektivt sätt är essentiellt. Att kompilera om en hemsida och ladda upp den på nytt är ineffektivt och framtiden hos dynamisk uppdaterade hemsidor ligger hos MQTT och websockets. Med hjälp av Invencon har jag utforskat detta område genom att få en back-end till ett systemet att bygga på. Det har framställts två användargränssnitt för två gruvrobotar som ska kunna ta ordar av ett publicerar-användargränssnitt. Meddelandena skickas som JSON-objekt som är fyllda med information som robotarna ska ta emot. Dessa ordrar kan vara att ändra robotens maximala hastighet. Robotarna uppdaterar sitt gränssnitt i realtid där de samtidigt skickar sin nuvarande hastighet till publiceraren som visar upp dem. Det finns ett fjärrkontroll-gränssnitt där man kan välja en robot som är igång, där gränssnittet presenterar all information om den valda roboten. Användar- gränssnitten skrivs i HTML och CSS där funktionaliteten görs i JavaScript med hjälp av MQTT och websockets. Flera tester har gjorts där man kollar latensen på hur lång tid det tar för ett meddelande att ta sig till en robot och tillbaka till publiceraren för att mäta hur pålitligt systemet är. Efter testerna utfördes, kom jag fram till att fler tester kommer behöva göras för att testa systemet på en högre nivå, då två robotar och en användare inte räcker för ett konkret resultat. Systemet har potential att användas i riktig verksamhet med vidareutveckling av båda tester och bättre back-end. / Today’s web browsers are updating their appearance more than ever, and being able to do so efficiently is essential. Compiling a website and uploading it again is inefficient, and the future of dynamically updated websites lies in MQTT and websockets. With the help of Invencon, I have explored this area by establishing a back-end for the system. Two user interfaces have been developed for two mining robots that can receive commands from a publisher-interface. Messages are sent as JSON-objects filled with information that the robots need to receive. These commands can include changing the robot’s maximum speed. The robots update their interfaces in real-time while si- multaneously sending their current speed to the publisher, which displays them. There is a remote control-interface where you can select a running robot, and the interface presents all information about the chosen robot. The user interfaces are written in HTML and CSS, with functionality implemented in JavaScript using MQTT and websockets. Several tests have been conducted to measure the latency of how long it takes for a message to reach a robot and back to the publisher, proving the reliability of the system. After the tests, it was concluded that more testing needs to be done to evaluate the system on a higher level, as two robots and one user are insufficient for a concrete result. The system has the potential to be used in real-world applications with further development of both testing and a better back-end.

The subject of JavaScript frameworks/libraries and which to choose as a developer, organization or client has been the target of quite some research, and even more debate. This thesis aims to investigate four of these, namely Angular, React, Svelte and Vue by building a functionally identical application and running performance tests towards them through Apache JMeter to measure throughput. Furthermore, Webdriver plugin will be added to measure full render response times to add another dimension to the discussion. The result of the investigation shows that even if some of the tests speak very highly in favor of some of these frameworks/libraries, some do not, and adding in previous research into perceived values as well as performance metrics of these frameworks make the picture even more complex. Furthermore, the frameworks/libraries in question evolve very rapidly, constantly contending against each other. What this study does, in the end, is to provide a basic method of comparison that can be extended, which will aid stakeholders in researching the frameworks/libraries strengths and weaknesses as well as which framework that fits their project’s needs. / Ämnet JavaScript och dess ramverk och bibliotek, samt vilket man bör välja som utvecklare, organisation eller kund har varit mål för en stor mängd forskning, och än mer debatt. Den här uppsatsen ämnar undersöka fyra av dessa ramverk/bibliotek genom att bygga en funktionellt identisk applikation och genomföra prestanda tester med Apache JMeter mot dem för att mäta genomströmning. Utöver detta kommer även ett instickningsprogram till JMeter vid namn Webdriver användas på samma applikationer för att mäta responstid och ytterligare expandera diskussionen. Resultatet av den här undersökningen visar att vissa av dessa tester talar i förmån för vissa ramverk/bibliotek, medan vissa inte gör det. Adderar man dessutom tidigare forskning rörande mjukare värden och prestandamätningar så blir bilden än mer komplex. Vidare kan nämnas att dessa ramverk och bibliotek utvecklats oerhört under de senaste åren och fortfarande utvecklas, och är i konstant kamp mot varandra. I slutändan skulle jag hävda att det bästa man kan göra som intressent är att samla så mycket fakta rörande både sitt eget projekt och de ramverk/bibliotek som kan tänkas användas, och sen välja. Vad den här studien kan ge en intressent är en reproducerbar metod med expansionsmöjligheter för att få ut nödvändig information inför nämnda val.

As more and more companies use the internet to grow their businesses and sales, it is crucial to have a fast and responsive site that keeps customers on the site. Hence, comparing two web frameworks with respect to response time is vital, as it is a significant part of delivering the page. The comparison will help developers to choose between Express.js and Ktor. Our research shows how the two frameworks, Ktor and Express.js, compare in response times for static and dynamic pages for a set of concurrent users. The comparison will explain how the frameworks’ response times change when having a different number of concurrent users and delivering static vs. dynamic content. An experiment with Locust was conducted to obtain the data needed to show the differences in response time for the two frameworks. Additionally, a literature study was conducted to find the best way to structure the servers, design the tests, and find information on how the frameworks should perform. We found that Express.js has an overall better response time than Ktor. At the same time, it was found that the Object Relational Mapper used with Ktor affected result more than the Object Relational Mapper used with Express.js. Hence, we conclude that Express.js is the better choice, but since both frameworks had low response times, we would say that even Ktor is a valid choice.

This degree project is a scientific study where the focus is to formulate a method of how to compare Single-Page Application (SPA) frameworks written in JavaScript. To solve the problem, an abstraction of SPA frameworks is required. This abstraction is completed using a criteria-based approach. Criteria are collected from literature and interviews with experienced developers. Every criterion is defined and has a set of questions evaluating it. In addition to the abstraction concepts are extracted from other comparative methods, such as performance testing and code comparison. The method is evolved into two separate parts, a theoretical and a practical. Finally, the method is tested on three different frameworks, AngularJS, Angular 2 and React, by implementing a prototype for each framework. From this prototype, code comparison and performance tests are conducted and evaluated. According to the method, AngularJS is suggested to be the best choice. However, the majority of the results from the theoretical part were more or less identical whereas practical part showed more differences. For future reference, this method could be evaluated to other comparative methods or be extended with more criteria and questions. / Detta examensarbete är en vetenskaplig studie där fokus är att formulera en metod för hur man kan jämföra ramverk för single-page-applikationer (SPA) skrivna i JavaScript. För att lösa problemet, behövs en abstraktion av SPA-ramverk. Denna abstraktion använder sig av ett kriterium baserat tillvägagångssätt. Kriterier samlas in från litteratur och intervjuer med erfarna utvecklare. Varje kriterium definieras och har en uppsättning frågor som utvärderar det. Förutom abstraktionen extraheras koncept från andra komparativa metoder, såsom prestandatestning och kod jämförelse. Metoden utvecklades i två separata delar, en teoretisk och en praktisk. Slutligen testas metoden på tre olika ramverk, AngularJS, Angular 2 och React genom att implementera en prototyp för varje ramverk. Från denna prototyp kan kod jämförelser och prestandatester genomföras och utvärderas. Resultatet visar att AngularJS är det bästa valet. Men de flesta av resultaten från den teoretiska delen var mer eller mindre identiska medan den praktiska delen visade fler skillnader. För framtida utveckling, kan denna metod utvärderas med andra jämförbara metoder eller utökas med flera kriterier och frågor.

Utvecklingen av datorer och deras förmåga ökar klyftan mellan datorer och skapar en stormångfald av hårdvarutillgänglighet. Kapaciteten som datorer besitter varierar kraftigt ochdärmed även förmågan att hantera komplexa applikationer. Moderna applikationer erbju-der inställningar som användare kan anpassa för datorn, något som kräver att användarenhar tillräcklig kunskap för att förstå inställningarnas e ekt. Att välja ut de optimala in-ställningarna för datorn är en process som är både svår och tidskrävande. Detta arbetegranskar hur ett dynamiskt adaptivt system automatiskt kan anpassa inställningarna förapplikationen medan den kör, utan manuell extern inverkan. Systemet mäter kontinuerligtapplikationen och individuella teknikers prestanda. Baserat på mätresultat anpassar detadaptiva systemet applikationens inställningar. Genom att abstrahera funktionaliteten attjustera applikationen kan datorns kapacitet utnyttjas, utan varken användarens kunskapeller påverkan. Arbetet undersöker hur olika tekniker kan in uera applikationens prestandaoch genomför tester av ett dynamiskt anpassande systems förmåga att skräddarsy appli-kationen för exekveringsmiljön. / The development of computers and their ability increases the gap between computers andcreate a wide variety of hardware availability. The capacity that computers possess varyconsiderably and thus the ability to handle complex applications. Modern applicationsprovides settings that users can customize for the computer, which requires the user tohave su cient knowledge to understand the attitude of the e ect. To select the optimalsettings for your PC is a process that is both di cult and time consuming. This thesisexamines how a dynamically adaptive system can automatically adjust the settings for theapplication while it is running, without manual external impact. The system continuouslymonitors the application and individual technologies performance. Based on measurementsthe adaptive system can customize applications settings. By abstracting the functionalityto adjust the application the computer's capacity is utlizied, without neither the user'sknowledge or in uence. The thesis examines how various technologies can in uence ap-plication performance and conducts tests of a dynamically adaptive system's ability tocustomize the application for execution environment.

JavaScript (JS) is one of the most popular programming languages due to its flexibility and versatility, but debugging JS code is tedious and error-prone. In our research, we conducted an empirical study to characterize the relationship between co-changed software entities (e.g., functions and variables), and built a machine learning (ML)-based approach to recommend additional entity to edit given developers’ code changes. Specifically, we first crawled 14,747 commits in 10 open-source projects; for each commit, we created one or more change dependency graphs (CDGs) to model the referencer-referencee relationship between co-changed entities. Next, we extracted the common subgraphs between CDGs to locate recurring co-change patterns between entities. Finally, based on those patterns, we extracted code features from co-changed entities and trained an ML model that recommends entities-to-change given a program commit. According to our empirical investigation, (1) 50% of the crawled commits involve multi-entity edits (i.e., edits that touch multiple entities simultaneously); (2) three recurring patterns commonly exist in all projects; and (3) 80–90% of co-changed function pairs either invoke the same function(s), access the same variable(s), or contain similar statement(s); and (4) our ML-based approach CoRec recommended entity changes with high accuracy. This research will improve programmer productivity and software quality. / M.S. / This thesis introduced a tool CoRec which can provide co-change suggestions when JavaScript programmers fix a bug. A comprehensive empirical study was carried out on 14,747 multi-entity bug fixes in ten open-source JavaScript programs. We characterized the relationship between co-changed entities (e.g., functions and variables), and extracted the most popular change patterns, based on which we built a machine learning (ML)-based approach to recommend additional entity to edit given developers’ code changes. Our empirical study shows that: (1) 50% of the crawled commits involve multi-entity edits (i.e., edits that touch multiple entities simultaneously); (2) three change patterns commonly exist in all ten projects; (3) 80-90% of co-changed function pairs in the 3 patterns either invoke the same function(s), access the same variable(s), or contain similar statement(s); and (4) our ML-based approach CoRec recommended entity changes with high accuracy. Our research will improve programmer productivity and software quality.