commit e4dcfbd6ff2078f563b696bae6fde1ed4a786f1e Author: christoph.schwoerer Date: Sat Nov 8 11:29:59 2025 +0100 init diff --git a/Exposee_Masterarbeit_CS-3b4365426366-safeBackup-0001.docx b/Exposee_Masterarbeit_CS-3b4365426366-safeBackup-0001.docx new file mode 100644 index 0000000..4f44e50 Binary files /dev/null and b/Exposee_Masterarbeit_CS-3b4365426366-safeBackup-0001.docx differ diff --git a/Exposee_Masterarbeit_CS.docx b/Exposee_Masterarbeit_CS.docx new file mode 100644 index 0000000..37fd64a Binary files /dev/null and b/Exposee_Masterarbeit_CS.docx differ diff --git a/Exposee_Masterarbeit_CS.typ b/Exposee_Masterarbeit_CS.typ new file mode 100644 index 0000000..81ab82d --- /dev/null +++ b/Exposee_Masterarbeit_CS.typ @@ -0,0 +1,45 @@ += #strong[Exposé zur Masterarbeit ] + +#strong[Reverse Requirements Engineering bei bestehenden Softwareprodukten unterstützt durch KI – dargestellt am Beispiel der c-entron GmbH] + +== #strong[1. Ausgangssituation und Unternehmenskontext] + +Die c-entron GmbH ist ein mittelständisches Softwareunternehmen, das eine über viele Jahre gewachsene Windows-basierte ERP-Software für IT-Systemhäuser entwickelt und vertreibt. Die bestehende Lösung bietet viele komplexe Funktionen, basiert jedoch auf einer über Jahre gewachsenen Codebasis, deren funktionale und nicht-funktionale Anforderungen nie systematisch dokumentiert wurden. + +Vor dem Hintergrund einer expansiven Vertriebspolitik ist eine Überarbeitung der Software notwendig, um eine Skalierbarkeit in der Entwicklung und Applikation zu gewährleisten. Hierzu ist die Migration von einer nativen Windows-Applikation zu einer modernen, webbasierten Plattform geplant. Diese Migration erfordert eine vollständige Neuentwicklung, die idealerweise auf einem strukturierten und vollständigen Anforderungskatalog basiert. + +== #strong[2. Problemstellung] + +Da für die bestehende Softwarelösung keine strukturierte und vollständige Dokumentation der Anforderungen existiert, fehlt eine belastbare Grundlage für die Neuentwicklung. + +Die zentrale Herausforderung besteht daher darin, die Anforderungen der bestehenden Lösung effizient und systematisch zu rekonstruieren – ein Prozess, der als #emph[Reverse Requirements Engineering] bezeichnet wird. Um diesen Prozess möglichst effizient zu gestalten, sollen funktionale Requirements durch eine KI aus dem bestehenden code extrahiert und strukturiert beschrieben werden. Nicht funktionale Requirements sollen über Interviews mit Stakeholdern mit den Ergebnissen aus der KI Analyse abgeglichen werden. + +#strong[3. Zielsetzung der Arbeit] + +Ziel dieser Arbeit ist es, ein KI-gestütztes Verfahren zu entwickeln, zu evaluieren und pilotartig zu implementieren, das es erlaubt, mit Hilfe eines LLM-Agenten aus bestehendem Softwarecode vollständige und strukturierte Requirements für die geplante Webanwendung zu extrahieren. Dies schließt funktionale sowie nicht-funktionale Anforderungen ein. + +Die Arbeit soll zudem ein konzeptionelles Prozessmodell aufzeigen, wie Unternehmen systematisch den Übergang von Altsoftware zu modernen Softwarearchitekturen – gestützt durch KI – gestalten können. + +== #strong[4. Forschungsfragen] + +- #strong[Grundlagen:] + - Was sind Large Language Models (LLMs) und wie funktionieren sie? + - Welche Anwendungsbereiche existieren für LLMs im Software Engineering? +- #strong[State of the Art:] + - Welche Verfahren des Reverse Requirements Engineerings existieren aktuell? + - Welche Best Practices existieren im klassischen Requirements Engineering? + - Wie werden LLMs derzeit im Bereich Requirements Engineering eingesetzt? +- #strong[Anwendung:] + - Wie kann der Einsatz von LLMs konkret helfen, Requirements aus bestehender Software zu extrahieren? + - Welche Herausforderungen und Limitationen ergeben sich aus dem Einsatz von LLMs in diesem Kontext? +- #strong[Evaluation:] + - Wie bewerten Stakeholder die Qualität der gewonnenen Anforderungen? + - Welche nicht-funktionalen Anforderungen (Sicherheit, Performanz, Usability etc.) müssen zusätzlich berücksichtigt werden? + +== #strong[5. Methodisches Vorgehen] + +- #strong[Literaturrecherche:] Systematische Analyse wissenschaftlicher und praxisnaher Literatur zu LLMs und Requirements Engineering. +- #strong[Technologische Evaluation:] Untersuchung aktueller LLMs auf ihre Eignung für das Requirements Engineering. +- #strong[Interviews mit Stakeholdern:] Qualitative Erhebung nicht-funktionaler Anforderungen und Erwartungen an das zukünftige System. +- #strong[Pilotimplementierung:] Entwicklung eines LLM-basierten Prototyps (Agent) zur automatisierten Analyse und Extraktion von Requirements. +- #strong[Validierung:] Vergleich der extrahierten Anforderungen mit Stakeholder-Erwartungen sowie qualitativer Review durch Expert:innen der c-entron GmbH. \ No newline at end of file diff --git a/Exposee_Masterarbeit_feedback.typ b/Exposee_Masterarbeit_feedback.typ new file mode 100644 index 0000000..db804a7 --- /dev/null +++ b/Exposee_Masterarbeit_feedback.typ @@ -0,0 +1,142 @@ += AW: Masterarbeit - Exposee + +#strong[Von: ]"Schallmo, Daniel Professor Dr." +#strong[Datum: ]2025-07-30 08:58:06 +0200 + +Lieber Christoph, + +#strong[danke dir. Anbei mein Feedback]: + +#strong[Stärken] + +- Relevanz: Die Kombination aus Legacy-Migration, KI-Einsatz und Requirements Engineering adressiert ein zentrales Digitalisierungsthema in KMUs. + +- Realitätsbezug: Der Unternehmenskontext ist nachvollziehbar und gut beschrieben – das erhöht die Anschlussfähigkeit für Stakeholder. + +- Methodenpluralität: Literaturarbeit, Prototypenentwicklung und qualitative Interviews erzeugen ein ganzheitliches Bild. + +#strong[Verbesserungsvorschläge] + +1. Titel schärfen + +#strong[Der aktuelle Titel ist lang und mehrteilig. Eine kürzere, fokussiertere Variante könnte lauten]: + +- KI-gestütztes Reverse Requirements Engineering bei Legacy-Software: Eine Fallstudie bei der c-entron GmbH + +#strong[Optionaler Untertitel]: + +- Extraktion funktionaler und nicht-funktionaler Anforderungen mithilfe von LLMs + +2. Problemstellung analytischer zuspitzen + +#strong[Die aktuelle Problemstellung beschreibt die Ausgangslage gut, bleibt jedoch auf einer allgemeinen Ebene. Ergänzend hilfreich wäre]: + +- eine kurze Beschreibung der Konsequenzen fehlender Anforderungen (z. B. Re-Implementationsfehler, technische Schuld, Ineffizienzen), + +- und eine Einordnung der besonderen Komplexität, die sich durch eine über Jahre gewachsene Codebasis ergibt. + +#strong[Formulierungsvorschlag]: + +„Die fehlende Dokumentation erschwert die gezielte Migration erheblich, da sowohl funktionale Redundanzen als auch implizit verankerte Prozesse nur durch aufwendige manuelle Analysen identifiziert werden können.“ + +3. Forschungsfragen konsolidieren + +#strong[Die aktuelle Gliederung mit Unterpunkten und den zahlreichen Forschungsfragen wirkt umfangreich und etwas fragmentiert. Eine mögliche Umstrukturierung]: + +#strong[Forschungsleitfragen (komprimiert)]: + +- Wie können LLMs systematisch für Reverse Requirements Engineering eingesetzt werden? + +- Welche funktionalen und nicht-funktionalen Anforderungen lassen sich durch eine Kombination von KI-Analyse und Stakeholder-Interviews extrahieren? + +- Wie bewerten Fachexpert:innen die Qualität und Vollständigkeit der gewonnenen Requirements? + +- Welche Chancen und Grenzen ergeben sich beim KI-gestützten Requirements Engineering in Legacy-Umgebungen? + +Optional: Die Grundlagenfragen (z. B. zu LLMs) können in den theoretischen Hintergrund integriert werden, statt als eigene Forschungsfragen aufgeführt zu werden. + +4. Evaluationskriterium für Qualität präzisieren + +#strong[Die Validierung der extrahierten Anforderungen ist zentral. Es sollte deutlicher gemacht werden, wie Qualität gemessen wird. Mögliche Indikatoren]: + +- Vollständigkeit (gegenüber manuell dokumentierten Anforderungen), + +- Verständlichkeit für Entwickler:innen, + +- Redundanzfreiheit, + +- Übereinstimmung mit Stakeholder-Erwartungen. + +#strong[Offene Fragen] + +- Modellspezifikation: Welches LLM kommt konkret zum Einsatz (z. B. GPT-4, Claude 3)? Welche Fähigkeiten (z. B. Codeverständnis, Promptsteuerung) sind entscheidend? + +- Rechtliche Aspekte: Wird der Einsatz von KI im Unternehmen in Bezug auf IP, Datenschutz und Sicherheit betrachtet? + +- Grenzen der Automatisierung: Wie wird mit impliziten Anforderungen (z. B. durch gewachsene Prozesse) umgegangen, die nicht im Code abgebildet sind? + +- Toolchain-Integration: Ist geplant, den entwickelten Prototypen in bestehende Tools (z. B. Jira, Confluence) zu integrieren oder als eigenständige Lösung zu evaluieren? + +- Quellen: Welche Quellen dienen als Basis? Z.B.: + +- https://ijasce.org/index.php/IJASCE/article/view/152 + +- https://www.interaction-design.org/literature/book/the-encyclopedia-of-human-computer-interaction-2nd-ed/requirements-engineering + +- https://www.bibsonomy.org/bibtex/1510ac6a2b48df877bbdcd429daee73eb/butonic?lang=de + +- https://arxiv.org/pdf/2308.10620 + +- https://arxiv.org/abs/2312.15223 + +- https://kclpure.kcl.ac.uk/ws/portalfiles/portal/341048798/fcomp-1-1519437.pdf + +- Zeitplan: Wann planst du was zu tun? + +Liebe Grüße, + +#strong[Daniel] + +#strong[Best regards] + +Prof. Dr. Daniel Schallmo + +Director of the Institute for Entrepreneurship, Innovation, and Sustainability (IfE) + +Member of the Institute for Digital Transformation (IDT) + +University of Applied Sciences Neu-Ulm + +Wileystr. 1 +D-89231 Neu-Ulm + ++49(0)731-9762-1531 +daniel.schallmo@hnu.de + +https://www.hnu.de/ife/en https://www.hnu.de/en/research/institutes-and-competence-centres/institute-for-entrepreneurship + +#strong[Latest publications]: + +Twin Transition: Theoretical Background, Empirical Insights, and Integrated Approach (Paper | Int. Journal of Innovation Management | B-ranked | 2025) https://www.worldscientific.com/doi/full/10.1142/S136391962540002X + +Successful Digital Entrepreneurship: A Systematic Literature Review on Strategies, Measures, and Tools (Paper | HMD Praxis der Wirtschaftsinformatik | C-ranked | 2025) https://link.springer.com/article/10.1365/s40702-025-01153-z + +Berlin as a Hotspot for Digital Entrepreneurship: An Empirical Analysis of the Entrepreneurial Ecosystem (Paper | HMD Praxis der Wirtschaftsinformatik | C-ranked | 2025) https://link.springer.com/article/10.1365/s40702-025-01154-y + +Digital Transformation Success Factors: A Systematic Literature Review and Bibliometric Analysis (Paper | Int. Journal of Innovation Management | B-ranked | 2024) https://www.worldscientific.com/doi/full/10.1142/S1363919624400048 + +Strategies for digital entrepreneurship success (Paper | European Journal of Innovation Management | C-ranked | 2024) https://www.emerald.com/insight/content/doi/10.1108/EJIM-01-2024-0081/full/html + +Digital Disruption and Transformation (Book | Springer | 2024) https://link.springer.com/book/10.1007/978-3-031-47888-8 + +Digitale Plattformen und Ökosysteme im B2B-Bereich (Book | Springer | 2024) https://link.springer.com/book/9783658431297 + +#strong[Find all publications and additional information here]: + +www.hnu.de/en/daniel-schallmo http://www.hnu.de/en/daniel-schallmo + +https://www.linkedin.com/in/danielschallmo/ + +https://www.hnu.de/en/daniel-schallmo + +\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ diff --git a/Exposee_Masterarbeit_final.typ b/Exposee_Masterarbeit_final.typ new file mode 100644 index 0000000..df49090 --- /dev/null +++ b/Exposee_Masterarbeit_final.typ @@ -0,0 +1,71 @@ += #strong[Exposé zur Masterarbeit] + +#strong[KI-gestütztes Reverse Requirements Engineering bei Legacy-Software: Eine Fallstudie bei der c-entron GmbH] +#emph[Extraktion funktionaler und nicht-funktionaler Anforderungen mithilfe von LLMs] + +== #strong[1. Ausgangssituation und Unternehmenskontext] + +Die c-entron GmbH ist ein mittelständisches Softwareunternehmen, das eine über viele Jahre gewachsene Windows-basierte ERP-Software für IT-Systemhäuser entwickelt und vertreibt. Die bestehende Lösung bietet zahlreiche komplexe Funktionen, basiert jedoch auf einer historisch gewachsenen Codebasis, deren funktionale und nicht-funktionale Anforderungen nie systematisch dokumentiert wurden. + +Vor dem Hintergrund einer expansiven Vertriebspolitik ist eine Überarbeitung der Software notwendig, um Skalierbarkeit in Entwicklung, Betrieb und Roll-out zu gewährleisten. Hierzu ist der Übergang von einer nativen Windows-Applikation zu einer modernen, webbasierten Plattform geplant. Diese Migration erfordert eine weitgehend vollständige Neuentwicklung, die idealerweise auf einem strukturierten und nachvollziehbaren Anforderungskatalog basiert. + +== #strong[2. Problemstellung] + +Da für die bestehende Softwarelösung keine strukturierte und vollständige Dokumentation der Anforderungen existiert, fehlt eine belastbare Grundlage für die Neuentwicklung. Die fehlende Dokumentation erschwert die gezielte Migration erheblich, da sowohl funktionale Redundanzen als auch implizit verankerte Prozesse nur durch aufwendige manuelle Analysen identifiziert werden können. + +Die Konsequenzen sind Re-Implementationsfehler, hohe technische Schuld, Ineffizienzen in der Entwicklung sowie ein erhöhtes Risiko, geschäftskritische Prozesse nicht passgenau zu übertragen. Die über Jahre gewachsene Codebasis verstärkt diese Komplexität, weil implizite Annahmen und domain-spezifisches Wissen häufig nur im Quellcode oder bei einzelnen Expert:innen verankert sind. + +== #strong[3. Zielsetzung] + +Ziel dieser Arbeit ist es, ein KI-gestütztes Verfahren zu entwickeln, zu evaluieren und pilotartig zu implementieren, das mit Hilfe eines LLM-Agenten aus bestehendem Softwarecode vollständige und strukturierte Requirements für die geplante Webanwendung extrahiert. Dies schließt funktionale sowie nicht-funktionale Anforderungen ein. + +Darüber hinaus soll ein konzeptionelles Prozessmodell aufgezeigt werden, wie Unternehmen den Übergang von Altsoftware zu modernen Softwarearchitekturen systematisch gestalten können. Die Arbeit liefert Entscheidungsgrundlagen zur Einbettung KI-gestützter Analysen in bestehende Toolchains und adressiert Governance-, Datenschutz- und IP-rechtliche Fragestellungen. + +== #strong[4. Forschungsleitfragen] + +- Wie können Large Language Models systematisch für Reverse Requirements Engineering in Legacy-Software eingesetzt werden? +- Welche funktionalen und nicht-funktionalen Anforderungen lassen sich durch eine Kombination aus KI-gestützter Codeanalyse und Stakeholder-Interviews extrahieren? +- Wie bewerten Fachexpert:innen die Qualität und Vollständigkeit der durch KI gewonnenen Requirements? +- Welche Chancen und Grenzen ergeben sich beim KI-gestützten Requirements Engineering in Legacy-Umgebungen? + +== #strong[5. Methodisches Vorgehen] + +- #strong[Literatur- und Marktanalyse:] Systematische Auswertung wissenschaftlicher und praxisnaher Quellen zu LLMs, Reverse Requirements Engineering und Legacy-Modernisierung; Ableitung eines theoretischen Bezugsrahmens. +- #strong[Technologieauswahl und -evaluation:] Vergleich führender LLMs (z. B. GPT-4o, Claude 3.5, Code-Llama 70B) hinsichtlich Codeverständnis, Kontrollierbarkeit und Integration; Auswahl eines Hauptmodells und Ergänzungsmodelle für spezielle Aufgaben. +- #strong[Stakeholder-Interviews:] Qualitative Interviews mit Entwickler:innen, Product Ownern und Kundenseite zur Erhebung nicht-funktionaler Anforderungen, Risiken und regulatorischer Rahmenbedingungen. +- #strong[Prototypische Agentenentwicklung:] Aufbau eines LLM-basierten Reverse-Engineering-Agenten, der Code-Repositorys analysiert, Requirements strukturiert beschreibt und mit Traceability-Metadaten anreichert. +- #strong[Validierung und Qualitätsmessung:] Strukturierte Evaluation der extrahierten Anforderungen anhand definierter Kriterien (siehe Abschnitt 7) inklusive Vergleich mit manuell erhobenen Anforderungen sowie Expert:innen-Review bei der c-entron GmbH. +- #strong[Governance und Compliance-Analyse:] Bewertung von Datenschutz, IP-Schutz und Sicherheit beim Einsatz externer KI-Dienste; Ableitung von Handlungsempfehlungen für den produktiven Einsatz. +- #strong[Dokumentation und Transfer:] Erstellung eines Prozessmodells, Guidelines für den operativen Einsatz und Handlungsempfehlungen zur Integration in bestehende Tools (z. B. Jira, Confluence). + +== #strong[6. Rahmenbedingungen und Annahmen] + +- Zugriff auf repräsentative Codebasen und bestehende Artefakte der Legacy-Anwendung (z. B. Tickets, Nutzer:innen-Dokumentation). +- Möglichkeit zum kontrollierten Einsatz kommerzieller und Open-Source-LLMs innerhalb der Sicherheitsrichtlinien der c-entron GmbH. +- Bereitschaft der Stakeholder, an Interviews, Workshops und Validierungssessions teilzunehmen. +- Integrationserprobung erfolgt in einer isolierten Toolchain, bevor eine produktive Anbindung an Jira oder Confluence bewertet wird. +- Implizite Anforderungen, die nicht im Code abgebildet sind, werden über ergänzende Shadowing-Sessions und Prozessanalysen identifiziert. + +== #strong[7. Evaluationskriterien und Messgrößen] + +- #strong[Vollständigkeit:] Anteil der durch KI identifizierten Requirements im Vergleich zu einem goldenen Referenzset. +- #strong[Verständlichkeit:] Expertenrating zu Klarheit, Präzision und Umsetzbarkeit der dokumentierten Anforderungen. +- #strong[Redundanzfreiheit:] Analyse doppelter oder widersprüchlicher Requirements vor und nach KI-Einsatz. +- #strong[Stakeholder-Alignment:] Abgleich der KI-Ergebnisse mit Erwartungen und Prioritäten aus Interviews. +- #strong[Aufwandsreduktion:] Vergleich der benötigten Zeit für Requirementserhebung mit und ohne KI-Unterstützung. + +== #strong[8. Geplanter Zeitplan] + +- #strong[Monat 1–2:] Vertiefte Literatur- und Marktanalyse, Festlegung des theoretischen Rahmens, Definition des Evaluationsdesigns. +- #strong[Monat 2–3:] Technologieauswahl, technische Einrichtung der Agenten-Infrastruktur, Sicherheits- und Compliance-Check. +- #strong[Monat 3–4:] Durchführung der Stakeholder-Interviews, Aufbereitung und Synthese der Ergebnisse. +- #strong[Monat 4–5:] Entwicklung und iterative Verfeinerung des LLM-Agenten, erste Extraktionen und interne Tests. +- #strong[Monat 5–6:] Validierungsphase mit Expert:innen-Workshops, Messung der Evaluationskriterien, Ableitung von Handlungsempfehlungen. +- #strong[Monat 6:] Finalisierung der Dokumentation, Erstellung des Prozessmodells und Vorbereitung der schriftlichen Abschlussarbeit. + +== #strong[9. Erwartete Beiträge] + +- Ein reproduzierbares Prozessmodell für KI-gestütztes Reverse Requirements Engineering in Legacy-Kontexten. +- Ein prototypischer LLM-Agent inklusive Bewertungsmatrix für unterschiedliche Modelle und Konfigurationen. +- Handlungsempfehlungen zur Integration der gewonnenen Anforderungen in bestehende Toolchains und Governance-Strukturen der c-entron GmbH. +- Empirische Erkenntnisse zu Chancen, Grenzen und organisatorischen Voraussetzungen des KI-Einsatzes in der Anforderungserhebung. diff --git a/MA_style.pdf b/MA_style.pdf new file mode 100644 index 0000000..c775d18 Binary files /dev/null and b/MA_style.pdf differ diff --git a/MA_style.typ b/MA_style.typ new file mode 100644 index 0000000..e69de29 diff --git a/MA_test.typ b/MA_test.typ new file mode 100644 index 0000000..e69de29 diff --git a/Masterarbeit_draft.pdf b/Masterarbeit_draft.pdf new file mode 100644 index 0000000..cd64688 Binary files /dev/null and b/Masterarbeit_draft.pdf differ diff --git a/Masterarbeit_draft.typ b/Masterarbeit_draft.typ new file mode 100644 index 0000000..00ed5f9 --- /dev/null +++ b/Masterarbeit_draft.typ @@ -0,0 +1,122 @@ +#import "masterarbeit_style.typ": thesis + +#let meta = (thesis.meta)( + "KI-gestütztes Reverse Requirements Engineering bei Legacy-Software", + subtitle: "Masterarbeit an der Hochschule Neu-Ulm", + "Christoph Musterfrau", + "Master of Science", + "Prof. Dr. Daniel Schallmo", + "31. März 2026" +) + +#(thesis.cover)(meta) + +#pagebreak() + +#(thesis.declaration)(meta) + +#pagebreak() + +#(thesis.abstract)([ + #heading(level: 1)[Abstract] + Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ergänze hier die Zusammenfassung der Arbeit. +]) + +#pagebreak() + +#(thesis.body_show)() + +#(thesis.body_content)([ + #set page(numbering: "roman") + #counter(page).update(1) + #heading(level: 1)[Inhaltsverzeichnis] + #outline(depth: 3) + + #pagebreak() + #set page(numbering: "arabic") + #counter(page).update(1) + + #heading(level: 1)[Einleitung] + #heading(level: 2)[Motivation und Ausgangssituation] + Beschreibe die Relevanz der Migration der c-entron ERP-Software. + + #heading(level: 2)[Problemstellung] + Analysiere die Folgen fehlender Anforderungsdokumentation und den Einfluss der Legacy-Codebasis. + + #heading(level: 2)[Zielsetzung] + Formuliere das Forschungsziel und den erwarteten Beitrag der Masterarbeit. + + #heading(level: 2)[Forschungsleitfragen] + Liste die konsolidierten Forschungsleitfragen aus dem Exposé auf. + + #heading(level: 2)[Aufbau der Arbeit] + Erläutere die Struktur des Dokuments und die Rolle der einzelnen Kapitel. + + #heading(level: 1)[Theoretischer Hintergrund] + #heading(level: 2)[Large Language Models im Requirements Engineering] + Charakterisiere relevante LLM-Konzepte, Fähigkeiten und Grenzen. + + #heading(level: 2)[Reverse Requirements Engineering] + Beschreibe etablierte Verfahren, Herausforderungen und Best Practices. + + #heading(level: 2)[Legacy-Modernisierung und Governance] + Analysiere regulatorische, sicherheitsrelevante und organisatorische Aspekte. + + #heading(level: 1)[Methodisches Vorgehen] + #heading(level: 2)[Forschungsdesign und Vorgehensmodell] + Verbinde Literaturrecherche, Technologieevaluation und Interviews in einem konsistenten Design. + + #heading(level: 2)[Technologieauswahl und LLM-Konfiguration] + Dokumentiere Kriterien, Modellwahl und Evaluationsschritte. + + #heading(level: 2)[Datengrundlage und Stakeholder-Einbindung] + Beschreibe Datenquellen, Interviewleitfäden und Validierungsworkshops. + + #heading(level: 1)[Prototypische Umsetzung] + #heading(level: 2)[Architektur des LLM-Agenten] + Skizziere die Komponenten, Interaktionsabläufe und Traceability-Konzepte. + + #heading(level: 2)[Toolchain-Integration] + Bewerte die Einbindung in bestehende Systeme (z. B. Jira, Confluence). + + #heading(level: 2)[Governance, Datenschutz und IP] + Dokumentiere Maßnahmen zur Sicherstellung von Compliance. + + #heading(level: 1)[Evaluation] + #heading(level: 2)[Evaluationskriterien und Messgrößen] + Beschreibe Vollständigkeit, Verständlichkeit, Redundanzfreiheit, Stakeholder-Alignment und Aufwandsreduktion. + + #heading(level: 2)[Durchführung der Evaluation] + Erläutere Messaufbau, Workshop-Design und Datenauswertung. + + #heading(level: 2)[Ergebnisse] + Stelle die Resultate der Qualitätsbewertung zusammen. + + #heading(level: 1)[Diskussion] + #heading(level: 2)[Interpretation der Ergebnisse] + Vergleiche die Evaluation mit den Forschungsleitfragen. + + #heading(level: 2)[Chancen und Grenzen] + Diskutiere Potenziale und Limitationen des KI-gestützten Ansatzes. + + #heading(level: 2)[Implikationen für Forschung und Praxis] + Leitfäden für Unternehmen und offene Forschungsfragen. + + #heading(level: 1)[Fazit und Ausblick] + #heading(level: 2)[Zusammenfassung der Arbeit] + Fasse die wichtigsten Erkenntnisse zusammen. + + #heading(level: 2)[Ausblick] + Zeige zukünftige Forschungsschwerpunkte und Weiterentwicklungsmöglichkeiten des Prototyps. + + #heading(level: 2)[Handlungsempfehlungen] + Formuliere konkrete nächste Schritte für die c-entron GmbH. + + #heading(level: 1)[Literaturverzeichnis] + Ergänze hier das automatisch generierte Literaturverzeichnis. + + #heading(level: 1)[Anhang] + #heading(level: 2)[Interviewleitfäden] + #heading(level: 2)[Zusätzliches Datenmaterial] + #heading(level: 2)[Konfigurationsdetails des Prototyps] +]) diff --git a/emails/AW_ Masterarbeit - Exposee.msg b/emails/AW_ Masterarbeit - Exposee.msg new file mode 100644 index 0000000..b007828 Binary files /dev/null and b/emails/AW_ Masterarbeit - Exposee.msg differ diff --git a/masterarbeit_style.typ b/masterarbeit_style.typ new file mode 100644 index 0000000..4d5c17e --- /dev/null +++ b/masterarbeit_style.typ @@ -0,0 +1,97 @@ +#let thesis_meta(title, subtitle: none, author, degree, supervisor, submission_date) = ( + title: title, + subtitle: subtitle, + author: author, + degree: degree, + supervisor: supervisor, + submission_date: submission_date, +) + +#let cover(meta) = [ + #set page(numbering: none) + #align(center)[ + #set text(font: "Times New Roman", size: 12pt) + #v(5cm) + + #text(size: 20pt, weight: "bold")[#meta.title] + #if meta.subtitle != none [ + #v(6mm) + #text(size: 14pt)[#meta.subtitle] + ] + + #v(2cm) + #text(size: 12pt)[Masterarbeit] + #v(4mm) + #text(size: 12pt)[#meta.degree] + + #v(3cm) + #text(size: 12pt)[Autor: #meta.author] + #v(2mm) + #text(size: 12pt)[Betreuung: #meta.supervisor] + #v(2mm) + #text(size: 12pt)[Abgabedatum: #meta.submission_date] + + #v(2cm) + #text(size: 10pt)[Hochschule Neu-Ulm - Fakultaet fuer Wirtschaftswissenschaften] + ] +] + +#let declaration(meta) = [ + #set page(numbering: none) + #set text(font: "Times New Roman", size: 11pt) + #set par(leading: 14pt) + #heading(level: 1)[Eigenstaendigkeitserklaerung] + + Hiermit versichere ich, die vorliegende Masterarbeit selbstaendig verfasst und keine anderen als die angegebenen Quellen und Hilfsmittel verwendet zu haben. Alle woertlich oder sinngemaess uebernommenen Textstellen sind als solche gekennzeichnet. + + #v(2cm) + #align(left)[ + #text(size: 11pt)[Neu-Ulm, #raw("______________________________")] + #v(3mm) + #text(size: 11pt)[Unterschrift: #raw("______________________________")] + ] +] + +#let abstract(content) = [ + #set page(numbering: "arabic") + #set text(font: "Times New Roman", size: 11pt) + #set par(justify: true, leading: 14pt) + #content +] + +#let body_show() = [ + #set page( + paper: "a4", + margin: (top: 25mm, bottom: 25mm, inside: 30mm, outside: 20mm), + numbering: "arabic" + ) + #set text(font: "Times New Roman", size: 11pt) + #set par(justify: true, leading: 14pt, first-line-indent: 5mm) + #set list(indent: 6mm, spacing: 2mm) + #set heading(numbering: "1.", depth: 3) + #show heading.where(level: 1): it => [ + #set text(size: 16pt, weight: "bold") + #it.body + ] + #show heading.where(level: 2): it => [ + #set text(size: 13pt, weight: "semibold") + #it.body + ] + #show heading.where(level: 3): it => [ + #set text(size: 12pt, weight: "semibold") + #it.body + ] +] + +#let body_content(children) = [ + #children +] + +#let thesis = ( + meta: thesis_meta, + cover: cover, + declaration: declaration, + abstract: abstract, + body_show: body_show, + body_content: body_content, +)