TY - RPRT A1 - Schubanz, Mathias T1 - How software engineers deal with decisions in Scrum – An analysis T1 - Wie Softwareentwickler mit Entscheidungen in Scrum umgehen - Eine Analyse N2 - The Agile Manifesto titled “Working software over comprehensive documentation”. Although the stated principle makes an important point, it should not follow that documentation becomes obsolete. On the contrary, agile software development (ASD) is based on frequent decisions focused on customer benefits. Those decisions guide further development, subsequent maintenance, and software evolution and are made during every stage of the software development cycle. Thus, documenting the most important ones is an important foundation fostering product comprehension, software quality, and customer benefit. Besides, preserving decision knowledge supports refactoring and, thus, diminishing software erosion. However, all these beneficial properties are opposed by a dismissive attitude among software developers. Documentation is very unpopular among software developers, especially in the ASD community. A common interpretation of the agile manifesto at this point is that good and functional code can fully replace documentation. Among other reasons, this attitude is the reason for the sparse application of structured and systematic documentation of decisions and their rationale. To shed more light on imponderables, developer’s desires regarding decision documentation, and assess the outlined perception of a lack of decision documentation, this paper reports a survey on decision documentation in Scrum among industry practitioners. The author assesses to what extent the above claims hold by asking industry practitioners about their perceptions and applied practices regarding decision documentation in Scrum. Therefore, the author conducted a large-scale survey in the German and English speaking Scrum community. A few more than 100 software developers were asked what they document, how they document and how they use/share produced documentation. The findings of this report reveal that there is a wide range of opinions in the agile community. The responses show that a developer’s experience significantly impacts the documentation frequency and the interest in the available documentation. Similarly, the role in which software developers have operated in Scrum plays a significant role in the frequency of documentation and the timing when developers document. N2 - Das Agile Manifest besagt sinngemäß "Funktionierende Software geht vor umfassende Dokumentation". Obwohl der genannte Grundsatz einen wichtigen Punkt darstellt, sollte daraus nicht folgen, dass Dokumentation obsolet wird. Im Gegenteil: Agile Softwareentwicklung (ASE) basiert auf häufigen Entscheidungen, die sich am Kundennutzen orientieren. Diese Entscheidungen leiten die weitere Entwicklung, die anschließende Wartung und die Software-Evolution und werden in jeder Phase des Software-Entwicklungszyklus getroffen. Daher ist die Dokumentation der wichtigsten Entscheidungen eine wichtige Grundlage, die das Produktverständnis, die Softwarequalität und den Kundennutzen fördert. Außerdem verbessert die Bewahrung von Entscheidungswissen das Refactoring und damit die Verringerung von Software-Erosion. All diesen positiven Eigenschaften steht jedoch eine ablehnende Haltung unter Softwareentwicklern gegenüber. Dokumentation ist bei Softwareentwicklern sehr unbeliebt, insbesondere in der ASE-Community. Eine gängige Interpretation des agilen Manifests ist an dieser Stelle, dass guter und funktionaler Code die Dokumentation vollständig ersetzen kann. Diese Einstellung ist unter anderem der Grund für die spärliche Anwendung von strukturierter und systematischer Dokumentation von Entscheidungen und deren Begründung. Um mehr Licht in die Unwägbarkeiten und Wünsche der Entwickler bezüglich der Entscheidungsdokumentation zu bringen und die skizzierte Wahrnehmung eines Mangels an Entscheidungsdokumentation zu bewerten, berichtet dieser Beitrag über eine Umfrage zum Thema Entscheidungsdokumentation in Scrum unter Entwicklern aus der Industrie. Der Autor erforscht, inwieweit die obigen Behauptungen zutreffen, indem er Praktiker aus der Industrie zu ihren Wahrnehmungen und angewandten Praktiken bezüglich der Entscheidungsdokumentation in Scrum befragt. Dazu führte der Autor in der deutsch- und englischsprachigen Scrum-Community eine umfangreiche Umfrage durch. Etwas mehr als 100 Softwareentwickler wurden befragt, was sie dokumentieren, wie sie dokumentieren und wie sie die erstellte Dokumentation nutzen/teilen. Die Ergebnisse zeigen, dass es eine große Bandbreite an Meinungen in der agilen Community gibt. Die Antworten lassen erkennen, dass die Erfahrung eines Entwicklers einen signifikanten Einfluss auf die Dokumentationshäufigkeit und das Interesse an der vorhandenen Dokumentation auswirkt. Ebenso ist die Rolle, in der Software Softwareentwickler in Scrum gearbeitet haben, entscheidend für die Häufigkeit der Dokumentation und den Zeitpunkt, wann Entwickler dokumentieren. KW - Agile software development KW - Decision documentation KW - Survey KW - Rationale management KW - Scrum KW - Agiles Software Engineering KW - Entscheidungsdokumentation KW - Umfrage KW - Begründungsmanagement KW - Scrum KW - Agile Softwareentwicklung KW - Scrum KW - Programmdokumentation KW - Umfrage Y1 - 2021 U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:co1-opus4-50662 ER - TY - THES A1 - Noack, Andreas T1 - Unified quality measures for clusterings, layouts, and orderings of graphs, and their application as software design criteria T1 - Einheitliche Gütemaße für Clusterings, Layouts und Orderings von Graphen, und deren Anwendung als Software-Entwurfskriterien N2 - How good is a given graph clustering, graph layout, or graph ordering --specifically, how well does it group densely connected vertices and separate sparsely connected vertices? How good is a given software design -- specifically, how well does it minimize the interdependence of the subsystems? This work introduces and validates simple and uniform measures for these two properties. Together with existing optimization algorithms, the introduced measures enable the automatic computation e.g. of communities in social networks and of design flaws in software systems. The first part derives, validates, and unifies quality measures for graph clusterings, graph layouts, and graph orderings, with the following results: - Identical quality measures can be applied to clusterings, layouts, and orderings; this enables the computation of consistent clusterings, layouts, and orderings. - Diverse existing and new measures can be unified into few general measures; this facilitates their comparison and validation. - Many existing measures are biased towards certain clusterings, layouts, or orderings, even for graphs without particularly dense or sparse subgraphs, and thus do not (only) measure quality in the above sense. - For example graphs, the minimization of new, unbiased (or weakly biased) measures reveals nonobvious groups, e.g. communities in social networks, subject areas in hypertexts, or closely interlocked countries in international trade. The second part derives, validates, and unifies dependency-based indicators of software design quality. It applies two quality measures for graph clusterings as measures for the coupling of software subsystems -- specifically for the coupling indicated by common changes and for the coupling indicated by references -- and shows: - The measures quantify the dependency-caused development costs, under well-defined simplifying assumptions. - The minimization of the measures conforms to existing dependency-related design principles (like locality of change, acyclicity of references, and stability of references), design rules, and design patterns. - For example software systems, the incremental minimization of the measures reveals nonobvious design flaws, like the distribution of coherent responsibilities over several subsystems, or references from low-level to high-level subsystems. In summary, this work shows that - simple measures can suffice to capture important aspects of graph clustering quality, graph layout quality, graph ordering quality, and software design quality, and - the optimization of simple measures can suffice to detect nonobvious and often useful structure in various real-world systems. N2 - Wie gut ist ein Graph-Clustering, Graph-Layout oder Graph-Ordering -- insbesondere, wie gut gruppiert es dicht verbundene Knoten? Wie gut ist ein Software-Entwurf -- insbesondere, wie gut minimiert er die Abhängigkeiten zwischen Subsystemen? Für diese beiden Eigenschaften definiert und validiert die vorliegende Arbeit einfache und einheitliche Maße. Zusammen mit existierenden Optimierungsalgorithmen ermöglichen diese Maße die automatische Entdeckung z.B. von kohäsiven Communities in sozialen Netzwerken und von Entwurfsfehlern in Software-Systemen. Der erste Teil definiert, validiert und vereinheitlicht Gütemaße für Graph-Clusterings, Graph-Layouts und Graph-Orderings, mit folgenden Ergebnissen: - Identische Gütemaße können auf Clusterings, Layouts und Orderings angewendet werden. Dies ermöglicht die Berechnung von konsistenten Clusterings, Layouts und Orderings. - Viele existierende und neue Gütemaße können zu wenigen allgemeinen Maßen vereinheitlicht werden; dies erleichtert ihren Vergleich und ihre Validierung. - Viele existierende Maße messen nicht (nur) Güte im obigen Sinne, da sie selbst für Graphen ohne ungewöhnlich dichte oder dünne Teilgraphen bestimmte Clusterings, Layouts oder Orderings bevorzugen. - Durch Optimierung verbesserter Maße lassen sich nicht-offensichtliche Gruppen in vielen realen Systemen finden, z.B. Communities in sozialen Netzwerken, Themengebiete in Hypertexten, und Integrationsräume in der Weltwirtschaft. Der zweite Teil definiert, validiert und vereinheitlicht abhängigkeitsbasierte Indikatoren für Software-Entwurfsqualität. Er verwendet zwei Gütemaße für Graph-Clusterings als Maße für die Kopplung von Software-Subsystemen -- insbesondere für Kopplung, deren Symptom gemeinsame Änderungen sind und für Kopplung, deren Ursache Referenzen sind -- und zeigt: - Die Maße quantifizieren die durch Abhängigkeiten verursachten Entwicklungskosten, unter vereinfachenden Annahmen. - Die Optimierung der Maße impliziert anerkannte Entwurfsprinzipien (z.B. Lokalität von Änderungen, Azyklizität von Referenzen, und Stabilität von Referenzen), Entwurfsregeln und Entwurfsmuster. - Durch Optimierung der Maße lassen sich nicht-offensichtliche Entwurfsfehler finden, z.B. die Verteilung kohärenter Verantwortlichkeiten über mehrere Subsysteme, oder Referenzen von allgemeinen zu speziellen Subsystemen. Zusammenfassend zeigt die Arbeit, dass - einfache Maße ausreichen, um wichtige Aspekte der Qualität von Graph-Clusterings, Graph-Layouts, Graph-Orderings und Software-Entwürfen zu formalisieren, und - die Optimierung einfacher Maße ausreicht, um nicht-offensichtliche und nützliche Struktur in verschiedensten Systemen zu finden. KW - Softwareentwicklung KW - Graphische Darstellung KW - Computergraphik KW - Projektmanagement KW - Graph-Clustering KW - Graphenzeichnen KW - Wissensextraktion KW - Softwareentwurf KW - Refactoring KW - Graph clustering KW - Graph layout KW - Knowledge discovery KW - Software design KW - Refactoring Y1 - 2007 U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:co1-opus-4046 ER - TY - THES A1 - Steinbrückner, Frank T1 - Consistent Software Cities : supporting comprehension of evolving software systems T1 - Consistent Software Cities : ein Ansatz zur entwicklungsbegleitenden Visualisierung von Softwaresystemen N2 - Software visualization is a field of software engineering which aims at providing visual representations of software systems or particular aspects thereof. Numerous approaches for the visualization of software systems have been developed during the last decades. Software cities denote one particular kind of software visualizations that adopts the city metaphor for depicting software systems as virtual cities. Due to their high expressiveness and effectiveness software cities are mainly used for program comprehension tasks, during reverse engineering, and in quality analysis scenarios. Software systems evolve. They are steadily enhanced to provide new product functions, corrected to fix defects, or adapted to changed system environments. Software cities, as proposed today, do not take this evolutionary character of software systems into account. The evolution of software systems, i.e. changes to their internal structure and other characteristics, can easily disrupt the overall software city structure and thus yield very inconsistent visualizations for evolving software systems. The interpretation of these evolving software cities may be error-prone and time-consuming. In this thesis we propose a new software city approach that is based on the observation that real cities often reveal their evolution insofar as they contain e.g. historic centers or satellite cities. Analogous patterns, however, cannot be found in software cities which is an astonishing divergence. We claim that by preserving historical structures and carefully expanding software cities during software evolution, i.e. by spatializing software evolution, we obtain highly expressive, effective, and consistent software cities which support a broader range of application scenarios than the current state of the field. The main contribution of this thesis is a new layout approach for software cities, which explicitly takes evolution into account. Its effects are twofold: First, evolution becomes directly visible in the software city structure in the form of specific geographic patterns that each depicts particular evolutionary phenomena. The resulting increased expressiveness allows for supporting new application scenarios which are evaluated for several example systems. Second, software evolution does no longer disrupt the overall software city structure. Instead, the software cities evolve smoothly during system evolution, which allows for using them during ongoing system development and maintenance. The high consistency of this approach is confirmed in an empirical evaluation. N2 - In den vergangenen Jahren wurden zahlreiche, teils sehr unterschiedliche Ansätze für die Visualisierung von Softwaresystemen vorgestellt. Softwarestädte sind ein spezieller Visualisierungsansatz, in dem Strukturen und Eigenschaften von Softwaresystemen in Form virtueller Städte dargestellt werden können. Aufgrund ihrer hohen Ausdruckskraft und Effektivität werden Softwarestädte hauptsächlich zur Programmanalyse, insbesondere während Reverse-Engineering Aktivitäten und in der Softwarequalitätsanalyse eingesetzt. Ein wesentliches Problem bisheriger Ansätze liegt in der Instabilität von Softwarestädten gegenüber Softwareänderungen. Selbst kleinste Änderungen an Softwaresystemen können schnell zu gravierenden strukturellen Änderungen der sie repräsentierenden Softwarestädte führen. Die dabei entstehenden Inkonsistenzen der Visualisierungen verschiedener Versionsstände erschweren die Interpretierbarkeit, insbesondere die Nachverfolgbarkeit von Softwareänderungen, und verstärken somit das Risiko von Fehlinterpretationen. Ein entwicklungsbegleitender Einsatz von Softwarestädten mit dem Ziel der kontinuierlichen Überwachung und frühzeitigen Erkennung von Entwicklungsproblemen wird somit erschwert. Während sich in realen Städten im Verlauf ihrer Entwicklung typische Strukturen, wie z.B. historische Stadtkerne oder Vorstädte, herausbilden, lassen sich analoge Muster in bisherigen Softwarestädten nicht finden. Gerade auch in Softwarestädten lassen sich durch die Erhaltung historischer Strukturen jedoch ausdrucksstarke, effektive und vor allem konsistente Visualisierungen formen. In dieser Arbeit wird daher ein neuer Ansatz für die Visualisierung von Softwaresystemen als Softwarestädte vorgestellt, in dem die Entwicklungshistorie von Softwaresystemen berücksichtigt, die Strukturen in Softwarestädten erhalten und ihr entwicklungsbegleitender Einsatz somit ermöglicht wird. Der Hauptbeitrag der Arbeit ist ein neuer Ansatz für die Visualisierung dynamischer hierarchischer Strukturen. Angewandt auf Softwarestädte hat dieser Ansatz gegenüber bisherigen Ansätzen zwei wesentliche Vorteile: Zum einen wird Evolution direkt sichtbar in Form bekannter städtischer Strukturen, die jeweils ein spezifisches Entwicklungsmuster repräsentieren. Wie im Verlauf der Arbeit gezeigt wird, ermöglicht die sich daraus ergebende erhöhte Ausdruckskraft der Visualisierungen die Unterstützung neuer Analyseszenarien. Zum anderen zerstören Softwareänderungen nicht mehr die grundlegende Struktur der Softwarestädte, wodurch insbesondere ihr entwicklungsbegleitender Einsatz mit dem Ziel der kontinuierlichen Projektüberwachung ermöglicht wird. KW - Informationstechnik KW - Stadtentwicklung KW - Virtuelle Realität KW - Rechnernetz KW - Softwarestädte KW - Softwarevisualisierung KW - Software cities KW - Software visualization Y1 - 2013 U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:co1-opus-28078 ER - TY - THES A1 - Schubanz, Mathias T1 - CUSTOM – MADE Scrum : CUSTOMized MAnagement of DEcision – knowledge in Scrum T1 - CUSTOM – MADE Scrum : Maßgeschneidertes Entscheidungsmanagement im Scrum N2 - Das Managen von Entscheidungen in der Softwareentwicklung, insbesondere im agilen Kontext, stellt eine anspruchsvolle Aufgabe dar. Oft können Entscheidungen anhand von durchgeführten Aktionen oder dem Quellcode nachvollzogen werden. Häufig bleibt jedoch das "Warum?" unklar. Das Fehlen von Begründungen erschwert zukünftige Entwicklungsarbeiten, Wartungsarbeiten oder etwaige Weiterentwicklungen erheblich. Besonders interessant ist auch oft die Frage nach dem "Warum nicht?" – also warum wurde eine Lösungsalternative verworfen? Diese Fragen sind zentral für Softwareentwickler. Im Gegensatz dazu tendieren lineare Vorgehensmodelle wie das Wasserfall-Modell dazu, übermäßig viel zu dokumentieren. Produkt- und Prozessdokumentation sowie detaillierte Handbücher sind hier üblich. Sie lösen jedoch nicht das Dilemma der Asymmetrie zwischen Angebot und Nachfrage. Der Paradigmenwechsel hin zu agilen Methoden hat dieses Problem auch nicht gelöst, sondern möglicherweise sogar verschärft. Das agile Manifest betont zwar die Kommunikation über Dokumentation, doch viele Entwickler interpretieren dies falsch und betrachten Code als die einzige Dokumentation. Die vorliegende Arbeit setzt an diesem Problem im Rahmen des Scrum-Frameworks an. Ihr Ziel ist es, die Dokumentation von wichtigen Entscheidungen strukturierter in den Scrum-Prozess zu integrieren. Die Arbeit umfasst eine Literaturuntersuchung, um festzustellen, was und in welchem Umfang dokumentiert werden sollte. Darüber hinaus beschäftigt sie sich mit der Frage, wie diese Dokumentation effektiv in den Scrum-Prozess integriert werden kann. Um diese Ziele zu erreichen, wurden Erfahrungen aus der Praxis durch Interviews und eine umfassende Umfrage eingeholt. Industrieerfahrene Softwareentwickler sowie mehrere hundert Studierende wurden in Fallstudien einbezogen. Die resultierenden Daten ergänzen den bestehenden Stand der Forschung und helfen, Wege für eine strukturierte Dokumentation, Verarbeitung und Wiederverwendung von Entscheidungswissen in Scrum zu identifizieren. Basierend auf den neuen Erkenntnissen wurde eine Erweiterung des Scrum-Frameworks namens Custom-MADE Scrum abgeleitet. Sie zeichnet sich durch einen adaptiven und flexiblen Ansatz zur Dokumentation von Entscheidungen und ihrer Begründung aus. Weiterhin definiert sie klare Verantwortlichkeiten und bietet Prozessbausteine für die strukturierte Integration der Dokumentation relevanter Entscheidungen in. Diese Erweiterung kann sowohl in bestehende als auch neu aufzusetzende Projekte integriert werden. Zusätzlich zu der Erweiterung wurde ein Werkzeug namens Custom-MADE Editor entwickelt. Es zielt darauf alle Potenziale zur Automatisierung der Dokumentation innerhalb des Custom-MADE Scrum zu heben, um den Prozess so effizient wie möglich zu gestalten. Insgesamt präsentiert der Autor einen flexiblen Ansatz zur systematischen Integration von Entscheidungsdokumentation in das Scrum-Framework. Die Ergebnisse stützen sich auf verschiedene empirische Arbeiten. N2 - Managing decisions in software development, especially in the agile context, is a challenging task. Often, decisions can be traced back through actions taken or the source code. However, the "Why?" behind these decisions is frequently unclear. The absence of explanations significantly complicates future development, maintenance, or further advancements. Also intriguing is the question of "Why not?" – why was an alternative solution discarded? These questions are central to software developers. In contrast, linear models like the waterfall approach tend to over-document. Product and process documentation, along with detailed manuals, are common. However, they fail to address the dilemma of asymmetry between supply and demand. The paradigm shift towards agile methods hasn't solved this problem, possibly exacerbating it. Though the agile manifesto emphasizes communication over documentation, many developers misunderstand it, considering code the sole documentation. This work addresses this issue within the Scrum framework, aiming to integrate the documentation of important decisions more systematically. It includes a literature review to determine what and to what extent should be documented. Additionally, it explores how this documentation can be effectively integrated into the Scrum process. To achieve these goals, practical experiences were gathered through interviews and a comprehensive survey. Industry-experienced software developers and several hundred students participated in case studies. The resulting data complement existing research and help identify ways to structure documentation, processing, and reuse decision knowledge in Scrum. Based on these insights, an extension of the Scrum framework called Custom-MADE Scrum was derived. It features an adaptive and flexible approach to documenting decisions and their rationale. It also defines clear responsibilities and provides process modules for the structured integration of decision documentation. This extension can be integrated into both existing and new projects. In addition to the extension, a tool called Custom-MADE Editor was developed. It aims to leverage automation to streamline documentation within Custom-MADE Scrum, making the process as efficient as possible. Overall, the author presents a flexible approach to systematically integrate decision documentation into the Scrum framework. The results are based on various empirical works. KW - Scrum KW - Rationale management KW - Documentation KW - Knowledge management KW - Decision knowledge KW - Entscheidungsbegründungen KW - Entscheidungswissen KW - Dokumentation KW - Agile Softwareentwicklung KW - Scrum KW - Programmdokumentation Y1 - 2023 U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:co1-opus4-67003 ER - TY - THES A1 - Simon, Frank T1 - Meßwertbasierte Qualitätssicherung - ein generisches Distanzmaß zur Erweiterung bisheriger Softwareproduktmaße N2 - In dieser Arbeit werden neue Ansätze zur meßwertbasierten Qualitätssicherung von Softwareprodukten für praxisrelevante Systemgrößen beschrieben. Dies umfaßt Hilfen zur spezifischen Definition von Qualität, Prozesse zur Qualitätssicherung, Werkzeugunterstützung sowie die Identifikation von Problemen bei der Anwendung vieler bisheriger Softwaremaße. Die pragmatische Anwendung der Meßtheorie erlaubt eine Erweiterung in Form eines auf Ähnlichkeiten zwischen Softwareelementen basierenden generischen Distanzmaßes. Dessen unterschiedliche Instanziierungen ermöglichen die automatische, anpaßbare Gruppierung von Elementen, sowie die ausdrucksstarke, ausschließlich durch Meßwerte bestimmte Softwarevisualisierung. Die ebenfalls in dieser Arbeit wiedergegebene empirische Arbeit, in der die Effizienz und Effektivität dieses Ansatzes mehrfach belegt wird, demonstriert die mögliche Bedeutung der meßwertbasierten Qualitätssicherung bei der Analyse großer Systeme. N2 - In this work new concepts for the metrics based quality assurance of large software systems are presented. This includes techniques for defining quality, processes for quality assurance, tool support and identification of problems when applying state-of-the-art software metrics. The pragmatic application of measurement theory allows an extension that is based on a special similarity measure for software elements. The application of this metric in different ways allows for automatic and adjustable grouping of software elements and the powerful software visualisation that is based on metric values only. The empirical work, which is also presented, shows the efficiency and effectivity of the new approach and demonstrates the potential importance of the metrics based quality assurance for the analysis of large software systems. KW - Softwareentwicklung KW - Qualitätssicherung KW - Qualitätssteigerung KW - Softwaremetrie KW - Softwarequalität KW - Softwarevermessung KW - Softwaremaße KW - Softwarewartung Y1 - 2001 U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:co1-000000124 ER - TY - THES A1 - Beyer, Dirk T1 - Formale Verifikation von Realzeit-Systemen mittels Cottbus Timed Automata N2 - Die Konstruktion eingebetteter Systeme, die starke Realzeit-Anforderungen zu erfüllen haben, wird in den verschiedensten Anwendungsbereichen immer bedeutsamer, z. B. in der Medizin, der Transporttechnik oder der Produktionsautomatisierung. Formale Methoden unterstützen die fehlerarme Entwicklung solcher Systeme, weil sie auf einer präzisen mathematischen Grundlage aufbauen. Der Autor entwickelt einen geeigneten Modellierungsformalismus und effiziente Verifikationsverfahren für den Einsatz einer formalen Methode. Durch die Einführung eines Modulkonzepts wird die Modellierung auch großer Realzeit-Systeme systematisch unterstützt. Für die Verifikation werden effiziente BDD-basierte Algorithmen verwendet, wobei auch das Problem des Findens guter BDD-Variablenordnungen gelöst wird. Es werden sowohl Erreichbarkeitsanalyse als auch Verfeinerungsanalyse unterstützt. Die Praktikabilität der Ansätze zur Modellierung und Verifikation werden in verschiedenen Fallstudien aus den Bereichen der reaktiven Systeme und der Kommunikationsprotokolle demonstriert. N2 - The construction of embedded systems which have to fulfill hard real-time requirements is becoming more and more important in various application areas, e. g. in medicine, in transport technology, or in production automation. Formal methods support the development of faultless systems because they use a precise mathematical basis. The author developed a suitable modelling formalism and efficient verification methods to enable the application of a formal method. Due to the module concept introduced in the thesis, the modelling of large systems is supported systematically. For the verification efficient BDD-based algorithms are used, and the problem of finding good BDD variable orderings is solved. Reachability analysis as well as refinement checking are provided. The practicability of the approaches for modelling and verification is demonstrated by presenting various case studies from the application areas of reactive systems and protocol engineering. KW - Verteiltes System KW - Verifikation Y1 - 2002 U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:co1-000000258 ER - TY - THES A1 - Camargo da Silva, Thayná T1 - Extracting knowledge graphs from user stories using LangChain T1 - Extrahieren von Wissensgraphen aus User Storys mit LangChain N2 - Requirements engineering is a fundamental component in software engineering since it defines the software from the user’s perspective. In this context, user stories play a crucial role since they are simple, natural language descriptions of software requirements, and they are widely utilized in the industry, along with the agile development methodology. User stories, while valuable for capturing individual functionalities, offer a limited perspective of the overall system, hindering maintainability and comprehension. To address these challenges, extracting structured information and modeling user stories is crucial. Knowledge graphs offer a promising approach by providing a visual and structured representation of user stories, facilitating data storage and analysis, and reducing manual effort retrieval, leading to a more coherent and manageable system. Several methodologies to model stories employ Natural Language Processing (NLP) techniques, presenting limited precision, complex implementation, and difficulties to interpret a sentence [47]. Recent research has explored using large language models, such as ChatGPT-3.5 [1], to extract knowledge graph components (nodes and relationships) from user stories. However, the solution relies on specific models and lacks comprehensive data processing pipelines for constructing knowledge graphs. LangChain, a model-agnostic framework, is a promising tool that empowers the development of applications centered around large language models. Its adaptability extends to knowledge graph construction, facilitating the extraction of structured information from textual data and seamless integration with graph databases. This thesis introduces a novel methodology for the automated generation of knowledge graphs from user stories by leveraging the advanced capabilities of Large Language Models (LLMs). Utilizing the LangChain framework as a basis, the UserStoryGraph- Transformer (USGT) module was developed to extract nodes and relationships from user stories using an LLM to construct accurate knowledge graphs. This innovative technique was implemented in a script to fully automate the knowledge graph extraction process. Additionally, the evaluation was automated through a dedicated evaluation script, utilizing an annotated dataset for assessment. By enhancing the visualization and understanding of user requirements and domain concepts, this method fosters better alignment between software functionalities and user expectations, ultimately contributing to more effective and user-centric software development processes. N2 - Die Anforderungsanalyse ist ein grundlegender Bestandteil der Softwareentwicklung, da sie die Software aus der Sicht des Benutzers definiert. In diesem Zusammenhang spielen User Storys eine entscheidende Rolle, da sie einfache, natürlichsprachliche Beschreibungen von Softwareanforderungen sind und in der Industrie zusammen mit der agilen Entwicklungsmethodik weit verbreitet sind. User Storys sind zwar wertvoll für die Erfassung einzelner Funktionalitäten, bieten aber nur eine begrenzte Sichtweise auf das Gesamtsystem, was die Wartbarkeit und das Verständnis erschwert. Um diese Herausforderungen zu bewältigen, ist die Extraktion von strukturierten Informationen und die Modellierung von User Storys von entscheidender Bedeutung. Wissensgraphen bieten einen vielversprechenden Ansatz, da sie eine visuelle und strukturierte Darstellung von User Storys bieten, die Datenspeicherung und -analyse erleichtern und den manuellen Aufwand beim Abrufen reduzieren, was zu einem kohärenten und besser handhabbaren System führt. Mehrere Methoden zur Modellierung von Geschichten verwenden Techniken der natürlichen Sprachverarbeitung (NLP), die sich durch begrenzte Präzision, komplexe Implementierung und Schwierigkeiten bei der Interpretation eines Satzes auszeichnen. Jüngste Forschungsarbeiten haben sich mit der Verwendung großer Sprachmodelle wie ChatGPT-3.5 befasst, um Komponenten des Wissensgraphen (Knoten und Beziehungen) aus User Storys zu extrahieren. Die Lösung beruht jedoch auf spezifischen Modellen und es fehlt an umfassenden Datenverarbeitungspipelines für die Konstruktion von Wissensgraphen. LangChain, ein modellunabhängiges Framework, ist ein vielversprechendes Werkzeug, das die Entwicklung von Anwendungen ermöglicht, die auf großen Sprachmodellen basieren. Seine Anpassungsfähigkeit erstreckt sich auch auf die Konstruktion von Wissensgraphen und erleichtert die Extraktion strukturierter Informationen aus Textdaten und die nahtlose Integration mit Graphdatenbanken. In dieser Arbeit wird eine neuartige Methodik für die automatische Generierung von Wissensgraphen aus User Storys vorgestellt, indem die fortgeschrittenen Fähigkeiten von Large Language Models (LLMs) genutzt werden. Auf der Grundlage des LangChain-Frameworks wurde das Modul UserStoryGraphTransformer (USGT) entwickelt, um Knoten und Beziehungen aus User Storys mit Hilfe eines LLMs zu extrahieren und genaue Wissensgraphen zu erstellen. Zusätzlich wurde die Auswertung durch ein spezielles Auswertungsskript automatisiert, das einen kommentierten Datensatz zur Bewertung verwendet. Durch die Verbesserung der Visualisierung und des Verständnisses von Benutzeranforderungen und Domänenkonzepten fördert diese Methode eine bessere Abstimmung zwischen Softwarefunktionalitäten und Benutzererwartungen und trägt letztendlich zu effektiveren und benutzerzentrierten Softwareentwicklungsprozessen bei. KW - Knowledge graph KW - Requirements engineering KW - Langchain KW - User story KW - Large language models KW - Neo4j KW - Wissensgraphen KW - Anforderungsanalyse KW - Anwendererzählung KW - Requirements engineering KW - Großes Sprachmodell KW - Wissensgraph Y1 - 2025 U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:co1-opus4-70382 ER -