A robot driving around a room often observes an object from an awkward position, where it may be partly hidden behind furniture, too distant, or lit from behind. A conventional vision pipeline runs an object detector on whatever image is available and accepts the result even when confidence is low. A robot on wheels, unlike a fixed camera, has a further option open to it: moving to a different position and observing again. Choosing where to look next, rather than only interpreting what is already in view, is known as active perception.
In this reading seminar (Lesegruppe), students will explore how Bitcoin works as a peer-to-peer electronic cash system and investigate selected protocol features, proposed changes, and wallet designs in depth.
A robot driving around a room often observes an object from an awkward position, where it may be partly hidden behind furniture, too distant, or lit from behind. A conventional vision pipeline runs an object detector on whatever image is available and accepts the result even when confidence is low. A robot on wheels, unlike a fixed camera, has a further option open to it: moving to a different position and observing again. Choosing where to look next, rather than only interpreting what is already in view, is known as active perception.
Language models can generate plausible code that fails its tests. This thesis investigates whether internal attention patterns predict failure before generation finishes, allowing computation to shift toward more promising candidates. The student will build on the Prober repository to train and evaluate lightweight prediction models.
Swarms of unmanned aerial vehicles (UAVs) are used in search and rescue, infrastructure inspection, and environmental monitoring. An operator supervising such a swarm has to follow many vehicles at once, understand where they are relative to one another, and issue commands to groups rather than to single drones. Ground control stations present this three-dimensional situation on flat screens, which leaves the operator to reconstruct the spatial picture mentally. A Mixed Reality (MR) headset can instead place drone positions, planned trajectories, and status information in the space where the drones actually fly.
This project uses small quadcopter drones, open-source research platforms known as Crazyflies, which are light enough to fly safely inside an ordinary room. Since GPS is unavailable indoors, position has to be established by other means, and these drones rely on a room-tracking system called Bitcraze Lighthouse. Small base stations mounted around the flight area, originally developed for virtual-reality headsets, sweep invisible infrared light across the space, while a receiver board on each drone detects these sweeps and computes its own position onboard many times per second. With four base stations placed around the room, the same calibrated setup can track a single drone or a small group.
Context
Modern LLMs are increasingly enhanced with the ability to interact with external tools such as:
- Code interpreters
- Search engines
- Databases
- Simulated environments
Context
The Apertus project from EPFL, ETH, focuses on developing a Swiss-based Large Language Model (LLM) with strong multilingual capabilities. While the model performs competitively on general language tasks, it currently struggles with structured programming challenges such as:
- Long-horizon reasoning over multiple files
- Code refactoring and abstraction
- Repository-level understanding
- Debugging and test-driven development
- Reliable code generation under constraints
Modern AI coding tools allow developers and agents to generate hundreds of lines of code in seconds. However, our standard processes for managing software—like Git feature branches and pull requests—were created over two decades ago when writing code by hand was a slow process. Because code generation is now nearly instant, the main bottleneck in software engineering has shifted from writing code to reviewing, testing, and integrating it.
AI coding assistants are now widely used in professional software development. The prompts developers write, the responses they receive, the subsequent edits they make, and the rework they perform before committing code remain almost entirely invisible for in-depth analysis. Without access to the full interaction between developer intent (i.e., a prompt) and AI output, it is not possible to study whether AI-generated code actually addresses what the developer needed.
Foundation models let a robots accept missions in natural language, but they also let a wrong or malicious instruction reach the propellers. PEACE [1] is a planner–executor agent for robots in which a large language model emits a complete, typed mission plan in a single call, and an independent safety service validates every motion command before actuation. That service currently enforces two geometric constraints: an altitude band and a horizontal geofence. It cannot express, let alone enforce, the rules that matter in the real world: keep distance from people, do not hover in front of windows, maintain a minimum altitude over roads, respect regulatory limits. This project replaces the geometric check with a two-tier guardrail: a plan-level check that grounds natural-language safety rules into formal specifications and verifies the whole mission plan before dispatch, and an execution-level check that grounds the same rules into spatial keep-out sets around detected objects.
Large language models (LLMs) are increasingly used as high-level planners for robots: a natural-language mission is turned into a sequence of actions that a classical controller executes. Recent work has shown that such LLM-controlled robots can be jailbroken into performing physically harmful actions, often with 100% attack success, on commercial platforms [1]. Proposed defenses either wrap the planner in a guardrail [2] or restrict what the planner may emit. Planner–executor agents such as PEACE [3] take the second route: the LLM produces a single, fully typed plan over a fixed tool schema instead of free-form code or a step-by-step reasoning loop. Whether this architectural choice actually reduces the attack surface has never been measured. This project builds a reusable red-teaming harness for LLM-enabled robot planners in simulation and uses it to compare architectures under a common set of attacks.
Indoor service robots carry medication, lab samples, and supplies through hospital corridors and move goods through warehouse aisles. They share this space with people who are not trained operators and who are often not paying attention to the robot. Navigation policies for such robots are increasingly learned through reinforcement learning or imitation. When a learned policy meets a situation outside its training data, it still produces an action, and nothing in that action tells the robot or its operator that the policy may be wrong.
The idea of this project is to extend an exsting dataset for Android apps and their third-party libraries. Our current research relies on a foundational dataset of Android hybrid applications to analyze Third-Party Library (TPL) usage and associated security risks. The dataset contains currently Flutter, .NET MAUI, React Native, and Apache Cordova apps and we want to extend this with additional frameworks, such as Ionic or Unity. While we already maintain an automated data acquisition pipeline, this seminar project focuses on extending its capabilities to systematically crawl, download, and build applications built with additional modern hybrid frameworks (such as Ionic, Unity, etc.) from public repositories (e.g., GitHub, Gitlab, etc.). Crucially, this project will also expand the pipeline and dataset to include purely native Android applications. This native inclusion will serve as a vital control group, enabling comparative benchmarks that highlight architectural, performance, and security differences between native and cross-platform paradigms.
Modern Android applications are increasingly built using hybrid frameworks such as React Native, Flutter, and Cordova, allowing developers to deploy apps across multiple platforms with a single codebase. Like native apps, hybrid applications heavily rely on Third-Party Libraries (TPLs) to accelerate development and integrate functionalities like analytics, advertising, and UI components. However, TPLs can introduce severe security vulnerabilities and privacy risks. While numerous techniques exist to detect TPLs in native Android applications (analyzing Dalvik bytecode), identifying TPLs in hybrid apps remains a significant challenge. This project aims to bridge this gap by investigating the structure of hybrid apps and developing a novel approach to accurately detect embedded TPLs within their non-native components (e.g., JavaScript bundles, Dart binaries).
This topic investigates unsupervised anomaly detection for merge conflict resolution in software engineering. Existing approaches generally formulate conflict resolution as supervised classification over predefined resolution labels. However, even a large labeled dataset may contain rare, unusual, or incorrectly reconstructed cases, and the labels may not adequately represent the full diversity of merge behavior. This project will develop methods to identify anomalous merge conflicts using the available conflict representations while initially ignoring the nine resolution labels. The objective is to determine whether anomaly scores can identify unusual conflict structures, rare resolution patterns, or cases that are difficult for conventional classifiers.
Low-cost robotic arms are usually driven by scripts that command each joint directly, which is adequate for a demonstration but rarely transfers to the next project and offers no protection against the arm moving through an obstacle or into itself. Robotics addresses this with two standard pieces of software: the first gives programs a common way to communicate with real or simulated motors and is called ROS 2 Control, while the second computes the joint angles needed to reach a position, checks the path for collisions, and plans a safe movement, and is called MoveIt 2. Taken together, they turn a one-off script into a reusable arm setup that transfers between simulation and hardware.
Language models can generate plausible code that fails its tests. This thesis investigates whether internal attention patterns predict failure before generation finishes, allowing computation to shift toward more promising candidates. The student will build on the Prober repository to train and evaluate lightweight prediction models.
The idea of this project is to extend an exsting dataset for Android apps and their third-party libraries. Our current research relies on a foundational dataset of Android hybrid applications to analyze Third-Party Library (TPL) usage and associated security risks. The dataset contains currently Flutter, .NET MAUI, React Native, and Apache Cordova apps and we want to extend this with additional frameworks, such as Ionic or Unity. While we already maintain an automated data acquisition pipeline, this seminar project focuses on extending its capabilities to systematically crawl, download, and build applications built with additional modern hybrid frameworks (such as Ionic, Unity, etc.) from public repositories (e.g., GitHub, Gitlab, etc.). Crucially, this project will also expand the pipeline and dataset to include purely native Android applications. This native inclusion will serve as a vital control group, enabling comparative benchmarks that highlight architectural, performance, and security differences between native and cross-platform paradigms.
In this reading seminar (Lesegruppe), students will explore how Bitcoin works as a peer-to-peer electronic cash system and investigate selected protocol features, proposed changes, and wallet designs in depth.
Modern AI coding tools allow developers and agents to generate hundreds of lines of code in seconds. However, our standard processes for managing software—like Git feature branches and pull requests—were created over two decades ago when writing code by hand was a slow process. Because code generation is now nearly instant, the main bottleneck in software engineering has shifted from writing code to reviewing, testing, and integrating it.
Context
Modern LLMs are increasingly enhanced with the ability to interact with external tools such as:
- Code interpreters
- Search engines
- Databases
- Simulated environments
Context
The Apertus project from EPFL, ETH, focuses on developing a Swiss-based Large Language Model (LLM) with strong multilingual capabilities. While the model performs competitively on general language tasks, it currently struggles with structured programming challenges such as:
- Long-horizon reasoning over multiple files
- Code refactoring and abstraction
- Repository-level understanding
- Debugging and test-driven development
- Reliable code generation under constraints
Language models can generate plausible code that fails its tests. This thesis investigates whether internal attention patterns predict failure before generation finishes, allowing computation to shift toward more promising candidates. The student will build on the Prober repository to train and evaluate lightweight prediction models.
Language models can generate programming exercises and solutions, but incorrect answers, weak tests, and repetitive tasks can limit their value as training data. This thesis builds on CodifieRL to generate synthetic coding tasks from real repositories and investigate whether execution-based filtering improves their quality and usefulness for training code models.
This project uses small quadcopter drones, open-source research platforms known as Crazyflies, which are light enough to fly safely inside an ordinary room. Since GPS is unavailable indoors, position has to be established by other means, and these drones rely on a room-tracking system called Bitcraze Lighthouse. Small base stations mounted around the flight area, originally developed for virtual-reality headsets, sweep invisible infrared light across the space, while a receiver board on each drone detects these sweeps and computes its own position onboard many times per second. With four base stations placed around the room, the same calibrated setup can track a single drone or a small group.
In this reading seminar (Lesegruppe), students will explore how Bitcoin works as a peer-to-peer electronic cash system and investigate selected protocol features, proposed changes, and wallet designs in depth.
The idea of this project is to extend an exsting dataset for Android apps and their third-party libraries. Our current research relies on a foundational dataset of Android hybrid applications to analyze Third-Party Library (TPL) usage and associated security risks. The dataset contains currently Flutter, .NET MAUI, React Native, and Apache Cordova apps and we want to extend this with additional frameworks, such as Ionic or Unity. While we already maintain an automated data acquisition pipeline, this seminar project focuses on extending its capabilities to systematically crawl, download, and build applications built with additional modern hybrid frameworks (such as Ionic, Unity, etc.) from public repositories (e.g., GitHub, Gitlab, etc.). Crucially, this project will also expand the pipeline and dataset to include purely native Android applications. This native inclusion will serve as a vital control group, enabling comparative benchmarks that highlight architectural, performance, and security differences between native and cross-platform paradigms.
This topic investigates the quality and correctness of nine automatically assigned labels for merge-conflict resolutions. The labels were reconstructed by replaying historical Git merges and mapping the tentative conflict representation to the final developer-committed file. Such mappings are reproducible and scalable, but they can be affected by formatting changes, reordered code, structural edits, ambiguous correspondence between conflict chunks, and compound resolutions. The project will develop methods to detect potentially incorrect, ambiguous, or unstable labels and will validate a sample of these cases through systematic inspection. The work combines supervised, unsupervised, and weakly supervised methods for label-quality assessment.
The idea of this project is to extend an exsting dataset for Android apps and their third-party libraries. Our current research relies on a foundational dataset of Android hybrid applications to analyze Third-Party Library (TPL) usage and associated security risks. The dataset contains currently Flutter, .NET MAUI, React Native, and Apache Cordova apps and we want to extend this with additional frameworks, such as Ionic or Unity. While we already maintain an automated data acquisition pipeline, this seminar project focuses on extending its capabilities to systematically crawl, download, and build applications built with additional modern hybrid frameworks (such as Ionic, Unity, etc.) from public repositories (e.g., GitHub, Gitlab, etc.). Crucially, this project will also expand the pipeline and dataset to include purely native Android applications. This native inclusion will serve as a vital control group, enabling comparative benchmarks that highlight architectural, performance, and security differences between native and cross-platform paradigms.
In this reading seminar (Lesegruppe), students will explore how Bitcoin works as a peer-to-peer electronic cash system and investigate selected protocol features, proposed changes, and wallet designs in depth.
Indoor service robots carry medication, lab samples, and supplies through hospital corridors and move goods through warehouse aisles. They share this space with people who are not trained operators and who are often not paying attention to the robot. Navigation policies for such robots are increasingly learned through reinforcement learning or imitation. When a learned policy meets a situation outside its training data, it still produces an action, and nothing in that action tells the robot or its operator that the policy may be wrong.
A robot driving around a room often observes an object from an awkward position, where it may be partly hidden behind furniture, too distant, or lit from behind. A conventional vision pipeline runs an object detector on whatever image is available and accepts the result even when confidence is low. A robot on wheels, unlike a fixed camera, has a further option open to it: moving to a different position and observing again. Choosing where to look next, rather than only interpreting what is already in view, is known as active perception.
Low-cost robotic arms are usually driven by scripts that command each joint directly, which is adequate for a demonstration but rarely transfers to the next project and offers no protection against the arm moving through an obstacle or into itself. Robotics addresses this with two standard pieces of software: the first gives programs a common way to communicate with real or simulated motors and is called ROS 2 Control, while the second computes the joint angles needed to reach a position, checks the path for collisions, and plans a safe movement, and is called MoveIt 2. Taken together, they turn a one-off script into a reusable arm setup that transfers between simulation and hardware.
The context is sustainbable software development. We try to find coding alternatives that are economical with regard to energy (electricity) consumption.
Language models can generate plausible code that fails its tests. This thesis investigates whether internal attention patterns predict failure before generation finishes, allowing computation to shift toward more promising candidates. The student will build on the Prober repository to train and evaluate lightweight prediction models.
This project investigates merge conflicts at this semantic level. It aims to characterize (1) the semantic changes represented by
oursandtheirs, (2) the relationship between these concurrent changes, and (3) how the final resolution consolidates them. The result should be an empirically grounded taxonomy and an annotated dataset of real-world merge conflicts.
The context is sustainbable software development. We try to find coding alternatives that are economical with regard to energy (electricity) consumption.
Indoor service robots carry medication, lab samples, and supplies through hospital corridors and move goods through warehouse aisles. They share this space with people who are not trained operators and who are often not paying attention to the robot. Navigation policies for such robots are increasingly learned through reinforcement learning or imitation. When a learned policy meets a situation outside its training data, it still produces an action, and nothing in that action tells the robot or its operator that the policy may be wrong.
Language models can generate programming exercises and solutions, but incorrect answers, weak tests, and repetitive tasks can limit their value as training data. This thesis builds on CodifieRL to generate synthetic coding tasks from real repositories and investigate whether execution-based filtering improves their quality and usefulness for training code models.
Modern Android applications are increasingly built using hybrid frameworks such as React Native, Flutter, and Cordova, allowing developers to deploy apps across multiple platforms with a single codebase. Like native apps, hybrid applications heavily rely on Third-Party Libraries (TPLs) to accelerate development and integrate functionalities like analytics, advertising, and UI components. However, TPLs can introduce severe security vulnerabilities and privacy risks. While numerous techniques exist to detect TPLs in native Android applications (analyzing Dalvik bytecode), identifying TPLs in hybrid apps remains a significant challenge. This project aims to bridge this gap by investigating the structure of hybrid apps and developing a novel approach to accurately detect embedded TPLs within their non-native components (e.g., JavaScript bundles, Dart binaries).
Foundation models let a robots accept missions in natural language, but they also let a wrong or malicious instruction reach the propellers. PEACE [1] is a planner–executor agent for robots in which a large language model emits a complete, typed mission plan in a single call, and an independent safety service validates every motion command before actuation. That service currently enforces two geometric constraints: an altitude band and a horizontal geofence. It cannot express, let alone enforce, the rules that matter in the real world: keep distance from people, do not hover in front of windows, maintain a minimum altitude over roads, respect regulatory limits. This project replaces the geometric check with a two-tier guardrail: a plan-level check that grounds natural-language safety rules into formal specifications and verifies the whole mission plan before dispatch, and an execution-level check that grounds the same rules into spatial keep-out sets around detected objects.
This project uses small quadcopter drones, open-source research platforms known as Crazyflies, which are light enough to fly safely inside an ordinary room. Since GPS is unavailable indoors, position has to be established by other means, and these drones rely on a room-tracking system called Bitcraze Lighthouse. Small base stations mounted around the flight area, originally developed for virtual-reality headsets, sweep invisible infrared light across the space, while a receiver board on each drone detects these sweeps and computes its own position onboard many times per second. With four base stations placed around the room, the same calibrated setup can track a single drone or a small group.
PEACE [1] is a planner–executor agent for a single-robot systems: a large language model (LLM) turns a natural-language mission into one typed plan of tool calls, an executor dispatches it deterministically over ROS 2, and an independent constraint layer validates every motion command. Many missions that motivate language-tasked drones, such as area survey, search, or inspection of distributed infrastructure, are naturally multi-robot. This project extends the planner–executor paradigm from single-robot system to a multi-robot system: the planner must decompose a mission into per-robot plans with dependencies, the executor must coordinate several robots, the world model must be shared, and the constraint layer must enforce inter-robot constraints such as separation and operational environment partitioning in addition to per-robot geofences.
Context
Managing distressed patients in clinical environments is a challenging yet critical skill for healthcare professionals. Patients exhibit diverse emotional responses—ranging from anxiety and shyness to outright resistance-making it essential for clinicians to adapt their approach. Traditional training methods often lack the realism needed to prepare professionals for these high-stakes interactions.
This project investigates merge conflicts at this semantic level. It aims to characterize (1) the semantic changes represented by
oursandtheirs, (2) the relationship between these concurrent changes, and (3) how the final resolution consolidates them. The result should be an empirically grounded taxonomy and an annotated dataset of real-world merge conflicts.This topic investigates unsupervised anomaly detection for merge conflict resolution in software engineering. Existing approaches generally formulate conflict resolution as supervised classification over predefined resolution labels. However, even a large labeled dataset may contain rare, unusual, or incorrectly reconstructed cases, and the labels may not adequately represent the full diversity of merge behavior. This project will develop methods to identify anomalous merge conflicts using the available conflict representations while initially ignoring the nine resolution labels. The objective is to determine whether anomaly scores can identify unusual conflict structures, rare resolution patterns, or cases that are difficult for conventional classifiers.
This topic investigates the quality and correctness of nine automatically assigned labels for merge-conflict resolutions. The labels were reconstructed by replaying historical Git merges and mapping the tentative conflict representation to the final developer-committed file. Such mappings are reproducible and scalable, but they can be affected by formatting changes, reordered code, structural edits, ambiguous correspondence between conflict chunks, and compound resolutions. The project will develop methods to detect potentially incorrect, ambiguous, or unstable labels and will validate a sample of these cases through systematic inspection. The work combines supervised, unsupervised, and weakly supervised methods for label-quality assessment.
The context is sustainbable software development. We try to find coding alternatives that are economical with regard to energy (electricity) consumption.
Foundation models let a robots accept missions in natural language, but they also let a wrong or malicious instruction reach the propellers. PEACE [1] is a planner–executor agent for robots in which a large language model emits a complete, typed mission plan in a single call, and an independent safety service validates every motion command before actuation. That service currently enforces two geometric constraints: an altitude band and a horizontal geofence. It cannot express, let alone enforce, the rules that matter in the real world: keep distance from people, do not hover in front of windows, maintain a minimum altitude over roads, respect regulatory limits. This project replaces the geometric check with a two-tier guardrail: a plan-level check that grounds natural-language safety rules into formal specifications and verifies the whole mission plan before dispatch, and an execution-level check that grounds the same rules into spatial keep-out sets around detected objects.
Low-cost robotic arms are usually driven by scripts that command each joint directly, which is adequate for a demonstration but rarely transfers to the next project and offers no protection against the arm moving through an obstacle or into itself. Robotics addresses this with two standard pieces of software: the first gives programs a common way to communicate with real or simulated motors and is called ROS 2 Control, while the second computes the joint angles needed to reach a position, checks the path for collisions, and plans a safe movement, and is called MoveIt 2. Taken together, they turn a one-off script into a reusable arm setup that transfers between simulation and hardware.
Swarms of unmanned aerial vehicles (UAVs) are used in search and rescue, infrastructure inspection, and environmental monitoring. An operator supervising such a swarm has to follow many vehicles at once, understand where they are relative to one another, and issue commands to groups rather than to single drones. Ground control stations present this three-dimensional situation on flat screens, which leaves the operator to reconstruct the spatial picture mentally. A Mixed Reality (MR) headset can instead place drone positions, planned trajectories, and status information in the space where the drones actually fly.
The idea of this project is to extend an exsting dataset for Android apps and their third-party libraries. Our current research relies on a foundational dataset of Android hybrid applications to analyze Third-Party Library (TPL) usage and associated security risks. The dataset contains currently Flutter, .NET MAUI, React Native, and Apache Cordova apps and we want to extend this with additional frameworks, such as Ionic or Unity. While we already maintain an automated data acquisition pipeline, this seminar project focuses on extending its capabilities to systematically crawl, download, and build applications built with additional modern hybrid frameworks (such as Ionic, Unity, etc.) from public repositories (e.g., GitHub, Gitlab, etc.). Crucially, this project will also expand the pipeline and dataset to include purely native Android applications. This native inclusion will serve as a vital control group, enabling comparative benchmarks that highlight architectural, performance, and security differences between native and cross-platform paradigms.
Modern Android applications are increasingly built using hybrid frameworks such as React Native, Flutter, and Cordova, allowing developers to deploy apps across multiple platforms with a single codebase. Like native apps, hybrid applications heavily rely on Third-Party Libraries (TPLs) to accelerate development and integrate functionalities like analytics, advertising, and UI components. However, TPLs can introduce severe security vulnerabilities and privacy risks. While numerous techniques exist to detect TPLs in native Android applications (analyzing Dalvik bytecode), identifying TPLs in hybrid apps remains a significant challenge. This project aims to bridge this gap by investigating the structure of hybrid apps and developing a novel approach to accurately detect embedded TPLs within their non-native components (e.g., JavaScript bundles, Dart binaries).
AI coding assistants are now widely used in professional software development. The prompts developers write, the responses they receive, the subsequent edits they make, and the rework they perform before committing code remain almost entirely invisible for in-depth analysis. Without access to the full interaction between developer intent (i.e., a prompt) and AI output, it is not possible to study whether AI-generated code actually addresses what the developer needed.
This project uses small quadcopter drones, open-source research platforms known as Crazyflies, which are light enough to fly safely inside an ordinary room. Since GPS is unavailable indoors, position has to be established by other means, and these drones rely on a room-tracking system called Bitcraze Lighthouse. Small base stations mounted around the flight area, originally developed for virtual-reality headsets, sweep invisible infrared light across the space, while a receiver board on each drone detects these sweeps and computes its own position onboard many times per second. With four base stations placed around the room, the same calibrated setup can track a single drone or a small group.
Large language models (LLMs) are increasingly used as high-level planners for robots: a natural-language mission is turned into a sequence of actions that a classical controller executes. Recent work has shown that such LLM-controlled robots can be jailbroken into performing physically harmful actions, often with 100% attack success, on commercial platforms [1]. Proposed defenses either wrap the planner in a guardrail [2] or restrict what the planner may emit. Planner–executor agents such as PEACE [3] take the second route: the LLM produces a single, fully typed plan over a fixed tool schema instead of free-form code or a step-by-step reasoning loop. Whether this architectural choice actually reduces the attack surface has never been measured. This project builds a reusable red-teaming harness for LLM-enabled robot planners in simulation and uses it to compare architectures under a common set of attacks.
This topic investigates the quality and correctness of nine automatically assigned labels for merge-conflict resolutions. The labels were reconstructed by replaying historical Git merges and mapping the tentative conflict representation to the final developer-committed file. Such mappings are reproducible and scalable, but they can be affected by formatting changes, reordered code, structural edits, ambiguous correspondence between conflict chunks, and compound resolutions. The project will develop methods to detect potentially incorrect, ambiguous, or unstable labels and will validate a sample of these cases through systematic inspection. The work combines supervised, unsupervised, and weakly supervised methods for label-quality assessment.
This topic investigates the quality and correctness of nine automatically assigned labels for merge-conflict resolutions. The labels were reconstructed by replaying historical Git merges and mapping the tentative conflict representation to the final developer-committed file. Such mappings are reproducible and scalable, but they can be affected by formatting changes, reordered code, structural edits, ambiguous correspondence between conflict chunks, and compound resolutions. The project will develop methods to detect potentially incorrect, ambiguous, or unstable labels and will validate a sample of these cases through systematic inspection. The work combines supervised, unsupervised, and weakly supervised methods for label-quality assessment.
PEACE [1] is a planner–executor agent for a single-robot systems: a large language model (LLM) turns a natural-language mission into one typed plan of tool calls, an executor dispatches it deterministically over ROS 2, and an independent constraint layer validates every motion command. Many missions that motivate language-tasked drones, such as area survey, search, or inspection of distributed infrastructure, are naturally multi-robot. This project extends the planner–executor paradigm from single-robot system to a multi-robot system: the planner must decompose a mission into per-robot plans with dependencies, the executor must coordinate several robots, the world model must be shared, and the constraint layer must enforce inter-robot constraints such as separation and operational environment partitioning in addition to per-robot geofences.
This project uses small quadcopter drones, open-source research platforms known as Crazyflies, which are light enough to fly safely inside an ordinary room. Since GPS is unavailable indoors, position has to be established by other means, and these drones rely on a room-tracking system called Bitcraze Lighthouse. Small base stations mounted around the flight area, originally developed for virtual-reality headsets, sweep invisible infrared light across the space, while a receiver board on each drone detects these sweeps and computes its own position onboard many times per second. With four base stations placed around the room, the same calibrated setup can track a single drone or a small group.
Context
Modern LLMs are increasingly enhanced with the ability to interact with external tools such as:
- Code interpreters
- Search engines
- Databases
- Simulated environments
Context
The Apertus project from EPFL, ETH, focuses on developing a Swiss-based Large Language Model (LLM) with strong multilingual capabilities. While the model performs competitively on general language tasks, it currently struggles with structured programming challenges such as:
- Long-horizon reasoning over multiple files
- Code refactoring and abstraction
- Repository-level understanding
- Debugging and test-driven development
- Reliable code generation under constraints
Foundation models let a robots accept missions in natural language, but they also let a wrong or malicious instruction reach the propellers. PEACE [1] is a planner–executor agent for robots in which a large language model emits a complete, typed mission plan in a single call, and an independent safety service validates every motion command before actuation. That service currently enforces two geometric constraints: an altitude band and a horizontal geofence. It cannot express, let alone enforce, the rules that matter in the real world: keep distance from people, do not hover in front of windows, maintain a minimum altitude over roads, respect regulatory limits. This project replaces the geometric check with a two-tier guardrail: a plan-level check that grounds natural-language safety rules into formal specifications and verifies the whole mission plan before dispatch, and an execution-level check that grounds the same rules into spatial keep-out sets around detected objects.
Large language models (LLMs) are increasingly used as high-level planners for robots: a natural-language mission is turned into a sequence of actions that a classical controller executes. Recent work has shown that such LLM-controlled robots can be jailbroken into performing physically harmful actions, often with 100% attack success, on commercial platforms [1]. Proposed defenses either wrap the planner in a guardrail [2] or restrict what the planner may emit. Planner–executor agents such as PEACE [3] take the second route: the LLM produces a single, fully typed plan over a fixed tool schema instead of free-form code or a step-by-step reasoning loop. Whether this architectural choice actually reduces the attack surface has never been measured. This project builds a reusable red-teaming harness for LLM-enabled robot planners in simulation and uses it to compare architectures under a common set of attacks.
This project uses small quadcopter drones, open-source research platforms known as Crazyflies, which are light enough to fly safely inside an ordinary room. Since GPS is unavailable indoors, position has to be established by other means, and these drones rely on a room-tracking system called Bitcraze Lighthouse. Small base stations mounted around the flight area, originally developed for virtual-reality headsets, sweep invisible infrared light across the space, while a receiver board on each drone detects these sweeps and computes its own position onboard many times per second. With four base stations placed around the room, the same calibrated setup can track a single drone or a small group.
Context
Modern LLMs are increasingly enhanced with the ability to interact with external tools such as:
- Code interpreters
- Search engines
- Databases
- Simulated environments
Context
The Apertus project from EPFL, ETH, focuses on developing a Swiss-based Large Language Model (LLM) with strong multilingual capabilities. While the model performs competitively on general language tasks, it currently struggles with structured programming challenges such as:
- Long-horizon reasoning over multiple files
- Code refactoring and abstraction
- Repository-level understanding
- Debugging and test-driven development
- Reliable code generation under constraints
The context is sustainbable software development. We try to find coding alternatives that are economical with regard to energy (electricity) consumption.
This topic investigates unsupervised anomaly detection for merge conflict resolution in software engineering. Existing approaches generally formulate conflict resolution as supervised classification over predefined resolution labels. However, even a large labeled dataset may contain rare, unusual, or incorrectly reconstructed cases, and the labels may not adequately represent the full diversity of merge behavior. This project will develop methods to identify anomalous merge conflicts using the available conflict representations while initially ignoring the nine resolution labels. The objective is to determine whether anomaly scores can identify unusual conflict structures, rare resolution patterns, or cases that are difficult for conventional classifiers.
This topic investigates the quality and correctness of nine automatically assigned labels for merge-conflict resolutions. The labels were reconstructed by replaying historical Git merges and mapping the tentative conflict representation to the final developer-committed file. Such mappings are reproducible and scalable, but they can be affected by formatting changes, reordered code, structural edits, ambiguous correspondence between conflict chunks, and compound resolutions. The project will develop methods to detect potentially incorrect, ambiguous, or unstable labels and will validate a sample of these cases through systematic inspection. The work combines supervised, unsupervised, and weakly supervised methods for label-quality assessment.
This project investigates merge conflicts at this semantic level. It aims to characterize (1) the semantic changes represented by
oursandtheirs, (2) the relationship between these concurrent changes, and (3) how the final resolution consolidates them. The result should be an empirically grounded taxonomy and an annotated dataset of real-world merge conflicts.
Swarms of unmanned aerial vehicles (UAVs) are used in search and rescue, infrastructure inspection, and environmental monitoring. An operator supervising such a swarm has to follow many vehicles at once, understand where they are relative to one another, and issue commands to groups rather than to single drones. Ground control stations present this three-dimensional situation on flat screens, which leaves the operator to reconstruct the spatial picture mentally. A Mixed Reality (MR) headset can instead place drone positions, planned trajectories, and status information in the space where the drones actually fly.
Swarms of unmanned aerial vehicles (UAVs) are used in search and rescue, infrastructure inspection, and environmental monitoring. An operator supervising such a swarm has to follow many vehicles at once, understand where they are relative to one another, and issue commands to groups rather than to single drones. Ground control stations present this three-dimensional situation on flat screens, which leaves the operator to reconstruct the spatial picture mentally. A Mixed Reality (MR) headset can instead place drone positions, planned trajectories, and status information in the space where the drones actually fly.
Low-cost robotic arms are usually driven by scripts that command each joint directly, which is adequate for a demonstration but rarely transfers to the next project and offers no protection against the arm moving through an obstacle or into itself. Robotics addresses this with two standard pieces of software: the first gives programs a common way to communicate with real or simulated motors and is called ROS 2 Control, while the second computes the joint angles needed to reach a position, checks the path for collisions, and plans a safe movement, and is called MoveIt 2. Taken together, they turn a one-off script into a reusable arm setup that transfers between simulation and hardware.
Low-cost robotic arms are usually driven by scripts that command each joint directly, which is adequate for a demonstration but rarely transfers to the next project and offers no protection against the arm moving through an obstacle or into itself. Robotics addresses this with two standard pieces of software: the first gives programs a common way to communicate with real or simulated motors and is called ROS 2 Control, while the second computes the joint angles needed to reach a position, checks the path for collisions, and plans a safe movement, and is called MoveIt 2. Taken together, they turn a one-off script into a reusable arm setup that transfers between simulation and hardware.
PEACE [1] is a planner–executor agent for a single-robot systems: a large language model (LLM) turns a natural-language mission into one typed plan of tool calls, an executor dispatches it deterministically over ROS 2, and an independent constraint layer validates every motion command. Many missions that motivate language-tasked drones, such as area survey, search, or inspection of distributed infrastructure, are naturally multi-robot. This project extends the planner–executor paradigm from single-robot system to a multi-robot system: the planner must decompose a mission into per-robot plans with dependencies, the executor must coordinate several robots, the world model must be shared, and the constraint layer must enforce inter-robot constraints such as separation and operational environment partitioning in addition to per-robot geofences.
The idea of this project is to extend an exsting dataset for Android apps and their third-party libraries. Our current research relies on a foundational dataset of Android hybrid applications to analyze Third-Party Library (TPL) usage and associated security risks. The dataset contains currently Flutter, .NET MAUI, React Native, and Apache Cordova apps and we want to extend this with additional frameworks, such as Ionic or Unity. While we already maintain an automated data acquisition pipeline, this seminar project focuses on extending its capabilities to systematically crawl, download, and build applications built with additional modern hybrid frameworks (such as Ionic, Unity, etc.) from public repositories (e.g., GitHub, Gitlab, etc.). Crucially, this project will also expand the pipeline and dataset to include purely native Android applications. This native inclusion will serve as a vital control group, enabling comparative benchmarks that highlight architectural, performance, and security differences between native and cross-platform paradigms.
This topic investigates the quality and correctness of nine automatically assigned labels for merge-conflict resolutions. The labels were reconstructed by replaying historical Git merges and mapping the tentative conflict representation to the final developer-committed file. Such mappings are reproducible and scalable, but they can be affected by formatting changes, reordered code, structural edits, ambiguous correspondence between conflict chunks, and compound resolutions. The project will develop methods to detect potentially incorrect, ambiguous, or unstable labels and will validate a sample of these cases through systematic inspection. The work combines supervised, unsupervised, and weakly supervised methods for label-quality assessment.
A robot driving around a room often observes an object from an awkward position, where it may be partly hidden behind furniture, too distant, or lit from behind. A conventional vision pipeline runs an object detector on whatever image is available and accepts the result even when confidence is low. A robot on wheels, unlike a fixed camera, has a further option open to it: moving to a different position and observing again. Choosing where to look next, rather than only interpreting what is already in view, is known as active perception.
A robot moving through an unfamiliar building must build a picture of its surroundings and work out where it sits within them at the same time. Solving both problems together from camera images is known as SLAM, short for simultaneous localization and mapping. The cameras used here record a normal colour image together with the distance to everything in view; such devices are called depth cameras, or RGB-D cameras, and they suit indoor robots because they provide both appearance and scale without the cost of a laser scanner. Many open-source SLAM systems exist, and they differ considerably in how they store the map, how they recognize a place already visited, how much computing power they require, and how well they cope with dim light or rapid motion.
This project investigates merge conflicts at this semantic level. It aims to characterize (1) the semantic changes represented by
oursandtheirs, (2) the relationship between these concurrent changes, and (3) how the final resolution consolidates them. The result should be an empirically grounded taxonomy and an annotated dataset of real-world merge conflicts.
AI coding assistants are now widely used in professional software development. The prompts developers write, the responses they receive, the subsequent edits they make, and the rework they perform before committing code remain almost entirely invisible for in-depth analysis. Without access to the full interaction between developer intent (i.e., a prompt) and AI output, it is not possible to study whether AI-generated code actually addresses what the developer needed.
Modern AI coding tools allow developers and agents to generate hundreds of lines of code in seconds. However, our standard processes for managing software—like Git feature branches and pull requests—were created over two decades ago when writing code by hand was a slow process. Because code generation is now nearly instant, the main bottleneck in software engineering has shifted from writing code to reviewing, testing, and integrating it.
Swarms of unmanned aerial vehicles (UAVs) are used in search and rescue, infrastructure inspection, and environmental monitoring. An operator supervising such a swarm has to follow many vehicles at once, understand where they are relative to one another, and issue commands to groups rather than to single drones. Ground control stations present this three-dimensional situation on flat screens, which leaves the operator to reconstruct the spatial picture mentally. A Mixed Reality (MR) headset can instead place drone positions, planned trajectories, and status information in the space where the drones actually fly.
This project investigates merge conflicts at this semantic level. It aims to characterize (1) the semantic changes represented by
oursandtheirs, (2) the relationship between these concurrent changes, and (3) how the final resolution consolidates them. The result should be an empirically grounded taxonomy and an annotated dataset of real-world merge conflicts.
The context is sustainbable software development. We try to find coding alternatives that are economical with regard to energy (electricity) consumption.
This topic investigates unsupervised anomaly detection for merge conflict resolution in software engineering. Existing approaches generally formulate conflict resolution as supervised classification over predefined resolution labels. However, even a large labeled dataset may contain rare, unusual, or incorrectly reconstructed cases, and the labels may not adequately represent the full diversity of merge behavior. This project will develop methods to identify anomalous merge conflicts using the available conflict representations while initially ignoring the nine resolution labels. The objective is to determine whether anomaly scores can identify unusual conflict structures, rare resolution patterns, or cases that are difficult for conventional classifiers.
Modern Android applications are increasingly built using hybrid frameworks such as React Native, Flutter, and Cordova, allowing developers to deploy apps across multiple platforms with a single codebase. Like native apps, hybrid applications heavily rely on Third-Party Libraries (TPLs) to accelerate development and integrate functionalities like analytics, advertising, and UI components. However, TPLs can introduce severe security vulnerabilities and privacy risks. While numerous techniques exist to detect TPLs in native Android applications (analyzing Dalvik bytecode), identifying TPLs in hybrid apps remains a significant challenge. This project aims to bridge this gap by investigating the structure of hybrid apps and developing a novel approach to accurately detect embedded TPLs within their non-native components (e.g., JavaScript bundles, Dart binaries).
A robot moving through an unfamiliar building must build a picture of its surroundings and work out where it sits within them at the same time. Solving both problems together from camera images is known as SLAM, short for simultaneous localization and mapping. The cameras used here record a normal colour image together with the distance to everything in view; such devices are called depth cameras, or RGB-D cameras, and they suit indoor robots because they provide both appearance and scale without the cost of a laser scanner. Many open-source SLAM systems exist, and they differ considerably in how they store the map, how they recognize a place already visited, how much computing power they require, and how well they cope with dim light or rapid motion.
PEACE [1] is a planner–executor agent for a single-robot systems: a large language model (LLM) turns a natural-language mission into one typed plan of tool calls, an executor dispatches it deterministically over ROS 2, and an independent constraint layer validates every motion command. Many missions that motivate language-tasked drones, such as area survey, search, or inspection of distributed infrastructure, are naturally multi-robot. This project extends the planner–executor paradigm from single-robot system to a multi-robot system: the planner must decompose a mission into per-robot plans with dependencies, the executor must coordinate several robots, the world model must be shared, and the constraint layer must enforce inter-robot constraints such as separation and operational environment partitioning in addition to per-robot geofences.
Large language models (LLMs) are increasingly used as high-level planners for robots: a natural-language mission is turned into a sequence of actions that a classical controller executes. Recent work has shown that such LLM-controlled robots can be jailbroken into performing physically harmful actions, often with 100% attack success, on commercial platforms [1]. Proposed defenses either wrap the planner in a guardrail [2] or restrict what the planner may emit. Planner–executor agents such as PEACE [3] take the second route: the LLM produces a single, fully typed plan over a fixed tool schema instead of free-form code or a step-by-step reasoning loop. Whether this architectural choice actually reduces the attack surface has never been measured. This project builds a reusable red-teaming harness for LLM-enabled robot planners in simulation and uses it to compare architectures under a common set of attacks.
Low-cost robotic arms are usually driven by scripts that command each joint directly, which is adequate for a demonstration but rarely transfers to the next project and offers no protection against the arm moving through an obstacle or into itself. Robotics addresses this with two standard pieces of software: the first gives programs a common way to communicate with real or simulated motors and is called ROS 2 Control, while the second computes the joint angles needed to reach a position, checks the path for collisions, and plans a safe movement, and is called MoveIt 2. Taken together, they turn a one-off script into a reusable arm setup that transfers between simulation and hardware.
A robot driving around a room often observes an object from an awkward position, where it may be partly hidden behind furniture, too distant, or lit from behind. A conventional vision pipeline runs an object detector on whatever image is available and accepts the result even when confidence is low. A robot on wheels, unlike a fixed camera, has a further option open to it: moving to a different position and observing again. Choosing where to look next, rather than only interpreting what is already in view, is known as active perception.
A robot moving through an unfamiliar building must build a picture of its surroundings and work out where it sits within them at the same time. Solving both problems together from camera images is known as SLAM, short for simultaneous localization and mapping. The cameras used here record a normal colour image together with the distance to everything in view; such devices are called depth cameras, or RGB-D cameras, and they suit indoor robots because they provide both appearance and scale without the cost of a laser scanner. Many open-source SLAM systems exist, and they differ considerably in how they store the map, how they recognize a place already visited, how much computing power they require, and how well they cope with dim light or rapid motion.
Indoor service robots carry medication, lab samples, and supplies through hospital corridors and move goods through warehouse aisles. They share this space with people who are not trained operators and who are often not paying attention to the robot. Navigation policies for such robots are increasingly learned through reinforcement learning or imitation. When a learned policy meets a situation outside its training data, it still produces an action, and nothing in that action tells the robot or its operator that the policy may be wrong.
Foundation models let a robots accept missions in natural language, but they also let a wrong or malicious instruction reach the propellers. PEACE [1] is a planner–executor agent for robots in which a large language model emits a complete, typed mission plan in a single call, and an independent safety service validates every motion command before actuation. That service currently enforces two geometric constraints: an altitude band and a horizontal geofence. It cannot express, let alone enforce, the rules that matter in the real world: keep distance from people, do not hover in front of windows, maintain a minimum altitude over roads, respect regulatory limits. This project replaces the geometric check with a two-tier guardrail: a plan-level check that grounds natural-language safety rules into formal specifications and verifies the whole mission plan before dispatch, and an execution-level check that grounds the same rules into spatial keep-out sets around detected objects.
Swarms of unmanned aerial vehicles (UAVs) are used in search and rescue, infrastructure inspection, and environmental monitoring. An operator supervising such a swarm has to follow many vehicles at once, understand where they are relative to one another, and issue commands to groups rather than to single drones. Ground control stations present this three-dimensional situation on flat screens, which leaves the operator to reconstruct the spatial picture mentally. A Mixed Reality (MR) headset can instead place drone positions, planned trajectories, and status information in the space where the drones actually fly.
PEACE [1] is a planner–executor agent for a single-robot systems: a large language model (LLM) turns a natural-language mission into one typed plan of tool calls, an executor dispatches it deterministically over ROS 2, and an independent constraint layer validates every motion command. Many missions that motivate language-tasked drones, such as area survey, search, or inspection of distributed infrastructure, are naturally multi-robot. This project extends the planner–executor paradigm from single-robot system to a multi-robot system: the planner must decompose a mission into per-robot plans with dependencies, the executor must coordinate several robots, the world model must be shared, and the constraint layer must enforce inter-robot constraints such as separation and operational environment partitioning in addition to per-robot geofences.
Large language models (LLMs) are increasingly used as high-level planners for robots: a natural-language mission is turned into a sequence of actions that a classical controller executes. Recent work has shown that such LLM-controlled robots can be jailbroken into performing physically harmful actions, often with 100% attack success, on commercial platforms [1]. Proposed defenses either wrap the planner in a guardrail [2] or restrict what the planner may emit. Planner–executor agents such as PEACE [3] take the second route: the LLM produces a single, fully typed plan over a fixed tool schema instead of free-form code or a step-by-step reasoning loop. Whether this architectural choice actually reduces the attack surface has never been measured. This project builds a reusable red-teaming harness for LLM-enabled robot planners in simulation and uses it to compare architectures under a common set of attacks.
Low-cost robotic arms are usually driven by scripts that command each joint directly, which is adequate for a demonstration but rarely transfers to the next project and offers no protection against the arm moving through an obstacle or into itself. Robotics addresses this with two standard pieces of software: the first gives programs a common way to communicate with real or simulated motors and is called ROS 2 Control, while the second computes the joint angles needed to reach a position, checks the path for collisions, and plans a safe movement, and is called MoveIt 2. Taken together, they turn a one-off script into a reusable arm setup that transfers between simulation and hardware.
A robot moving through an unfamiliar building must build a picture of its surroundings and work out where it sits within them at the same time. Solving both problems together from camera images is known as SLAM, short for simultaneous localization and mapping. The cameras used here record a normal colour image together with the distance to everything in view; such devices are called depth cameras, or RGB-D cameras, and they suit indoor robots because they provide both appearance and scale without the cost of a laser scanner. Many open-source SLAM systems exist, and they differ considerably in how they store the map, how they recognize a place already visited, how much computing power they require, and how well they cope with dim light or rapid motion.
Indoor service robots carry medication, lab samples, and supplies through hospital corridors and move goods through warehouse aisles. They share this space with people who are not trained operators and who are often not paying attention to the robot. Navigation policies for such robots are increasingly learned through reinforcement learning or imitation. When a learned policy meets a situation outside its training data, it still produces an action, and nothing in that action tells the robot or its operator that the policy may be wrong.
Indoor service robots carry medication, lab samples, and supplies through hospital corridors and move goods through warehouse aisles. They share this space with people who are not trained operators and who are often not paying attention to the robot. Navigation policies for such robots are increasingly learned through reinforcement learning or imitation. When a learned policy meets a situation outside its training data, it still produces an action, and nothing in that action tells the robot or its operator that the policy may be wrong.
Foundation models let a robots accept missions in natural language, but they also let a wrong or malicious instruction reach the propellers. PEACE [1] is a planner–executor agent for robots in which a large language model emits a complete, typed mission plan in a single call, and an independent safety service validates every motion command before actuation. That service currently enforces two geometric constraints: an altitude band and a horizontal geofence. It cannot express, let alone enforce, the rules that matter in the real world: keep distance from people, do not hover in front of windows, maintain a minimum altitude over roads, respect regulatory limits. This project replaces the geometric check with a two-tier guardrail: a plan-level check that grounds natural-language safety rules into formal specifications and verifies the whole mission plan before dispatch, and an execution-level check that grounds the same rules into spatial keep-out sets around detected objects.
Large language models (LLMs) are increasingly used as high-level planners for robots: a natural-language mission is turned into a sequence of actions that a classical controller executes. Recent work has shown that such LLM-controlled robots can be jailbroken into performing physically harmful actions, often with 100% attack success, on commercial platforms [1]. Proposed defenses either wrap the planner in a guardrail [2] or restrict what the planner may emit. Planner–executor agents such as PEACE [3] take the second route: the LLM produces a single, fully typed plan over a fixed tool schema instead of free-form code or a step-by-step reasoning loop. Whether this architectural choice actually reduces the attack surface has never been measured. This project builds a reusable red-teaming harness for LLM-enabled robot planners in simulation and uses it to compare architectures under a common set of attacks.
Modern Android applications are increasingly built using hybrid frameworks such as React Native, Flutter, and Cordova, allowing developers to deploy apps across multiple platforms with a single codebase. Like native apps, hybrid applications heavily rely on Third-Party Libraries (TPLs) to accelerate development and integrate functionalities like analytics, advertising, and UI components. However, TPLs can introduce severe security vulnerabilities and privacy risks. While numerous techniques exist to detect TPLs in native Android applications (analyzing Dalvik bytecode), identifying TPLs in hybrid apps remains a significant challenge. This project aims to bridge this gap by investigating the structure of hybrid apps and developing a novel approach to accurately detect embedded TPLs within their non-native components (e.g., JavaScript bundles, Dart binaries).
This topic investigates unsupervised anomaly detection for merge conflict resolution in software engineering. Existing approaches generally formulate conflict resolution as supervised classification over predefined resolution labels. However, even a large labeled dataset may contain rare, unusual, or incorrectly reconstructed cases, and the labels may not adequately represent the full diversity of merge behavior. This project will develop methods to identify anomalous merge conflicts using the available conflict representations while initially ignoring the nine resolution labels. The objective is to determine whether anomaly scores can identify unusual conflict structures, rare resolution patterns, or cases that are difficult for conventional classifiers.
AI coding assistants are now widely used in professional software development. The prompts developers write, the responses they receive, the subsequent edits they make, and the rework they perform before committing code remain almost entirely invisible for in-depth analysis. Without access to the full interaction between developer intent (i.e., a prompt) and AI output, it is not possible to study whether AI-generated code actually addresses what the developer needed.
Modern Android applications are increasingly built using hybrid frameworks such as React Native, Flutter, and Cordova, allowing developers to deploy apps across multiple platforms with a single codebase. Like native apps, hybrid applications heavily rely on Third-Party Libraries (TPLs) to accelerate development and integrate functionalities like analytics, advertising, and UI components. However, TPLs can introduce severe security vulnerabilities and privacy risks. While numerous techniques exist to detect TPLs in native Android applications (analyzing Dalvik bytecode), identifying TPLs in hybrid apps remains a significant challenge. This project aims to bridge this gap by investigating the structure of hybrid apps and developing a novel approach to accurately detect embedded TPLs within their non-native components (e.g., JavaScript bundles, Dart binaries).
Language models can generate programming exercises and solutions, but incorrect answers, weak tests, and repetitive tasks can limit their value as training data. This thesis builds on CodifieRL to generate synthetic coding tasks from real repositories and investigate whether execution-based filtering improves their quality and usefulness for training code models.
Language models can generate programming exercises and solutions, but incorrect answers, weak tests, and repetitive tasks can limit their value as training data. This thesis builds on CodifieRL to generate synthetic coding tasks from real repositories and investigate whether execution-based filtering improves their quality and usefulness for training code models.
This project investigates merge conflicts at this semantic level. It aims to characterize (1) the semantic changes represented by
oursandtheirs, (2) the relationship between these concurrent changes, and (3) how the final resolution consolidates them. The result should be an empirically grounded taxonomy and an annotated dataset of real-world merge conflicts.
Modern Android applications are increasingly built using hybrid frameworks such as React Native, Flutter, and Cordova, allowing developers to deploy apps across multiple platforms with a single codebase. Like native apps, hybrid applications heavily rely on Third-Party Libraries (TPLs) to accelerate development and integrate functionalities like analytics, advertising, and UI components. However, TPLs can introduce severe security vulnerabilities and privacy risks. While numerous techniques exist to detect TPLs in native Android applications (analyzing Dalvik bytecode), identifying TPLs in hybrid apps remains a significant challenge. This project aims to bridge this gap by investigating the structure of hybrid apps and developing a novel approach to accurately detect embedded TPLs within their non-native components (e.g., JavaScript bundles, Dart binaries).
A robot moving through an unfamiliar building must build a picture of its surroundings and work out where it sits within them at the same time. Solving both problems together from camera images is known as SLAM, short for simultaneous localization and mapping. The cameras used here record a normal colour image together with the distance to everything in view; such devices are called depth cameras, or RGB-D cameras, and they suit indoor robots because they provide both appearance and scale without the cost of a laser scanner. Many open-source SLAM systems exist, and they differ considerably in how they store the map, how they recognize a place already visited, how much computing power they require, and how well they cope with dim light or rapid motion.
This project uses small quadcopter drones, open-source research platforms known as Crazyflies, which are light enough to fly safely inside an ordinary room. Since GPS is unavailable indoors, position has to be established by other means, and these drones rely on a room-tracking system called Bitcraze Lighthouse. Small base stations mounted around the flight area, originally developed for virtual-reality headsets, sweep invisible infrared light across the space, while a receiver board on each drone detects these sweeps and computes its own position onboard many times per second. With four base stations placed around the room, the same calibrated setup can track a single drone or a small group.
A robot driving around a room often observes an object from an awkward position, where it may be partly hidden behind furniture, too distant, or lit from behind. A conventional vision pipeline runs an object detector on whatever image is available and accepts the result even when confidence is low. A robot on wheels, unlike a fixed camera, has a further option open to it: moving to a different position and observing again. Choosing where to look next, rather than only interpreting what is already in view, is known as active perception.
A robot moving through an unfamiliar building must build a picture of its surroundings and work out where it sits within them at the same time. Solving both problems together from camera images is known as SLAM, short for simultaneous localization and mapping. The cameras used here record a normal colour image together with the distance to everything in view; such devices are called depth cameras, or RGB-D cameras, and they suit indoor robots because they provide both appearance and scale without the cost of a laser scanner. Many open-source SLAM systems exist, and they differ considerably in how they store the map, how they recognize a place already visited, how much computing power they require, and how well they cope with dim light or rapid motion.
Indoor service robots carry medication, lab samples, and supplies through hospital corridors and move goods through warehouse aisles. They share this space with people who are not trained operators and who are often not paying attention to the robot. Navigation policies for such robots are increasingly learned through reinforcement learning or imitation. When a learned policy meets a situation outside its training data, it still produces an action, and nothing in that action tells the robot or its operator that the policy may be wrong.
Swarms of unmanned aerial vehicles (UAVs) are used in search and rescue, infrastructure inspection, and environmental monitoring. An operator supervising such a swarm has to follow many vehicles at once, understand where they are relative to one another, and issue commands to groups rather than to single drones. Ground control stations present this three-dimensional situation on flat screens, which leaves the operator to reconstruct the spatial picture mentally. A Mixed Reality (MR) headset can instead place drone positions, planned trajectories, and status information in the space where the drones actually fly.
Swarms of unmanned aerial vehicles (UAVs) are used in search and rescue, infrastructure inspection, and environmental monitoring. An operator supervising such a swarm has to follow many vehicles at once, understand where they are relative to one another, and issue commands to groups rather than to single drones. Ground control stations present this three-dimensional situation on flat screens, which leaves the operator to reconstruct the spatial picture mentally. A Mixed Reality (MR) headset can instead place drone positions, planned trajectories, and status information in the space where the drones actually fly.
Context
Managing distressed patients in clinical environments is a challenging yet critical skill for healthcare professionals. Patients exhibit diverse emotional responses—ranging from anxiety and shyness to outright resistance-making it essential for clinicians to adapt their approach. Traditional training methods often lack the realism needed to prepare professionals for these high-stakes interactions.
Indoor service robots carry medication, lab samples, and supplies through hospital corridors and move goods through warehouse aisles. They share this space with people who are not trained operators and who are often not paying attention to the robot. Navigation policies for such robots are increasingly learned through reinforcement learning or imitation. When a learned policy meets a situation outside its training data, it still produces an action, and nothing in that action tells the robot or its operator that the policy may be wrong.
This topic investigates unsupervised anomaly detection for merge conflict resolution in software engineering. Existing approaches generally formulate conflict resolution as supervised classification over predefined resolution labels. However, even a large labeled dataset may contain rare, unusual, or incorrectly reconstructed cases, and the labels may not adequately represent the full diversity of merge behavior. This project will develop methods to identify anomalous merge conflicts using the available conflict representations while initially ignoring the nine resolution labels. The objective is to determine whether anomaly scores can identify unusual conflict structures, rare resolution patterns, or cases that are difficult for conventional classifiers.
This topic investigates the quality and correctness of nine automatically assigned labels for merge-conflict resolutions. The labels were reconstructed by replaying historical Git merges and mapping the tentative conflict representation to the final developer-committed file. Such mappings are reproducible and scalable, but they can be affected by formatting changes, reordered code, structural edits, ambiguous correspondence between conflict chunks, and compound resolutions. The project will develop methods to detect potentially incorrect, ambiguous, or unstable labels and will validate a sample of these cases through systematic inspection. The work combines supervised, unsupervised, and weakly supervised methods for label-quality assessment.
A robot driving around a room often observes an object from an awkward position, where it may be partly hidden behind furniture, too distant, or lit from behind. A conventional vision pipeline runs an object detector on whatever image is available and accepts the result even when confidence is low. A robot on wheels, unlike a fixed camera, has a further option open to it: moving to a different position and observing again. Choosing where to look next, rather than only interpreting what is already in view, is known as active perception.
A robot moving through an unfamiliar building must build a picture of its surroundings and work out where it sits within them at the same time. Solving both problems together from camera images is known as SLAM, short for simultaneous localization and mapping. The cameras used here record a normal colour image together with the distance to everything in view; such devices are called depth cameras, or RGB-D cameras, and they suit indoor robots because they provide both appearance and scale without the cost of a laser scanner. Many open-source SLAM systems exist, and they differ considerably in how they store the map, how they recognize a place already visited, how much computing power they require, and how well they cope with dim light or rapid motion.
Context
Managing distressed patients in clinical environments is a challenging yet critical skill for healthcare professionals. Patients exhibit diverse emotional responses—ranging from anxiety and shyness to outright resistance-making it essential for clinicians to adapt their approach. Traditional training methods often lack the realism needed to prepare professionals for these high-stakes interactions.
This topic investigates the quality and correctness of nine automatically assigned labels for merge-conflict resolutions. The labels were reconstructed by replaying historical Git merges and mapping the tentative conflict representation to the final developer-committed file. Such mappings are reproducible and scalable, but they can be affected by formatting changes, reordered code, structural edits, ambiguous correspondence between conflict chunks, and compound resolutions. The project will develop methods to detect potentially incorrect, ambiguous, or unstable labels and will validate a sample of these cases through systematic inspection. The work combines supervised, unsupervised, and weakly supervised methods for label-quality assessment.
The idea of this project is to extend an exsting dataset for Android apps and their third-party libraries. Our current research relies on a foundational dataset of Android hybrid applications to analyze Third-Party Library (TPL) usage and associated security risks. The dataset contains currently Flutter, .NET MAUI, React Native, and Apache Cordova apps and we want to extend this with additional frameworks, such as Ionic or Unity. While we already maintain an automated data acquisition pipeline, this seminar project focuses on extending its capabilities to systematically crawl, download, and build applications built with additional modern hybrid frameworks (such as Ionic, Unity, etc.) from public repositories (e.g., GitHub, Gitlab, etc.). Crucially, this project will also expand the pipeline and dataset to include purely native Android applications. This native inclusion will serve as a vital control group, enabling comparative benchmarks that highlight architectural, performance, and security differences between native and cross-platform paradigms.
The idea of this project is to extend an exsting dataset for Android apps and their third-party libraries. Our current research relies on a foundational dataset of Android hybrid applications to analyze Third-Party Library (TPL) usage and associated security risks. The dataset contains currently Flutter, .NET MAUI, React Native, and Apache Cordova apps and we want to extend this with additional frameworks, such as Ionic or Unity. While we already maintain an automated data acquisition pipeline, this seminar project focuses on extending its capabilities to systematically crawl, download, and build applications built with additional modern hybrid frameworks (such as Ionic, Unity, etc.) from public repositories (e.g., GitHub, Gitlab, etc.). Crucially, this project will also expand the pipeline and dataset to include purely native Android applications. This native inclusion will serve as a vital control group, enabling comparative benchmarks that highlight architectural, performance, and security differences between native and cross-platform paradigms.