Themen für Bachelorarbeiten im WS 2026/2027
Themen für Bachelorarbeiten im WS 2026/2027
Im Folgenden finden Sie einige Themenvorschläge für Bachelorarbeiten im WS 2026/2027. Die Themen werden bis zur Vorbesprechung laufend ergänzt. Sie können bei Interesse schon vorab mit dem jeweiligen Betreuer Kontakt aufnehmen.
Validierung eines Modells zur Beurteilung der Qualität von User Stories
Im Institut für Wirtschaftsinformatik – Software Engineering wurde ein Modell zur Beurteilung der Qualität von User Stories entwickelt. Das Modell basiert auf den INCOSE Guidelines für Anforderungen und auf den INVEST Kriterien für User Stories. Ziel der Arbeit ist der Vergleich dieses Modells mit anderen Modellen aus der Literatur und die Durchführung einer Umfrage zur Beurteilung der Qualität des entwickelten Modells.
Literaturanalyse
- Identifikation von Ansätzen zur (KI-basierten) Beurteilung der Qualität von Anforderungen mit Fokus auf User Stories
- Herausarbeiten der konzeptionellen Gemeinsamkeiten und Unterschiede zwischen diesen Ansätzen
Praktischer Teil
- Entwicklung eines Konzepts für die Beurteilung der Qualität des am Institut entwickelten Modells zur Beurteilung der Qualität von User Stories auf Basis einer (Online) Umfrage
- Entwicklung und Betreuung der Online-Umfrage
- Auswertung der Daten der Online-Umfrage
Betreuung: Reinhold Plösch
Status: OFFEN
Extraktion von Anforderungen aus Systemtestaufzeichnungen
Im Kontext der Wartung von Systemen besteht oft die Notwendigkeit, Anforderungen auf Basis des implementierten Systems zu extrahieren um darauf aufbauend Wartungsaktivitäten zu ermöglichen bzw. zu erleichtern. Im Zuge der Arbeit soll ein System entwickelt werden, das Videos von Systemtests analysiert und auf Basis dieser Daten Anforderungen (User Stories) extrahiert und dokumentiert. Ein rudimentärer Prototyp dafür ist am Institut vorhanden.
Literaturanalyse
- Identifikation von Ansätzen zur Extraktion von Anforderungen aus Systemen
- Der Fokus der Analyse liegt dabei auf Arbeiten, die die Extraktion dieses Wissens aus Systemen zur Laufzeit ermöglichen. Ansätze, die diese Analyse auf Basis des Source-Codes machen, sind zurückzustellen.
Praktischer Teil
- Entwicklung eines Prototyps zur Generierung von User Stories aus Videodaten
- Validierung des Prototyps
Betreuung: Reinhold Plösch
Status: OFFEN
Die Auswirkung von schlechten Anforderungen auf die Fähigkeit von LLMs, guten Code zu erzeugen
In der Literatur finden sich Ansätze, um die Qualität von Anforderungen mit Hilfe von KI-Systemen zu analysieren bzw. zu verbessern. Im Kontext des klassischen Software Engineering ist das auch sinnvoll, da Menschen typischerweise gut formulierte Anforderungen besser verstehen. Im Kontext des Einsatzes von KI-Systemen zur Codegenerierung stellt sich die Frage, ob aktuelle KI-Modelle auch mit qualitativ schwachen Anforderungen gut umgehen können oder ob sie Anforderungen hoher Qualität benötigen. Diese Fragestellung soll im Zuge eines umfangreichen, automatisierten Experimentes beantwortet werden.
Literaturanalyse
- Aufarbeiten der wissenschaftlichen Literatur, die den Zusammenhang zwischen der Güte von Anforderungen mit dem Projekterfolg, der Qualität von generiertem Code, etc., untersucht.
- Analyse der Literatur, die die Fragestellung dieser Bachelorarbeit in den Fokus rückt.
Praktischer Teil
- Konzeption, Entwicklung und Auswertung eines vollautomatisierten Experiments, das zum Ziel hat, herauszufinden, ob die Güte von Anforderungen Auswirkungen auf die Qualität des generierten Codes hat.
Betreuung: Reinhold Plösch
Status: OFFEN
Token-Optimiertes Refactoring von Code Smells mit LLMs
Aktuelle Forschungsergebnisse zeigen, dass das automatische Refactoring von Code Smells mit LLMs gut funktioniert. Die meisten Ansätze verwenden dafür jedoch die jeweils besten LLMs einer Modellfamilie. Sowohl aus Kostensicht als auch aus ökologischer Sicht ist diese Vorgehensweise nicht sinnvoll. Es wäre vielmehr besser, je nach Komplexität des Refactorings das dafür kleinstmögliche Modell innerhalb einer Modellfamilie zu verwenden. Im Zuge der Arbeit soll im Rahmen eines Experiments gezeigt werden, ob die Kritikalität von Code Smells (oder ähnliche Eigenschaften von Code Smells) als Auswahlkriterium für die Wahl eines möglichst kleinen Modells einer Modellfamilie geeignet ist.
Literaturanalyse
- Überblick über Arbeiten zum automatisierten Refactoring von Code Smells
- Identifikation von Arbeiten, die sich mit optimierten Auswahl von LLMs beschäftigen
- Identifikation von Eigenschaften von Code Smells für die Auswahl eines möglichst kleinen LLMs einer Modellfamilie
Praktischer Teil
- Konzeption, Entwicklung und Auswertung eines vollautomatisierten Experiments, das zum Ziel hat, herauszufinden, ob die identifizierten Eigenschaften von Code Smells für die Auswahl eines möglichst kleinen LLMs einer Modellfamilie geeignet sind
- Idealerweise werden zumindest zwei Modellfamilien untersucht, um eine Aussage darüber treffen zu können, ob die Ergebnisse spezifisch für ein Modell oder unabhängig von der Modellfamilie sind.
Betreuung: Reinhold Plösch
Status: OFFEN
Vergleich der Eignung von Index-Systemen für systemweite Refactorings von großen Codebasen
Aktuelle Forschungsergebnisse zeigen, dass das automatische Refactoring von Code Smells mit LLMs gut funktioniert – zumindest für kleine Refactorings, die nur eine oder wenige Sourcecode-Dateien betreffen. Bei systemweiten Refactorings stoßen LLMs typischerweise an ihre Grenzen. Im Zuge dieser Arbeiten sollen Index-Systeme identifiziert und beurteilt werden, die auf zuverlässige Art und Weise die für große Refactorings notwendigen Symbolinformationen (z.B. wo wird eine Methode aufgerufen, in welcher Klasse wird eine Methode überschrieben) zur Verfügung stellen. Ziel ist es, die Stärken und Schwächen dieser Systeme für das Refactoring von großen Codebasen (300K+) zu untersuchen. Die Arbeit soll sich dabei nicht nur auf MCP-Server konzentrieren, sondern auch auf IDE-basierte oder ähnliche Ansätze.
Literaturanalyse
- Identifikation von Index-Systemen, die für das KI-basierte Refactoring geeignet erscheinen
- Identifikation der Stärken und Schwächen der jeweiligen Ansätze aus der Sicht des KI-basierten Refactorings
Praktischer Teil
- Entwicklung eines quantitativen Kriterienkatalogs zur Beurteilung der Index-Systeme
- Praktischer Vergleich ausgewählte Index-Systeme (die Auswahl erfolgt auf Basis der identifizierten Stärken und Schwächen) anhand unterschiedlicher Codebasen
- Quantitative Beurteilung der betrachteten Index-Systeme auf Basis des entwickelten Kriterienkatalogs
Betreuung: Reinhold Plösch
Status: OFFEN
Analyse der Eignung von Codebase-Memory MCP für systemweite Refactorings
Aktuelle Forschungsergebnisse zeigen, dass das automatische Refactoring von Code Smells mit LLMs gut funktioniert – zumindest für kleine Refactorings, die nur eine oder wenige Sourcecode-Dateien betreffen. Bei systemweiten Refactorings stoßen LLMs typischerweise an ihre Grenzen. Das Open-Source-Projekt Codebase-Memory (https://deusdata.github.io/codebase-memory-mcp/) könnte ein guter Ansatz für systemweite Refactorings sein. Im Zuge der Arbeit soll untersucht werden, wie Codebase-Memory für automatiserte Refactorings am besten verwendet wird, um zuverlässige systemweite Refactorings zu erreichen.
Literaturanalyse
- Überblick über die Funktionsweise von Codebase-Memory MCP
- Überblick über Arbeiten, die Codebase-Memory MCP für Refactoring verwenden – Identifikation von Best Practices
Praktischer Teil
- Implementierung eines Prototypen (z.B. als Claude-Code Skill) für das Refactoring ausgewählte Code oder Design Smells.
- Umfangreiche Validierung des Prototyps anhand einer größeren Anzahl der vom Werkzeug unterstützten Code und Design Smells. Dabei sind neben großen Projekten auch kleine Projekte zu berücksichtigen.
Betreuung: Reinhold Plösch
Status: OFFEN
KI-gestützte Generierung adaptiver Übungsbeispiele zur Klausurvorbereitung
Studierende bereiten sich auf Klausuren häufig mit einer begrenzten Anzahl bekannter Übungsbeispiele vor, die weder auf ihren individuellen Lernstand zugeschnitten sind noch ausreichend Variation bieten, um das Verständnis wirklich zu festigen. Generative KI-Systeme eröffnen hier neue Möglichkeiten: Aus bestehenden Aufgaben und Vorlesungsfolien als Wissensbasis lassen sich automatisiert neue, thematisch passende Übungsbeispiele erzeugen, deren Schwierigkeitsgrad sich an der bisherigen Lösungsleistung der Studierenden orientiert. Ziel dieser Arbeit ist die Konzeption, Implementierung und Evaluation eines solchen Systems zur adaptiven Klausurvorbereitung.
Literaturanalyse
- Überblick über bestehende Ansätze zur automatisierten Generierung von Übungs- und Prüfungsaufgaben mittels KI/LLMs
- Identifikation von Konzepten zur Schwierigkeitsgradsteuerung und Adaption an den individuellen Lernfortschritt
- Herausarbeiten von Kriterien zur Qualitätssicherung automatisch generierter Übungsbeispiele
Praktischer Teil
- Konzeption eines Systems, das auf Basis bestehender Aufgaben und Vorlesungsfolien neue, thematisch passende Übungsbeispiele generiert
- Entwicklung eines Mechanismus zur Anpassung des Schwierigkeitsgrads anhand der bisherigen Lösungsleistung sowie zur Berücksichtigung des Lernfortschritts über mehrere Beispiele hinweg
- Implementierung eines Prototyps und Einbindung der generierten Beispiele in eine von Studierenden nutzbare Umgebung (z.B. Google Colab)
- Evaluation des Prototyps, z.B. anhand der Qualität und Passgenauigkeit der generierten Beispiele
Betreuung: Iris Groher
Status: OFFEN
IDE-integriertes KI-Feedback für Python-Programmieraufgaben
Studierende bearbeiten Programmieraufgaben typischerweise in lokalen Entwicklungsumgebungen (z.B. Visual Studio Code), während Feedback erst nach Abgabe über automatisierte Tests oder Lehrende bzw. Tutoren erfolgt. Dadurch bleibt der eigentliche Problemlöseprozess weitgehend unsichtbar, obwohl gerade dieser für das Lernen zentral ist. Bisherige KI-Assistenzsysteme in Entwicklungsumgebungen (z.B. Copilot) fokussieren primär auf Code-Generierung und Produktivitätssteigerung, nicht auf didaktisch kontrollierte Lernunterstützung. Ziel dieser Arbeit ist die Konzeption, Implementierung und Evaluation eines einfachen VS-Code-Plugins, das den aktuell bearbeiteten Python-Code von Studierenden analysiert und bei Erkennung typischer Fehlermuster kontextsensitives, lernorientiertes Feedback gibt, ohne dabei vollständige Lösungen zu generieren.
Literaturanalyse
- Überblick über bestehende Ansätze zu KI-gestützten Feedback- und Assistenzsystemen in Entwicklungsumgebungen
- Identifikation typischer Fehlermuster von Studierenden bei Python-Programmieraufgaben aus der Literatur
- Herausarbeiten von Kriterien für lernförderliches (formatives) im Vergleich zu lösungsgenerierendem Feedback
Praktischer Teil
- Konzeption eines Prototyps für ein VS-Code-Plugin, das den aktuell bearbeiteten Code auf eine ausgewählte Menge typischer Fehlermuster hin analysiert
- Implementierung des Prototyps inklusive Anzeige des kontextsensitiven Feedbacks direkt in der IDE
- Implementierung einfacher Guardrail-Mechanismen zur Vermeidung vollständiger Lösungsgenerierung
- Evaluation des Prototyps anhand ausgewählter Python-Übungsaufgaben
Betreuung: Iris Groher
Status: VERGEBEN
Erfassung und Kategorisierung von Bearbeitungsprozessen bei Programmieraufgaben
Wenn Studierende Programmieraufgaben bearbeiten, entsteht dabei ein Prozess aus vielen kleinen Änderungsschritten, etwa das Beheben von Syntaxfehlern, iteratives Ausprobieren, Refactoring oder gezielte Korrekturen der Lösungslogik. Dieser Prozess bleibt bislang meist unsichtbar, da üblicherweise nur der finale, abgegebene Code betrachtet wird. Für ein besseres Verständnis, wie Studierende beim Programmieren lernen und wo typische Schwierigkeiten auftreten, ist es jedoch wertvoll, diesen Bearbeitungsprozess systematisch zu erfassen. Ziel dieser Arbeit ist die Konzeption und Implementierung eines VS-Code-Plugins, das Codeänderungen während der Bearbeitung von Python-Aufgaben kontinuierlich erfasst, in sinnvolle Kategorien einteilt (z.B. Syntaxkorrektur, Logikänderung, Trial-and-Error) und für eine spätere Analyse strukturiert ablegt.
Literaturanalyse
- Überblick über bestehende Ansätze zur Aufzeichnung und Analyse von Programmierprozessen
- Identifikation von Kategorisierungsschemata für Code-Änderungen bzw. Edit-Events aus der Literatur
- Herausarbeiten von Kriterien für eine datenschutzkonforme und aussagekräftige Erfassung von Bearbeitungsprozessen
Praktischer Teil
- Konzeption eines Prototyps für ein VS-Code-Plugin, das Codeänderungen während der Bearbeitung von Python-Aufgaben laufend erfasst
- Entwicklung eines Kategorisierungsschemas sowie eines Mechanismus zur automatisierten Klassifikation der erfassten Änderungen
- Implementierung einer strukturierten Ablage der kategorisierten Daten für die spätere Analyse
- Evaluation des Prototyps anhand aufgezeichneter Bearbeitungsprozesse bei ausgewählten Python-Übungsaufgaben
Betreuung: Iris Groher
Status: VERGEBEN
Didaktische Integration von KI in die Programmierausbildung: Konzepte für „AI-first”-Lehransätze
Generative KI-Coding-Assistenten (z.B. GitHub Copilot, ChatGPT) sind für Programmieranfänger:innen längst verfügbar und werden von ihnen selbstverständlich genutzt, unabhängig davon, ob Lehrveranstaltungen darauf ausgelegt sind. Etablierte Curricula für Einführungslehrveranstaltungen wurden jedoch größtenteils für eine Welt ohne KI-Unterstützung konzipiert. In der internationalen Diskussion haben sich dazu unterschiedliche Positionen herausgebildet: von einer strikten “Foundations-first”-Haltung, die den KI-Einsatz bewusst hinauszögert, bis zu “AI-first”-Ansätzen, die generative KI von Beginn an integraler Bestandteil der Lehre sein lassen und den Fokus von reiner Syntaxbeherrschung hin zu Fähigkeiten wie Prompting, Code-Review und kritischer Bewertung von KI-generiertem Code verschieben. Ziel dieser Arbeit ist ein Rahmenwerk zur systematischen Einordnung und zum Vergleich didaktischer Ansätze.
Literaturanalyse
- Überblick über bestehende didaktische Ansätze (“AI-first” vs. “Foundations-first”)
- Systematisierung von Kriterien für Zeitpunkt/Umfang der KI-Integration
- Kompetenzverschiebungen (Syntax → Prompting, Code-Review, kritische Bewertung)
Praktischer Teil
- Entwicklung eines Kriterienkatalogs/Rahmenwerks
- Anwendung auf reale Curricula/Syllabi als Fallstudien
- Ergänzende Interviews mit Lehrenden zu ihren Erfahrungen
- Handlungsempfehlungen
Betreuung: Iris Groher
Status: VERGEBEN
Multi-Agenten-System zur Generierung und Qualitätssicherung von Hinweisen bei Programmieraufgaben
Studierende profitieren beim Lösen von Programmieraufgaben von zeitnahen, gut dosierten Hinweisen (Hints). Das bedeutet, dass sowohl fehlende Hilfe auf der einen Seite, aber auch generierte vollständige Lösungen den Lernerfolg mindern. Einzelne, undifferenzierte LLM-Prompts zur Hint-Generierung laufen jedoch Gefahr, entweder zu vage zu bleiben, Konzepte zu verwenden die Studierende noch nicht verstehen, oder unbeabsichtigt die Lösung preiszugeben, und bieten somit wenig Kontrolle über den Entstehungsprozess des Hinweises. Aktuelle Arbeiten zeigen, dass sich diese Aufgabe auf mehrere spezialisierte Agenten aufteilen lässt, etwa einen Agenten zur Analyse des aktuellen Codes/Kontexts, einen zur Hint-Generierung und einen zur Prüfung, ob der Hinweis die Lösung preisgibt.
Ziel dieser Arbeit ist die Konzeption, Implementierung und Evaluation eines solchen Multi-Agenten-Systems zur Hint-Generierung für Python-Programmieraufgaben.
Literaturanalyse
- Überblick über bestehende (Multi-Agenten-)Ansätze zur KI-gestützten Hint-Generierung in der Programmierausbildung
- Pädagogische Prinzipien für “gute” Hints (Minimal-Help-Prinzip, sokratisches Fragen, Scaffolding) und deren Umsetzung in bisherigen Systemen
- Ansätze zur Erkennung/Verhinderung von Lösungsleckage in KI-generiertem Feedback
Praktischer Teil
- Konzeption einer Multi-Agenten-Architektur (u.a. Kontextanalyse-, Hint-Generierungs- und Verifikations-Agent) zur Hint-Generierung für Python-Programmieraufgaben
- Implementierung eines Prototyps
- Beurteilung von Hint-Qualität und Lösungsleckage
Betreuung: Iris Groher
Status: OFFEN
Partielles Laden und Speichern von EMF-Modellen mittels FlatBuffers, Protocol Buffers oder Cap’n Proto
Hinweis: Erfahrung mit Java ist von Vorteil, idealerweise auch mit Eclipse bzw. dem Eclipse Modeling Framework (EMF).
Das Eclipse Modeling Framework (EMF) ist die de-facto Standardplattform der modellgetriebenen Softwareentwicklung. EMF-Modelle werden standardmäßig im XML-basierten XMI-Format gespeichert. Dabei wird eine Modelldatei stets als Ganzes geladen bzw. gespeichert, auch wenn nur ein kleiner Teil des Modells benötigt oder verändert wird. Bei großen Modellen führt dies zu langen Lade- und Speicherzeiten sowie zu hohem Speicherbedarf.
Binäre Serialisierungsformate wie FlatBuffers, Protocol Buffers oder Cap’n Proto versprechen deutlich schnellere Lese- und Schreibzugriffe. Einige dieser Formate erlauben zudem den Zugriff auf einzelne Daten, ohne die gesamte Datei vorab zu deserialisieren. Dies eröffnet die Möglichkeit, nur Teile eines Modells (partielle Modelle) zu laden und zu speichern.
Ziel dieser Arbeit ist die Konzeption und Umsetzung eines Persistenzmechanismus für EMF-Modelle, der partielle Modelle unterstützt und durch den Einsatz eines binären Serialisierungsformats deutlich schnellere Lese- und Schreibzugriffe als XMI ermöglicht.
Literaturanalyse
- Analyse der Persistenzmechanismen von EMF (XMI, Resource-API) sowie existierender Ansätze zur skalierbaren Modellpersistenz (z.B. NeoEMF, CDO)
- Vergleich von FlatBuffers, Protocol Buffers und Cap’n Proto hinsichtlich Datenmodell, Schema-Evolution, Unterstützung partieller Zugriffe und Java-Anbindung
- Untersuchung von Konzepten für partielles Laden (Lazy Loading) und Fragmentierung von Modellen
Praktischer Teil
- Konzeption einer Abbildung von Ecore-Metamodellen auf Schemata des gewählten Formats, inkl. Vererbung, Containment- und Querverweisen
- Implementierung eines Generators, der aus einem Ecore-Metamodell das entsprechende Schema erzeugt
- Implementierung einer EMF-Resource, die Modelle im gewählten Format speichert und das partielle Laden und Speichern von Modellteilen unterstützt
- Evaluation mittels Benchmarks (Lade- und Speicherzeiten, Speicherbedarf, Dateigröße) im Vergleich zu XMI anhand unterschiedlich großer Modelle
- Optional: Vergleich mehrerer der genannten Formate
Betreuung: Stefan Klikovits
Status: Verfügbar
Automatisierte Analyse von Fahrszenarien
Für die Entwicklung und das Verständnis autonomer Fahrsysteme ist eine detaillierte Analyse von Szenarien essenziell. Neben der visuellen oder manuellen Betrachtung gewinnt die automatisierte Szenarioanalyse an Bedeutung, etwa zur Merkmalserkennung, Transformation oder Bewertung. Solche Analysen können z.B. helfen, strukturelle Eigenschaften eines Straßennetzwerks zu erkennen oder die Komplexität eines Szenarios zu klassifizieren.
Ziel dieser Arbeit ist die Entwicklung einer flexiblen Tool-Pipeline, mit der verschiedene Analyse- und Transformationstools auf Fahrszenarien angewendet werden können. Diese Tools sollen aus den Szenariendaten (z.B. aus OpenSCENARIO oder CommonRoad Dateien) automatisiert Merkmale extrahieren – wie etwa die Topologie des Straßennetzes, die Anzahl der Fahrspuren oder die Dichte des Verkehrs – und die Ergebnisse strukturiert abspeichern.
Literaturanalyse
- Analyse bestehender Verfahren zur strukturierten Analyse und Feature-Extraktion in simulierten Fahrszenarien
- Untersuchung von existierenden Szenarien und Toolsets für gängige Simulatoren wie Carla, esmini, Apollo oder Autoware
- Anforderungen an Pipelines zur automatisierten Verarbeitung von Simulationsdaten
Praktischer Teil
- Entwicklung einer modularen Pipeline zur Analyse und Transformation von Szenarien
- Implementierung ausgewählter Analyse-Tools (z.B. Straßennetz-Extraktion als Graph, Feature-Klassifikation)
- Zusammenstellung eines repräsentativen Datensatzes aus verschiedenen Simulatoren (z.B. Carla, esmini, Apollo, Autoware) zur Evaluation
- Speicherung und strukturierte Dokumentation der Ergebnisse für Vergleichs- oder Weiterverwendungszwecke
Betreuung: Stefan Klikovits
Status: Verfügbar
Ein Mixed-Reality-Showcase: Reales Fahrzeug weicht virtuellen Hindernissen aus
Hinweis: Für diese Arbeit ist die Arbeit mit dem realen PiCar am Institut erforderlich. Ein regelmäßiges Vor-Ort-Arbeiten am Institut ist daher Voraussetzung; ein rein remote durchführbares Projekt ist nicht möglich.
Digitale Zwillinge werden meist entweder als reine Simulation (z.B. zur Analyse oder zum Testen) oder als 1:1-Abbild eines einzelnen physischen Assets betrachtet. In realen Anwendungsszenarien müssen physische Assets jedoch zunehmend auch mit rein virtuellen, physisch nicht existierenden Entitäten interagieren, zum Beispiel wenn ein reales Fahrzeug auf ein simuliertes Hindernis reagieren muss. Am Institut steht mit dem Raspberry-Pi-Car ein reales Asset zur Verfügung. Ein digitaler Zwilling sowie eine Simulationsumgebung für das PiCar existieren jedoch noch nicht und sind im Rahmen dieser Arbeit zu erstellen.
Der Begriff Mixed Reality bezieht sich hier auf die Interaktion physischer und virtueller Entitäten und nicht auf eine AR/VR-Darstellung. Ziel dieser Arbeit ist die Konzeption und Umsetzung eines anschaulichen Showcases, in dem ein reales PiCar in Echtzeit virtuellen, nicht-physisch existierenden Hindernissen ausweicht. Kern der Umsetzung ist ein Controller, der neben den echten Sensordaten des PiCars auch virtuelle Sensordaten injizieren kann, die von simulierten Entitäten in der Simulationsumgebung stammen. Diese virtuellen Sensordaten sollen dabei im selben Format wie die realen Sensordaten des PiCars vorliegen (z.B. simulierte Distanzmesswerte im Format der tatsächlich verbauten Sensorik), sodass die Steuerungslogik nicht zwischen realen und virtuellen Quellen unterscheiden muss. Der Showcase soll die Interaktion zwischen physischer und virtueller Welt für Betrachter:innen klar nachvollziehbar machen und sich z.B. für Lehr- oder Institutsvorführungen eignen. Eine allgemeine, wiederverwendbare Architektur ist nicht Ziel der Arbeit.
Literaturanalyse
- Analyse bestehender Showcases und Demonstratoren zur Interaktion physischer und virtueller Entitäten in Digital-Twin- bzw. Simulationsumgebungen
- Überblick über Methoden zur Hinderniserkennung und -vermeidung bei (semi-)autonomen Fahrzeugen
- Analyse der am PiCar tatsächlich verbauten Sensorik (Typ, Datenformat, Update-Rate) als Grundlage für die virtuellen Sensordaten
- Untersuchung von Konzepten zur Sensorabstraktion bzw. zum Einspielen (Injizieren) simulierter Sensordaten in reale Steuerungssysteme (z.B. Hardware-/Sensor-in-the-Loop-Ansätze)
Praktischer Teil
- Erstellung eines digitalen Zwillings des PiCars (Repräsentation von Zustand und relevanten Sensordaten)
- Aufbau einer Simulationsumgebung, in der virtuelle Hindernisse modelliert und deren simulierte Sensormessungen im Format der realen PiCar-Sensorik erzeugt werden
- Entwicklung eines Controllers für das PiCar, der reale Sensordaten mit im selben Format injizierten virtuellen Sensordaten kombiniert, ohne zwischen beiden Quellen unterscheiden zu müssen
- Implementierung der Ausweich- bzw. Bremslogik auf Basis dieser kombinierten Sensordaten: das reale PiCar reagiert in Echtzeit auf virtuelle Hindernisse
- Visualisierung des Gesamtszenarios (physisch + virtuell) für Betrachter:innen, z.B. als einfache 2D/3D-Ansicht
- Demonstration des Showcases anhand mehrerer vordefinierter Hindernis-Szenarien
- Evaluation der Nachvollziehbarkeit und Reaktionsfähigkeit des Showcases (z.B. Latenz zwischen injizierter Sensordatenänderung und Fahrzeugreaktion)
Betreuung: Stefan Klikovits
Status: Verfügbar
Automatisierte Identifikation sicherer Library Alternativen
Software Bill of Materials (SBOMs) gewinnen zunehmend an Bedeutung für die Nachvollziehbarkeit und Sicherheit von Softwarekomponenten, insbesondere im Zuge regulatorischer Vorgaben wie dem Cyber Resilience Act (CRA). SBOMs ermöglichen durch standardisierte Beschreibungen (z.B. im CycloneDX- oder SPDX-Format) die genaue Auflistung aller im System verwendeten Komponenten inklusive Version, Quelle, Konfiguration und Lizenz.
Ziel dieser Arbeit ist es, auf Basis einer gegebenen SBOM mögliche Alternativen für jede gelistete Komponente automatisch zu identifizieren, die weniger oder keine bekannte Sicherheitslücken aufweisen, kompatible Lizenzen besitzen und funktional vergleichbar sind. Dadurch soll ein erster Schritt in Richtung automatischer Resilienz und Austauschbarkeit von Softwarearchitekturen geschaffen werden.
Literaturanalyse
- Analyse bestehender SBOM-Standards (CycloneDX, SPDX) und deren Datenmodelle
- Untersuchung von Ansätzen zur Schwachstellenbewertung anhand öffentlich zugänglicher Datenquellen (z.B. NVD, CVE, OSV.dev, CVSS)
- Analyse von Plattformen und Tools zur Komponentenverwaltung und -vergleich (z.B. Libraries.io, Deps.dev, ClearlyDefined)
- Überblick über bestehende Lizenzklassen und -einschränkungen (z.B. MIT, Apache, GPL) sowie Tools zur Lizenzprüfung
Praktischer Teil
- Entwicklung eines Tools, das aus einer gegebenen SBOM (CycloneDX/SPDX) die enthaltenen Komponenten extrahiert
- Abfrage geeigneter Plattformen zur Identifikation potenzieller Alternativen (z.B. via Libraries.io oder deps.dev API)
- Implementierung von Filtermechanismen zur Bewertung der Alternativen nach:
- Sicherheitsstatus (CVE-Freiheit, CVSS-Score)
- Lizenztyp (vergleichbare oder freizügigere Lizenzen)
- Beliebtheit und Community-Aktivität (Downloads, Maintenance)
- Funktionale Ähnlichkeit (z.B. Package-Kategorie, Dependency-Struktur)
- Zusammenstellung und Visualisierung der Alternativen mit Bewertung
- Optionale Erweiterung: Export einer neuen „empfohlenen SBOM“ auf Basis der Alternativen
Demonstration: Die entwickelte Lösung soll exemplarisch auf reale oder synthetische SBOMs angewendet und evaluiert werden (z.B. durch gezielte Auswahl verwundbarer Komponenten mit vorhandenen Alternativen).
Betreuung: Stefan Klikovits
Status: Verfügbar
Python-native Bibliothek für die Asset Administration Shell
Hinweis: Dieses Thema richtet sich an Python-affine Studierende. Python-Vorkenntnisse sind sehr zu Empfehlen, Vorkenntnisse zur Asset Administration Shell sind nicht notwendig.
Die Asset Administration Shell (AAS) ist der standardisierte digitale Repräsentant physischer und digitaler Assets im Kontext der Industrie 4.0. Für die Arbeit mit AAS in Python existieren bereits Software Development Kits (z.B. das Eclipse BaSyx Python SDK). Diese orientieren sich jedoch stark am AAS-Metamodell: Entwickler:innen müssen Submodelle, Submodel-Elemente und Referenzen explizit und oft sehr wortreich aufbauen, anstatt mit gewohnten Python-Klassen und -Attributen zu arbeiten. Dadurch entsteht viel Boilerplate-Code, und die Einstiegshürde für Python-Entwickler:innen ohne AAS-Hintergrund ist hoch.
Ziel dieser Arbeit ist die Konzeption und Umsetzung einer Python-Bibliothek mit einer deutlich schlankeren, “pythonischen” API für die AAS, ähnlich zu ORM Frameworks für SQL Datenbanken. Die Bibliothek soll sich nicht am Aufbau des AAS-Metamodells orientieren, sondern nativ in das Klassen-Ökosystem von Python integrieren: AAS und Submodelle sollen als gewöhnliche Python-Klassen definiert und verwendet werden können (z.B. mittels Type Hints, Dataclasses oder Deskriptoren), während die Abbildung auf die AAS-Struktur im Hintergrund erfolgt. Zusätzlich soll die Bibliothek die Anbindung an AAS-Server vereinfachen, insbesondere durch:
- Subscriptions: Abonnieren von Änderungen an AAS-Elementen auf einem AAS-Server
- Callbacks: Automatischer Aufruf benutzerdefinierter Funktionen bei Wertänderungen
- AutoSave: Automatische Synchronisation lokaler Änderungen mit dem AAS-Server, ohne explizite Speicheraufrufe
Literaturanalyse
- Analyse der AAS-Spezifikationen (Metamodell und API) sowie existierender AAS-SDKs (z.B. Eclipse BaSyx Python SDK) hinsichtlich Funktionsumfang und API-Design
- Untersuchung von Kriterien und Methoden zur Bewertung der Usability von APIs
- Analyse etablierter Python-Bibliotheken mit deklarativen, klassenbasierten APIs als Vorbild (z.B. ORMs wie SQLAlchemy oder Validierungsbibliotheken wie Pydantic)
- Überblick über Benachrichtigungs- und Synchronisationsmechanismen für AAS-Server (z.B. Polling der REST-API, ereignisbasierte Mechanismen)
Praktischer Teil
- Entwurf einer klassenbasierten API, mit der AAS und Submodelle als native Python-Klassen definiert, instanziiert und verändert werden können
- Implementierung der Abbildung zwischen Python-Klassen und AAS-Strukturen, inkl. Serialisierung in die Standardformate (z.B. JSON)
- Umsetzung der Anbindung an einen AAS-Server mit Subscription-, Callback- und AutoSave-Mechanismen
- Paketierung der Bibliothek (Installation via pip), automatisierte Tests und Dokumentation
Betreuung: Stefan Klikovits
Status: Verfügbar
Grafischer Online-Editor für Asset Administration Shells im Stil von UML-Klassen- und Objektdiagrammen
Die Asset Administration Shell (AAS) ist der standardisierte digitale Repräsentant industrieller Assets im Kontext der Industrie 4.0, spezifiziert durch die Industrial Digital Twin Association (IDTA). Eine AAS strukturiert die Informationen eines Assets über dessen gesamten Lebenszyklus als Hierarchie typisierter Submodelle. Das AAS-Metamodell selbst ist dabei in Form von UML-Klassendiagrammen spezifiziert.
Trotz dieser UML-Grundlage arbeiten bestehende AAS-Werkzeuge – allen voran der AASX Package Explorer – weitgehend auf Ebene von Baumansichten und Serialisierungsformaten (XML, JSON, AASX). Ingenieur:innen, die mit UML vertraut sind, können ihre gewohnte Modellierungssicht daher nicht nutzen. Ein leichtgewichtiger, UML-basierter AAS-Editor mit direkter Anbindung an einen laufenden AAS-Repository-Server fehlt bislang.
Ziel dieser Arbeit ist die Konzeption und Umsetzung eines grafischen Online-Editors für AAS, der den aktuellen Zustand eines AAS-Repository-Servers über dessen REST-API als UML-Diagramme darstellt: Klassendiagramme für die Struktur von Submodellen und Objektdiagramme für konkrete Asset-Instanzen. Benutzer:innen sollen AAS-Elemente direkt im Diagramm anlegen, ändern und löschen können. Der Editor soll entweder als direkte Webanwendung oder als Visual-Studio-Code-Erweiterung umgesetzt werden (z.B. auf Basis von Eclipse GLSP, analog zu Werkzeugen wie bigUML) und grundlegende Validierung gegen die Constraints des AAS-Metamodells bieten.
Literaturanalyse
- Analyse existierender AAS-Editoren (z.B. AASX Package Explorer, Eclipse BaSyx UI, Papyrus4Manufacturing)
- Untersuchung von Frameworks für webbasierte grafische Editoren (z.B. Eclipse GLSP, Sprotty, bigUML) zur Auswahl einer geeigneten technischen Basis
- Analyse des AAS-Metamodells (v3.x) und der standardisierten AAS-REST-API (IDTA Part 2)
Praktischer Teil
- Konzeption einer Abbildung zwischen AAS-Metamodell und UML-Klassen-/Objektdiagrammen (Submodelle, Submodel-Elemente, Properties, Referenzen)
- Implementierung einer Verbindungsschicht, die über die AAS-REST-API von einem laufenden AAS-Repository-Server liest und auf diesen schreibt
- Entwicklung des grafischen Editors zur Darstellung und Bearbeitung von Submodellstrukturen (Klassendiagramm) und Instanzen (Objektdiagramm)
- Implementierung einer metamodellbasierten Validierung mit direkter Rückmeldung im Diagramm
- Evaluation anhand einer Fallstudie mit einem realistischen AAS-Szenario, inkl. Vergleich von Usability und Modellierungsaufwand mit dem AASX Package Explorer
Von Vorteil
- Interesse an TypeScript/JavaScript und Web Development
- Kenntnisse von UML Klassen- und Objektdiagrammen
- Interesse an modellgetriebener Softwareentwicklung und digitalen Zwillingen
- Grundkenntnisse zu REST-APIs und JSON
Betreuung: Stefan Klikovits
Status: Verfügbar
