Scientific web portal generátor. The entire project, whose part this dissertation is, consists of the users interface GUI, the processes' communication, the softwares communication with a user and of the script for automatic parsering the selected entity by a method of extraction the semantic information from the marked text. The last-named part is a main content of my dissertation. The dissertations objective is a script (prototype), which returns on the basis of an input XML file with names of research workers, an output XML file with URL home pages' addresses and pages' addresses with a list of publications. Great deal of my dissertation will be devoted to the first-rate test datas assembly and in the end to the profound static analysis of the resulting scripts behaviour, which I have programed. This part will survey us about the percentage fruitfulness and about the rate of the designed script. The script will be prepared for the integration into the common project.

The main topics of the thesis are open data, open data initiatives and sustainable mobility. Current state of open data made available by the Prague city administration is explored. Successful open data initiatives from abroad, that use open data to contribute to sustainable mobility, are examined. Results of the study of open data in driving sustainable mobility in nine smart cities are partially replicated and extended using the state of open data in Prague. Results of the author's own research aimed at Prague are compared with results of this study and complement them. Interviews with representatives of foreign open data initiatives in the field of sustainable mobility are used to examine the inception, day-to-day activities, roles they play and key aspects of operations of these initiatives. Results from both parts of the thesis are combined with an overview of literature on the topic. Possibilities of further development of both the open data in Prague in general and the sustainable mobility initiatives in Prague working with open data are presented.

In this paper, design decisions to improve usability in APIs for implementations of DUI applications has been investigated. Namely what abstractions an API like that should provide to the programmer, and how those abstractions should be presented syntax-wise to the programmer in the API. The exploration was done with a literature study, development of a game prototype with a DUI API, and three user sessions where an interview, and a sketch task was done with the participating developers.

[pt] APIs (do inglês - application programming interfaces) desempenham um papel crucial no desenvolvimento de software. Quase todos os programadores estão frequentemente na posição de utilizar APIs de terceiros. Atualmente, encontramos várias pesquisas que procuram explorar e compreender as interações dos usuários com a API do ponto de vista da usabilidade. No entanto, tais estudos deixam de fora um aspecto importante da qualidade de uso de uma API, a comunicabilidade. Ao contrário da usabilidade, cuja definição está associada à facilidade de uso e aprendizagem, a comunicabilidade está associada à capacidade de um artefato de comunicar sua lógica de projeto. Uma API que carece de comunicabilidade pode levar os usuários ao uso indevido e produzir bugs em seu código. Esta tese de doutorado aborda este problema a partir de uma perspectiva de Engenharia Semiótica. Ao caracterizar uma API como um artefato mediador da comunicabilidade, começamos nossa tese com a proposta de que as APIs deveriam ser coloquiais. Diagnosticamos em nosso primeiro estudo que os usuários, em certos casos, têm dificuldade em compreender a lógica interna de funcionamento de um API apenas olhando para suas interfaces. Neste estudo, descobrimos que as APIs muitas vezes carecem de comunicabilidade. Enquanto a usabilidade é sobre a capacidade do usuário de aprender e usar uma API, a comunicabilidade é sobre a capacidade da API de transferir a comunicação do projetista para o usuário, expondo assim sua lógica de projeto. Uma API conversacional é aquela que pode expor sua lógica interna através de suas interfaces, atendendo aos contextos pragmáticos de seus usuários. A partir deste estudo, nós nos propusemos então a definir o que é uma API conversacional na prática e a investigar quais métodos ou tecnologias seriam necessários para auxiliar os projetistas na criação de tais APIs. Nesta tese, propomos uma estrutura conceitual e um método para apoiar o projeto de APIs de conversação. Ao projetar uma API, o projetista tem em mãos três maneiras diferentes de enviar sua mensagem ao seu usuário: o código fonte, a documentação e o comportamento da API. Nossa estrutura conceitual explora como caracterizar e classificar uma API de conversação de acordo com os três tipos de mensagens da perspectiva do projetista. Nosso método de apoio ao projeto da API de conversação, que foi inspirado nos resultados e lições aprendidas de uma pesquisa-ação que realizamos, consiste em três etapas. O primeiro passo é ajudar o projetista a identificar quem são os usuários da API e suas necessidades de conversação específicas. Na segunda etapa, o método ajuda o projetista na modelagem de possíveis conversas de API com os diferentes usuários mapeados para atingir seus objetivos. Finalmente, o método fornece um conjunto de diretrizes para guiar o projetista na definição das interfaces API, incluindo sua parametrização. Usando este método, realizamos um estudo de caso com um projeto de API, que visa apoiar a refatoração de programas Java. Do ponto de vista do projetista da API, o método o ajudou a criar empatia com seus usuários e a melhor derivar e refletir sobre os requisitos e conversas que a API deve fornecer aos diferentes perfis de usuários. / [en] APIs (application programming interfaces) play a crucial role in software development. Almost any programmer is often at the position of using thirdparty APIs. Currently, we find several researches that seek to explore and understand users interactions with the API from an usability point of view. However, such studies leave out an important aspect of an API quality of use, the communicability. Unlike usability, whose definition is associated with ease of use and learning, communicability is associated with an artifact s ability to communicate its design logic. An API that lacks communicability can lead users to misuse and produce bugs in their code. This doctoral thesis addresses this problem from a Semiotic Engineering perspective. By characterizing an API as a mediating artifact for communicability, we started our thesis with the proposal that APIs should be conversational. We diagnosed in our first study that users, in certain cases, have difficulty in understanding the internal operating logic of an API just by looking at its interfaces. In this study, we found that APIs often lack in communicability. While usability is about the user s ability to learn and use an API, communicability is about the API s ability to transfer the designer communication to the user, thus exposing its design rationale. A conversational API is the one that can expose its internal logic through its interfaces, attending the pragmatic contexts of its users. From this study, we then set out to define what a conversational API is in practice and to investigate what methods or technologies would be needed to assist designers in creating such APIs. In this thesis, we propose a conceptual framework and a method to support the design of conversational APIs. When designing an API, the designer has in hands three different ways to send his message to his user: the source code, the documentation, and the behavior of the API. Our conceptual framework explores how to characterize and classify a conversational API according to the three types of messages from the designer s perspective. Our method of supporting conversational API design, which was inspired by the results and lessons learned from an action-research we conducted, consists of three steps. The first step is to help the designer on identifying who the API users are and their specific conversational needs. In the second step, the method helps the designer on modeling possible API conversations with the different mapped users to achieve their goals. Finally, the method provides a set of guidelines to guide the designer in defining the API interfaces, including their parameterization. Using this method, we perform a case study with an API design, which aims at supporting the refactoring of Java programs. From the API designer s point of view, the method helped him on creating empathy with his users and better deriving and reflecting upon the requirements and conversations that the API should provide to the different user profiles.

In recent years, voxel-based modelling has seen a reintroduction to computer game development through massive graphics hardware improvements. Never- theless, polygons continue to be the default building block of 3D objects, intro- ducing a need for the transformation of polygon meshes into voxel-based models; this process is known as voxelization. Efficient voxelization algorithms take ad- vantage of the flexibility and control offered by modern, programmable GPU pipelines. However, the variability in possible approaches poses the question of how different GPU-based implementations affect voxelization performance.This thesis explores the impact of GPU-based improvements by comparing four different implementations of a solid voxelization algorithm. The implemen- tations include a naive transition from the CPU to the GPU, a non-branching execution path approach, data pre-processing, and a combination of the two previous approaches. Benchmarking experiments run on four, standard polygo- nal models and three graphics cards (NVIDIA and AMD) provide runtime and memory usage data for each implementation. A comparative analysis is per- formed on the basis of this data to determine the performance impact of the GPU-based adjustments to the voxelization algorithm implementation.Results indicate that the non-branching execution path approach yields clear improvements over the naive implementation, while data pre-processing has in- consistent performance and a large initial performance cost; the combination of the two improvements unsurprisingly leads to combined results. Therefore, the conclusive recommendation is using the non-branching execution path technique for GPU-based improvements. / Voxel-baserad modellering har på senare år blivit återintroducerat till datorspelsutveckling tack vare massiva förbättringar i grafikhårdvara. Trots detta fortsätter polygoner att vara standarden för uppbyggnaden av 3D-objekt. Detta gör det nödvändigt att kunna transformera polygonytor till voxel-baserade modeller; denna process kallas för voxelisering. Effektiva voxeliseringsalgoritmer tar vara på den flexibilitet och kontroll som ges av moderna, programmerbara GPU-pipelines. Variationen i möjliga tillvägagångssätt gör det dock intressant att veta hur olika GPU-baserade implementationer påverkar prestandan av voxeliseringen. Denna avhandling undersöker påverkan av GPU-baserade förbättringar genom att jämföra fyra olika implementationer av en solid-voxeliseringsalgoritm. Implementationerna inkluderar en naiv övergång från CPU:n till GPU:n, en metod med en non-branching exekveringsväg, förbehandling av data, och en kombination av det två tidigare metoderna. Benchmarkingexperiment görs på fyra standardpolygonmodeller och tre grafikkort (NVIDIA och AMD) förser data för exekveringstid och minnesåtgång för varje implementation. En jämförande analys görs med detta data som grund för att bestämma den påverkan som de GPU-baserade ändringarna har på prestandan av voxeliseringsalgoritmens implementation. Resultaten indikerar att implementationen med en non-branching exekveringsväg ger klara förbättringar över den naiva implementationen, medans förbehandlingen av data presterar inkonsekvent och har en stor initial prestandakostnad; kombinationen av dem båda ledde, inte överraskande, till blandade resultat. Den slutgiltiga rekommendationen är således att använda tekniken med en non-branching exekveringsväg för GPU-baserade förbättringar.

There is problem that every company has its own customer portal. This problem can be solved by creating a platform that gathers all customers’ portals in one place. For such platform, it is required a web API protocol that is fast, secure and has capacity for many users. Consequently, a survey of various web API protocols has been made by testing their performance and security. The task was to find out which web API protocol offered high security as well as high performance in terms of response time both at low and high load. This included an investigation of previous work to find out if certain protocols could be ruled out. During the work, the platform’s backend was also developed, which needed to implement chosen web API protocols that would later be tested. The performed tests measured the APIs’ connection time and their response time with and without load. The results were analyzed and showed that the protocols had both pros and cons. Finally, a protocol was chosen that was suitable for the platform because it offered high security and fast connection. In addition, the server was not affected negatively by the number of connections. Reactive REST was the web API protocol chosen for this platform. / Det finns ett problem i dagens samhälle gällande att varje företag har sin egen kundportal. Detta problem kan lösas genom att skapa en plattform som samlar alla kundportaler på samma plats. För en sådan plattform krävs det ett web API protokoll som är snabb, säker och har kapacitet för många användare. Därför har en undersökning om olika web API protokolls prestanda samt säkerhetstester gjorts. Arbetet gick ut på att ta reda på vilket web API protokoll som erbjuder hög säkerhet och hög prestanda i form av svarstid både vid låg och hög belastning. Det ingick också i arbetet att göra en undersökning av tidigare arbeten för att ta reda på om eventuella protokoll kunde uteslutas. Under arbetet utvecklades också plattformens backend som implementerade de olika web API protokollen för att sedan kunna utföra tester på dessa. Testerna som utfördes var svarstid både med och utan belastning, uppkopplingstid samt belastning. Resultaten analyserades och visade att protokollen hade både för- och nackdelar. Avslutningsvis valdes ett protokoll som var lämpad för plattformen eftersom den hade hög säkerhet samt snabbast uppkopplingstid. Dessutom påverkades inte servern negativt av antalet uppkopplingar. Reactive REST valdes som web API protokoll för denna plattform.

This thesis presents a comprehensive security analysis of the Server-Server API of the Matrix protocol, providing a detailed examination of its vulnerabilities and contributing a significant body of knowledge to the cybersecurity field. The research focused exclusively on the Server-Server API of the Matrix protocol. Despite the testing of 2 vulnerabilities that did not succeed, the primary contribution of this work lies in the in-depth threat analysis and the identification of 16 critical, yet untested, vulnerabilities that may be probed in future research. The findings reveal that the Matrix protocol’s Server-Server API currently maintains a competent level of security. However, the uncovered vulnerabilities highlight the necessity for continuous and proactive security measures within its ongoing development. The practical implications of the identified vulnerabilities are substantial, with relevance extending to similar APIs in the broader digital communication landscape. The rigorous penetration testing methodology following rigorous standards, coupled with systematic documentation, ensures a trustworthy basis for the study’s conclusions. In essence, this thesis does not only answer the research question by identifying and documenting current security weaknesses within the Server-Server API but also establishes a methodological foundation for future security enhancement initiatives. By doing so, it adds valuable insights to the cybersecurity community, with implications for developers, researchers, and users alike, emphasizing the need for a persistent and vigilant approach to API security in the evolving digital era / Denna avhandling presenterar en omfattande säkerhetsanalys av Server-Server API:et för Matrix-protokollet, och bidrar med en utvärdering av dess sårbarheter och betydande kunskap till cybersäkerhetsområdet. Forskningen fokuserade uteslutande på Server-Server API:et för Matrix-protokollet. Trots penetrationstestningen av två sårbarheter som inte lyckades, ligger det primära bidraget från detta arbete i den djupgående hotanalysen och identifieringen av 16 kritiska, ännu otestade, sårbarheter som kan utforskas i framtida forskning. Resultaten visar att Matrix-protokollets Server-Server API för närvarande upprätthåller en bra säkerhetsnivå. De upptäckta sårbarheterna betonar dock nödvändigheten av kontinuerliga säkerhetsåtgärder inom dess pågående utveckling. De praktiska konsekvenserna av de identifierade sårbarheterna är betydande, med relevans som sträcker sig till liknande API:er i det bredare digitala kommunikationslandskapet. Den noggranna metodiken för penetrationstestning enligt strikta standarder, tillsammans med systematisk dokumentation, säkerställer en tillförlitlig grund för studiens slutsatser. I grund och botten svarar denna avhandling inte bara på forskningsfrågan genom att identifiera och dokumentera nuvarande säkerhetsbrister inom Server-Server API:et utan etablerar också en metodologisk grund för framtida säkerhetsförstärkningsinitiativ. Genom att göra detta tillför den värdefulla insikter till cybersäkerhetsgemenskapen, med implikationer för utvecklare, forskare och användare lika, vilket betonar behovet av en ihärdig och vaksam inställning till API-säkerhet i den utvecklande digitala eran.

An Application Programming Interface (API) provides developers with a high-level framework that abstracts the underlying implementation of services. Using an API reduces the time developers spent on implementation, and it encourages collaboration and innovation from third-party developers. Making an API public has a risk: developers might use it inappropriately. Most APIs have a policy that states which behaviors are considered fraudulent. Detecting applications that fraudulently use an API is a challenging problem: it is unfeasible to review all applications that make requests. API providers aim to implement an automatic tool that accurately detects suspicious applications from all the requesting applications. In this thesis, we study the possibility of using machine learning techniques to detect fraud in Web APIs. We experiment with supervised learning methods (random forests and gradient boosting), clustering methods such as Density-Based Spatial Clustering of Applications with Noise (DBSCAN), and ensemble methods that combine the predictions of supervised learning methods and clustering methods. The dataset available contains data gathered when a developer creates an application and data collected when the application starts making HTTP requests. We derive a meaningful representation from the most important textual fields of the dataset using Sentence-BERT (S-BERT). Furthermore, we experiment with the predictive importance of the S-BERT embeddings. The method that achieves the best performance in the test set is an ensemble method that combines the results from the gradient boosting classifier and DBSCAN. Furthermore, this method performs better when using the S-BERT embeddings of the textual data of the applications, achieving an f1-score of 0.9896. / Ett API (Application Program Interface) ger utvecklare ett högnivåramverk som abstraherar den underliggande implementationen av tjänster. Användning av ett API reducerar tiden utvecklare lägger på implementation, och uppmuntrar samarbete med och innovation av tredjeparts-utvecklare. Att göra ett API publikt har ett risk: utvecklare kan utnyttja den på olämpliga sätt. De flesta API:erna har ett policy som beskriver beteenden som räknas som bedrägliga. Upptäckandet av applikationer som använder ett API på ett bedrägligt sätt är ett icke-trivialt problem, det är omöjligt att undersöka alla applikationer som skickar begäran till API:et. API leverantörerna siktar ständigt på att skapa ett automatiskt verktyg för att exakt upptäcka applikationer misstänkta för bedrägeri. I denna avhandling undersöks möjligheten av användning av maskininlärning för att upptäcka bedrägeri i Web API. Vi experimenterar med övervakad inlärningsmetoder (random forests och gradient boosting), klustring metoder som Density-Based Spatial Clustering of Applications with Noise (DBSCAN) och ensemble metoder som kombinerar prediktionerna av övervakad inlärningsmetoder och klustring metoder. Det tillgängliga datasetet innehåller data samlat när en utvecklare skapar en applikation och när den börjar skicka HTTP begäran. Vi härleder en meningsfull representation från de viktigaste textfälten i datasetet med hjälp av Sentence-BERT (SBERT). Dessutom experimenterar vi med den prediktiva betydelsen av S-BERT-inbäddningarna. Metoden som uppfyller den bästa prestandan i testsetet är ett ensemble metod som kombinerade resultaten från gradient boosting klassificeraren och DBSCAN. Denna metod presterar även bättre vid användning av S-BERT-inbäddnignarna av applikationernas textdata och därav uppnår ett f1-score på 0.9896.

This degree project proposes a novel architecture for IoT systems, utilizing smartphones as edge devices and running the value-creating software such as preprocessing, anomaly detection, and deriving data-based insights in the web browser as opposed to natively on the device. Utilizing the smartphone as an edge device reduces cost of adoption for IoT technologies since less hardware has to be included in the system compared to bundling a device for processing with the system. However, in typical implementations, these smartphones are running native applications that are necessarily bound by the policy set up by the owners of the major application marketplaces through which the applications are distributed, that among other things enforce a heavy revenue-sharing program. Furthermore, this sytem is not convenient for the user since they have to download an application they may only use once or sparingly, and it relies on the compatibility between the operating system and the application. Running the application in the browser as opposed to natively would solve these issues. This work also explores the experimental WebUSB API and investigates its applicability in IoT systems. Specifically, this work explores two constructed scenarios that showcase the promise of this novel architecture to extrapolate how it can be utilized for other purposes. These two constructed scenarios are successfully implemented, and various metrics to analyse their performance and real world applicability are discussed. In one experiment, a QR-scanning application is implemented in the browser, and showcases an average frame rate of over 60 frames per second while rendering a live video feed of the contents captured by the camera as well as a loading animation, and an average time to completion for scanning a QR code of 0,204 seconds after initiating the scan. In another experiment, a firmware update is simulated by transferring encrypted data from the browser via the WebUSB API to a microcontroller. Due to the limitations of the experimental setup, the implementation could showcase a transfer of no more than 29 KB of encrypted data in 10 seconds. However, the implementation successfully shows that the browser can remain interactive even while performing these transferring operations, and that there are good APIs in place for developers to easily access the advanced sensors of the phone, and that the WebUSB API has good safety measures in place. Furthermore, the work successfully demonstrates how the WebUSB API can be utilized in IoT systems as a novel way of transferring data that holds great implications for the future of IoT systems in general, and the web in particular. To conclude, the work finds that the modern web browser works well as an environment for IoT applications, and that it has good access to the advanced sensors of the smartphone, and that theWebUSB API can effectively be utilised for data transfer in IoT applications. / Detta examensarbete föreslår en ny arkitektur för IoT-system som använder smarta telefoner som edge-enheter som behandlar den data de tar emot i webbläsaren, snarare än nativt på enheten. Att använda smarta telefoner som en edge-enheter minskar kostnaden för användning av IoT-teknologier eftersom mindre hårdvara behöver ingå i systemet, eftersom viss funktionalitet istället kan substitueras av den smarta telefonen. I typiska implementationer kör dessa smarta telefoner nativa applikationer som nödvändigtvis är bundna av de regelverk som fastställts av ägarna av de stora applikationsmarknaderna genom vilka applikationerna distribueras, vilket bland annat påtvingar applikationsägarna att ge bort stora delar av sina intäkter. Dessutom är detta system inte bekvämt för användaren eftersom de måste ladda ner en applikation de bara kommer använda ett fåtal gånger, och som dessutom är beroende av kompatibiliteten med operativsystemet. Att istället köra en motsvarande applikation i webbläsaren löser dessa problem. Detta arbete utforskar också det experimentella WebUSB API:t och undersöker dess användbarhet i IoT-system. Specifikt utforskar detta arbete två konstruerade scenarier som visar potentialen i denna nya arkitektur för att extrapolera hur den kan användas för andra ändamål. Dessa två konstruerade scenarier implementeras framgångsrikt och olika mått för att analysera deras prestanda och verkliga tillämpbarhet diskuteras. I ett experiment implementeras en QR- skanningsapplikation i webbläsaren och uppnår en genomsnittlig bildfrekvens på över 60 bildrutor per sekund samtidigt som en live videoström av innehållet som fångas av kameran och en laddningsanimation visas på skärmen. Vidare uppnådde applikationen en genomsnittlig tid för tolkning av QR-koder på 0,204 sekunder, från och med det att skanningen inleddes. I ett annat experiment simuleras en programvaruuppdatering genom att överföra krypterad data från webbläsaren via WebUSB API:t till en enkretsdator. På grund av begränsningarna i experimentet kunde implementationen inte visa en överföring högre än 29 KB krypterad data på 10 sekunder. Implementationen visar dock framgångsrikt att webbläsaren kan förbli interaktiv även när de utför dessa överföringsåtgärder, och att det finns bra API: er för utvecklare att enkelt få tillgång till telefonens avancerade sensorer och att WebUSB API:t har goda säkerhetsmekanismer på plats. Dessutom demonstrerar arbetet framgångsrikt hur WebUSB API:t kan användas i IoT-system som ett nytt sätt att överföra data som har stora implikationer för framtiden för IoT-system i allmänhet och på webbläsare och webbapplikationer synnerhet. Avslutningsvis konstaterar arbetet att den moderna webbläsaren fungerar bra som en miljö för IoT-system och att den har god tillgång till den smarta telefonens avancerade sensorer och att WebUSB API:t framgångsrikt kan användas för dataöverföring i IoT-system.

This thesis looks into how to implement an abstraction layer between transaction data gathered from Revised Payment Services Directive (PSD2) compliant banks via an Application Programming Interface (API) and a data base, with a human user interface for reading and structuring the data. API for data sources tend to not have a standardized structure and this creates a problem for machine learning. The result is that the machine learning component either has to be built around the data collected from the API or the data to be transformed and reformatted to fit the structure of the machine learning component's database. An application will use the abstraction layer to fetch data and to allow the user to set up how the data should be reformatted before being sent to the machine learning component's database. The application has to display the data in an easy to read format and the application needs to be usable by a human user. The main questions are (i) how this abstraction should be implemented, (ii) how much of it can be automated, and (iii) what is the optimal design for the components. PSD2 open banking systems in Sweden are using Representational State Transfer (REST) API and provide data in the JavaScript Object Notation (JSON) format, and can be considered the de facto standard. The abstractions can be divided into three areas: Authorization, Account and transaction access, and Transaction data. Out of these areas only the transaction data could be abstracted fully. The account and transaction access process could be partly abstracted while the authorization process can only be broken down into steps as there is no possibility of abstracting the parameters used by the different banks. The project aimed to produce a fully functioning application for gathering data via PSD2 open banking where the user can configure the application through a simple system that does not require the user to have a lot of knowledge about coding. While the process of fetching transaction data from PSD2 API is simplified, the goal of being useful to a person without knowledge of coding is currently impossible unless PSD2 open banking is standardized or more advanced tools are used. / Den här uppsatsen undersöker hur man kan implementera ett abstraktionslager mellan transaktionsdata samlat från Revised Payment Services Directive (PSD2) kompatibla banker via en Application Programming Interface (API) och en databas, med en gränssnitt för människor att använda för att läsa och strukturera data. APIer för datakällor tenderar mot att inte ha en standardiserad struktur och det skapar problem för maskininlärning. Det resulterar i att maskininlärningskomponenten måste antingen byggas runt datan som hämtas från APIer eller att datan transformeras och oformaterad för att passa strukturen för maskininlärningskomponentens databas. Applikation behöver visa datan på ett format som är enkelt att läsa och vara lätt för en människa att använda. Huvudfrågorna är (i) hur abstraktionen ska implementeras, (ii) hur mycket som kan automatiseras, och (iii) vad optimala designen är för komponenterna. PSD2 open banking system i Sverige använder sig av Representational State Transfer (REST) APIer och ger data i JavaScript Object Notation (JSON) formatet och kan anses som en de facto standard. Abstraktionerna kan delas in i tre områden: auktorisering, tillgång till konton och transaktioner, och transaktionsdata. Av dessa tre områden så var det endast transaktionsdata som kunde fullt abstrakternas. Processen för tillgång till konton och transaktioner kunde delvis abstrakternas medan auktorisering kunde endast brytas ner i steg eftersom det inte finns någon möjlighet att abstraktera parametrarna som används av olika banker. Det här projektet försökte producera en fullt fungerande applikation för att samla data via PSD2 kompatibla open banking system där användaren kan konfigurera applikationen genom ett simpelt system där användaren inte skulle behöva erfarenhet om kodning. Processen för att hämta transaktionsdata från PSD2 APIer kan förenklas, men målet var att det skulle vara användbart för en person som inte kan programmering är omöjligt att nå om PSD2 open banking inte standardiseras eller mer avancerade verktyg används.