From: 2024-09-20 10:15 to 14:00
Place: E:2116 and E:4130 (Lucas)
Contact: birger [dot] swahn [at] cs [dot] lth [dot] se

Three Computer Science MSc/BSc theses to be presented on 20 September

Friday, 20 September there will be three master/bachelor thesis presentations in Computer Science at Lund University, Faculty of Engineering.

The presentations will take place in E:2116 and E:4130 (Lucas). See information for each presentation.

Note to potential opponents: Register as an opponent to the presentation of your choice by sending an email to the examiner for that presentation (firstname.lastname@cs.lth.se). Do not forget to specify the presentation you register for! Note that the number of opponents may be limited (often to two), so you might be forced to choose another presentation if you register too late. Registrations are individual, just as the oppositions are! More instructions are found on this page.

10:15-11:00 in E:2116

Presenters: Josefin Wetterstrand, Blenda Öhman
Title: A Comparative Study of Callback Service Solutions
Examiner: Per Andersson
Supervisors: Flavius Gruian (LTH), Erik Gilbertsson (Sinch AB)

Callback services using thread pools with platform threads to send HTTP requests can face bottlenecks when slow-responding web services occupy threads, limiting the availability of resources for handling other requests. This thesis explores how different concurrency models affect the callback delivery and how the performance of callback services varies based on the chosen concurrency model. We specifically compare a concurrency model using blocking threads with three non-blocking alternatives, namely Java Virtual Threads, Spring WebFlux, and Kotlin Coroutines.

To conduct this comparison, we developed a simulator for sending and receiving HTTP requests from an external web service. Performance tests were carried out by using this simulator to evaluate response times, transactions per second and CPU utilization across the different models. In the context of our specific simulation environment, the simulator with Spring WebFlux demonstrated the best performance in terms of response time when handling HTTP requests. Furthermore, we found that not only does the choice of concurrency model impact the performance of the callback service, the choice of libraries within that concurrency model had a significant effect on performance.

Link to popular science summary: To be uploaded

11:15-12:00 in E:4130 (Lucas)

Presenters: Nils Randevik, David Petersson
Title: Evaluation of an AI Assistant Swarm of LLM-based Agents
Examiner: Jacek Malec
Supervisors: Björn Regnell (LTH)

A recent development in the field of AI assistants are swarms, collaborative groups of LLM-based agents. In order to evaluate such systems, we created an assistant prototype using Autogen consisting of a swarm of LLM-based agents. The main evaluation of the prototype was it's result accuracy, meaning the correctness or realism of it's responses when used by a human as an assistant for a given task. We evaluated through user testing, giving test subjects a task to perform using the prototype as an assistant. After evaluating the results and comparing them to the results when using ChatGPT, we found that the number of instances of hallucination was greater when using the swarm prototype. The swarm was more affected by the quality of the human-specified prompts than ChatGPT, with more detailed prompts giving improved results. Suggesting that AI swarms may not be as viable for general use as predicted.

Link to popular science summary: To be uploaded

13:15-14:00 in E:2116

Presenter: Erik Präntare
Title: Decoupling Context Sensitivities From Program Analyses
Examiner: Jonas Skeppstedt
Supervisors: Christoph Reichenbach (LTH)

The area of program analysis aims at automatically computing information about programs. Examples of such information are what values could be stored in the program variables, whether a safety-critical state could occur, or if some required program invariant can be violated. These properties are of interest in many areas and applications, such as program safety, linting and optimizing compilers.

As many properties of programs are not computable, analyses instead compute an approximation of the properties. This approximation introduces false results. To counteract this effect, analyses may implement sensitivities to increase the granularity of the analysis. However, new sensitivities are not immediately applicable to old analyses, or vice versa, owing to the coupling between the analysis and sensitivity.

This thesis provides a method for decoupling the analysis from the sensitivity by expressing the sensitivity as a preprocessing step of the analyzed program. We show that this method is applicable to multiple analyses and sensitivities by applying the method in an implemented proof of concept framework. We also outline the formal requirements for a sensitivity to be possible to decouple in this way, and a formal description for when we can expect the sensitive analysis to preserve the correctness of the nonsensitive analysis.

Link to popular science summary: To be uploaded