reflexion.tex (8370B)
1 \section{Conclusion} 2 3 \subsection{Technically} 4 5 Generally, I think the implementation does its job very well. I was able to implement the required processes and the targeted user-experience. The implementation (in C2EC as well as in the Paydroid app) suffers of some technical debts (listed in \autoref{sec-results-improvements}). I finally accepted them, because I had to prioritize the formal parts of the thesis, such as the poster, video, book entry or this documentation. I could have prevented some of these issues, if I would have read the documentation and specification more carefully. But overall I am satisfied with the work I did concerning the short time span that was available for the implementation. 6 7 \subsubsection{C2EC} 8 9 The implementation of C2EC was the biggest part of my work during the thesis. It is the core of the framework and I had to think about API specification conformance, extensibility, correctness and database integration. I wanted to achieve an architecture, which is similar to the one of the GNU Taler Exchange. This inlcuded to decouple steps in the withdrawal process using triggers and the notify feature of postgres. I learned a lot about how postgres works and how I can write working postgres functions and triggers. First, I failed to properly document the database fields, tables and functions. After a review with Prof. Dr. Christian Grothoff, I learned about the comment functionality of the postgres SQL standard. 10 11 In Go code of the C2EC component I had to implement a robust way to communicate between parallel running processes. The Go concurrency model made this possible in an straight forward and what I think, comprehensible way. I correctly anticipated that it would pay out to first implement the concepts for my requirements in a dummy project and then adapt them to C2EC. Additionally, the implementation of the database access layer behind an interface allows to change the database without changing the entire application. 12 13 Concerning the extensibility of C2EC I was able to implement code level abstractions which allow an seemless integration of additional payment system providers. After the feedback of Prof. Dr. Christian Grothoff I was able to eliminate an unnecessary layer of abstraction, which made it even easier. 14 15 I think I have been able to apply a lot of the knowledge I have gained over the last three years. From time to time I thought: "ah, this is why the professor told us this". This helped me to deepen my understanding of topics like encoding, REST API, concurrency and many more. 16 17 \subsubsection{Paydroid Terminal Application} 18 19 The paydroid application was challenging to me since I never wrote a real Android application on my own. That is why I think I did a good job by implementing a best practice structure with the view models, composable and navigation controller. Thanks to the feedback of Prof. Dr. Benjamin Fehrensen, I was able to improve the design and verify the correctness of these best practices. 20 21 I first had problems to understand how exactly the versioning in Android works. The backward compatibility is given even when big time gaps between the feature needed and the version in use occur. In the beginning I suffered to understand the difference of the none compose and compose era of Android programming and mixed the patterns. After better understanding how features work in jetpack compose I think I implemented a modern Android app. 22 23 Since the app needs to do requests in the background I had to understand how this could be achieved. Therefore, I needed to understand how I can access other threads. I think in this area is the biggest shortcoming of my implementation. I implemented an asynchronous state-handling. Threads running detached from the UI-Thread will update the model, which will lead to the regeneration of the composables. I think it would be a better way to implement a the asynchronous tasks using Androids state flow features. Due to the lack of time I decided to not do this anymore. 24 25 It was interesting to learn about the difference of Go goroutines and Kotlin coroutines. While running background tasks using goroutines works perfectly fine, in Kotlin on Android I learnt it is required to start a new thread and launch coroutines on the new thread. Otherwise Android will not allow network requests, because it disallows I/O operations on its UI thread. From my point of view this shows a limitation of coroutines on top of JVM threads. They are not real parallel but just suspend work on the thread and check periodically if they can process further. If there are thread level restrictions (like the Android restrictions), they will affect the execution of the coroutines on top and like this undermine the concept of coroutines. 26 27 \subsection{Methodically} 28 29 To organize the work I did a rough planning of the work and the artefacts in the beginning. On top of this plan I did a weekly iterative planning of the work I wanted to do. This plan was presented through the weekly meeting with Prof. Dr. Christian Grothoff and Prof. Dr. Benjamin Fehrensen. Sometimes the plan needed to be sligthly adjusted due to their feedback. This led to the organization of doing my planning at Thursday night so I could plan my work and adjust the plan after our weekly meeting at Wednesday morning. I think I could have made the process a bit more transparent but in the end I was able to deliver the artefacts and deliverables on time. Sometimes I lost focus because there were so much loose ends to keep up with. I then did something different and ordered my thoughts. This helped sometimes but not always. When the stress level was rising this was even more difficult. In such situations taking a step back and prioritzing the work helped me. 30 31 \subsection{Personally} 32 33 The world of payment systems seems a bit chaotic to me. I think this is the result of a lot of different approaches for the same problem developed at the same time. Standards exist but they mainly suggest things and do not enforce them. The technical documentation is obfuscated in big documents with a lot of boiler plate text. This makes it very hard to act appropriately without finding out by hand how a process works exactly. For example to bring a Wallee transaction into the fulfill state (which allows the shipping of goods) you must settle the transaction and execeute the final balance. The documentation does not care about this. I had to write e-mails with Wallee to finally understand this. Even the people of Wallee messed up their own transaction states. 34 35 The thesis was constrained with a lot of insecurities for me. How does the process look? How can I implement the process? How does GNU Taler even work? How does Wallee work? In the end I am proud of what I accomplished during the thesis. I was able to understand the different API and write a program which fulfills the properties needed for the withdrawal. Additionally I could learn a lot about designing an API and especially parallelization in Go and Android. 36 37 I am thankful that the Bern University of Applied Sciences supports free software projects like GNU Taler. It was a great opportunity for me as student and as human to gain direct insights and work on a GNU project during my thesis. I remember Prof. Dr. Christian Grothoff telling me during an onsite session: "Nicht so kurzfristig denken!" (do not think short-term). This also showed the horizon of the project to me. It tries to sustainably change the payment landscape for good. That is what I like the most about free software. It is built to last. The world will not get better when we keep pushing towards short-term profit benefiting individuals, global warming and war. GNU Taler and other GNU projects are making a difference and take a humanitarian perspective on technology. Providing technology supporting \textit{humans}. This was the reason I started my journey in computer science with my apprenticeship in 2015 and eventually decided to do my thesis on GNU Taler. It has not changed since. Even when my contribution is small I believe it is important. When everyone adds their ideas and work to the plate, we can achieve a better world. The title picture, generously provided by cartoonist Bruno Fauser \cite{fauser}, visualizes this attitude. Sometimes it is hard to not loose faith for the good, but; the good wins. Always.