1582 research outputs found
Sort by
Deep Learning for Dynamic Representations of Real-World Entities
Full text linkTechniken des Representation Learnings sind maßgeblich für die Funktion zahlreicher Anwendungen des Deep Learnings. Als Repräsentationen werden Abbildungen von realweltlichen Konzepten oder Dingen in den Vektorraum verstanden, welche als Eingangssignal für tiefe neuronale Netzwerke verwendet werden. Ein Beispiel sind sogenannte Wordvektoren, die als numerische Repräsentation von Worten in Techniken des Natural Language Processing Anwendung finden. Diese Repräsentationen sind kontextabhängig und können wie auch die zugrundeliegenden Wörter selbst verschiedene Bedeutungen in Abhängigkeit der benachbarten Wörter tragen. Auf der Ebene der numerischen Repräsentationen von Entitäten aus Wissensgraphen hingegen überwiegt der Ansatz statischer Vektorrepräsentationen. Im Hinblick auf die Speicherung statischer Informationen in Wissensgraphen ist diese Paradigma ausreichend, gerät jedoch an seine Grenzen sobald dynamische Situationen modelliert werden.
Diese Dissertation befasst sich damit, Techniken und Formalismen zu entwickeln, die es ermöglichen, kontextabhängige Vektorrepräsentationen auch für wissensgraphbasierte Anwendungen zu verwenden. Ziel ist es, mit diesen dynamischen oder kontextabhängigen Vektorrepräsentationen dynamische Situationen realweltlicher Entitäten zu modellieren. Im Rahmen dieser Arbeit umfasst dies Nutzer in sozialen Netzwerken, Fahrzeuge im Straßenverkehr, geopolitische Entitäten und Teilnehmer in einem Wahrnehmungsexperiment.
In diesem Rahmen wird auf Grundlage prädiktiver Fragestellungen (z.B. Welche Lokalität wird von einem Nutzer als nächstes aufgesucht?) empirisch aufgezeigt, dass die beschriebenen neuartigen Methoden den bekannten statischen Vektorrepräsentationen hinsichtlich der Modellierung dynamischen Verhaltens überlegen sind. Hierzu werden zunächst anhand empirischer Experimente die Grenzen statischer Verfahren aufgezeigt.
Aufbauend hierauf wird der temporally contextualized Knowledge Graph Formalismus und das dazugehörige Verfahren zum Embedding (d.h. der Abbildung in den Vektorraum) namens RETRA entworfen, mit dem die geforderte Kontextualisierung der Vektorrepräsentation von Entitäten aus Wissensgraphen realisiert wird. Anschließend wird im Rahmen einer weiteren empirischen Studie aufgezeigt, wie sich eine statische Welt auf das Konzept der situativen Kontextualisierung auswirkt und mit welchen Maßnahmen dem begegnet werden kann. Hierzu wird ein neuer Task eingeführt, für dessen Lösung es notwendig ist, verschiedene Kontextmodalitäten (hier Bild und Text) in eine wissensgraphbasierte Herangehensweise heranzuziehen.Representation Learning techniques play a crucial role in a wide variety of Deep Learning applications. From Language Generation to Link Prediction on Graphs, learned numerical vector representations often build the foundation for numerous downstream tasks.
In Natural Language Processing, word embeddings are contextualized and depend on their current context. This useful property reflects how words can have different meanings based on their neighboring words.
In Knowledge Graph Embedding (KGE) approaches, static vector representations are still the dominant approach. While this is sufficient for applications where the underlying Knowledge Graph (KG) mainly stores static information, it becomes a disadvantage when dynamic entity behavior needs to be modelled.
To address this issue, KGE approaches would need to model dynamic entities by incorporating situational and sequential context into the vector representations of entities. Analogous to contextualised word embeddings, this would allow entity embeddings to change depending on their history and current situational factors.
Therefore, this thesis provides a description of how to transform static KGE approaches to contextualised dynamic approaches and how the specific characteristics of different dynamic scenarios are need to be taken into consideration.
As a starting point, we conduct empirical studies that attempt to integrate sequential and situational context into static KG embeddings and investigate the limitations of the different approaches. In a second step, the identified limitations serve as guidance for developing a framework that enables KG embeddings to become truly dynamic, taking into account both the current situation and the past interactions of an entity. The two main contributions in this step are the introduction of the temporally contextualized Knowledge Graph formalism and the corresponding RETRA framework which realizes the contextualisation of entity embeddings.
Finally, we demonstrate how situational contextualisation can be realized even in static environments, where all object entities are passive at all times.
For this, we introduce a novel task that requires the combination of multiple context modalities and their integration with a KG based view on entity behavior
In-Situ Thread Visualization - Programming Framework, Visual Design, and Empirical Studies
Full text linkToday, almost every modern computing device is equipped with multicore processors capable of efficient concurrent and parallel execution of threads. This processor feature can be leveraged by concurrent programming, which is a challenge for software developers for two reasons: first, it introduces a paradigm shift that requires a new way of thinking. Second, it can lead to issues that are unique to concurrent programs due to the non-deterministic, interleaved execution of threads. Consequently, the debugging of concurrency and related performance issues is a rather difficult and often tedious task. Developers still lack on thread-aware programming tools that facilitate the understanding of concurrent programs. Ideally, these tools should be part of their daily working environment, which typically includes an Integrated Development Environment (IDE). In particular, the way source code is visually presented in traditional source-code editors does not convey much information on whether the source code is executed concurrently or in parallel in the first place.
With this dissertation, we pursue the main goal of facilitating and supporting the understanding and debugging of concurrent programs. To this end, we formulate and utilize a visualization paradigm that particularly includes the display of interactive glyph-based visualizations embedded in the source-code editor close to their corresponding artifacts (in-situ).
To facilitate the implementation of visualizations that comply with our paradigm as plugins for IDEs, we designed, implemented and evaluated a programming framework called CodeSparks. After presenting the design goals and the architecture of the framework, we demonstrate its versatility with a total of fourteen plugins realized by different developers using the CodeSparks framework (CodeSparks plugins). With focus group interviews, we empirically investigated how developers of the CodeSparks plugins experienced working with the framework. Based on the plugins, deliberate design decisions and the interview results, we discuss to what extent we achieved our design goals. We found that the framework is largely target programming-language independent and that it supports the development of plugins for a wide range of source-code-related tasks while hiding most of the details of the underlying plugin development API.
In addition, we applied our visualization paradigm to thread-related runtime data from concurrent programs to foster the awareness of source code being executed concurrently or in parallel. As a result, we developed and designed two in-situ thread visualizations, namely ThreadRadar and ThreadFork, with the latter building on the former. Both thread visualizations are based on a debugging approach, which combines statistical profiling, thread-aware runtime metrics, clustering of threads on the basis of these metrics, and finally interactive glyph-based in-situ visualizations. To address scalability issues of the ThreadRadar in terms of space required and the number of displayable thread clusters, we designed a revised thread visualization. This revision also involved the question of how many thread clusters k should be computed in the first place. To this end, we conducted experiments with the clustering of threads for artifacts from a corpus of concurrent Java programs that include real-world Java applications and concurrency bugs. We found that the maximum k on the one hand and the optimal k according to four cluster validation indices on the other hand rarely exceed three. However, occasionally thread clusterings with k > 3 are available and also optimal. Consequently, we revised both the clustering strategy and the visualization as parts of our debugging approach, which resulted in the ThreadFork visualization. Both in-situ thread visualizations, including their additional features that support the exploration of the thread data, are implemented in a tool called CodeSparks-JPT, i.e., as a CodeSparks plugin for IntelliJ IDEA.
With various empirical studies, including anecdotal usage scenarios, a usability test, web surveys, hands-on sessions, questionnaires and interviews, we investigated quality aspects of the in-situ thread visualizations and their corresponding tools. First, by a demonstration study, we illustrated the usefulness of the ThreadRadar visualization in investigating and fixing concurrency bugs and a performance bug. This was confirmed by a subsequent usability test and interview, which also provided formative feedback. Second, we investigated the interpretability and readability of the ThreadFork glyphs as well as the effectiveness of the ThreadFork visualization through anonymous web surveys. While we have found that the ThreadFork glyphs are correctly interpreted and readable, it remains unproven that the ThreadFork visualization effectively facilitates understanding the dynamic behavior of threads that concurrently executed portions of source code. Moreover, the overall usability of CodeSparks-JPT is perceived as "OK, but not acceptable" as the tool has issues with its learnability and memorability. However, all other usability aspects of CodeSparks-JPT that were examined are perceived as "above average" or "good".
Our work supports software-engineering researchers and practitioners in flexibly and swiftly developing novel glyph-based visualizations that are embedded in the source-code editor. Moreover, we provide in-situ thread visualizations that foster the awareness of source code being executed concurrently or in parallel. These in-situ thread visualizations can, for instance, be adapted, extended and used to analyze other use cases or to replicate the results. Through empirical studies, we have gradually shaped the design of the in-situ thread visualizations through data-driven decisions, and evaluated several quality aspects of the in-situ thread visualizations and the corresponding tools for their utility in understanding and debugging concurrent programs.Heutzutage ist fast jedes moderne Computergerät mit Multicore-Prozessoren ausgestattet, die eine effiziente nebenläufige und parallele Ausführung von Threads ermöglichen. Diese Prozessoreigenschaft kann durch nebenläufige Programmierung genutzt werden, was für Softwareentwicklerinnen und Softwareentwickler aus zwei Gründen eine Herausforderung darstellt: Erstens stellt sie einen Paradigmenwechsel dar, der eine neue Denkweise erfordert. Zweitens kann es zu Problemen kommen, die aufgrund der nicht-deterministischen, ineinander verzahnten Ausführung von Threads nur bei nebenläufigen Programmen auftreten. Folglich ist das Debugging von Nebenläufigkeit und damit verbundenen Performance-Problemen eine ziemlich schwierige und oft langwierige Aufgabe. Softwareentwickelnden fehlt es immer noch an Thread-sensitiven Programmierwerkzeugen, die das Verstehen von nebenläufigen Programmen erleichtern. Idealerweise sollten diese Werkzeuge Teil ihrer täglichen Arbeitsumgebung sein, zu der in der Regel eine integrierte Entwicklungsumgebung (IDE) gehört. Insbesondere die Art und Weise, wie der Quellcode in herkömmlichen Quellcode-Editoren visuell dargestellt wird, vermittelt kaum Informationen darüber, ob der Quellcode überhaupt parallel oder nebenläufig ausgeführt wird.
Mit dieser Dissertation verfolgen wir das Hauptziel, das Verstehen und das Debuggen von nebenläufigen Programmen zu erleichtern und zu unterstützen. Zu diesem Zweck formulieren und verwenden wir ein Visualisierungsparadigma, das insbesondere die Anzeige interaktiver, glyphenbasierter Visualisierungen umfasst, die in den Quellcode-Editor eingebettet sind und in unmittelbarer Nähe der entsprechenden Artefakte platziert werden (in-situ).
Um die Implementierung von Visualisierungen, die unserem Paradigma entsprechen, als Plugins für IDEs zu erleichtern, haben wir ein Programmier-Framework namens \textit{CodeSparks} entworfen, implementiert und evaluiert. Nachdem wir die Designziele und die Architektur des Frameworks vorgestellt haben, demonstrieren wir seine Vielseitigkeit anhand von insgesamt vierzehn Plugins, die von verschiedenen Entwicklerinnen und Entwicklern mit dem CodeSparks-Framework realisiert wurden (CodeSparks-Plugins). In Fokusgruppeninterviews haben wir empirisch untersucht, welche Erfahrungen die Entwicklerinnen und Entwickler der CodeSparks-Plugins bei der Arbeit mit dem Framework gemacht haben. Anhand der Plugins, bewussten Designentscheidungen und der Interviewergebnisse diskutieren wir, inwieweit wir unsere Designziele erreicht haben. Wir fanden heraus, dass das Framework weitgehend unabhängig von der Zielprogrammiersprache ist und dass es die Entwicklung von Plugins für ein breites Spektrum von Quellcode-bezogenen Programmieraufgaben unterstützt, während die meisten Details der zugrunde liegenden Plugin-Entwicklungs-API verborgen bleiben.
Darüber hinaus haben wir unser Visualisierungsparadigma auf Thread-bezogene Laufzeitdaten von nebenläufigen Programmen angewandt, um das Bewusstsein von Quellcode zu fördern, der nebenläufig oder parallel ausgeführt wird. Infolgedessen haben wir zwei In-Situ-Thread-Visualisierungen entwickelt und gestaltet, namentlich ThreadRadar und ThreadFork, wobei letztere auf der ersteren aufbaut. Beide Thread-Visualisierungen basieren auf einem Debugging-Ansatz, der statistisches Profiling, Thread-sensitive Laufzeitmetriken, Clustering von Threads auf der Grundlage dieser Metriken und schließlich interaktive Glyphen-basierte In-situ Visualisierungen kombiniert. Um Probleme mit der Skalierbarkeit des ThreadRadars in Bezug auf den Platzbedarf und die Anzahl der darstellbaren Thread-Cluster zu lösen, haben wir eine überarbeitete Thread-Visualisierung entwickelt. Bei dieser Überarbeitung ging es auch um die Frage, wie viele Thread-Cluster k überhaupt berechnet werden sollten. Zu diesem Zweck haben wir Experimente mit dem Clustering von Threads für Artefakte aus einem Korpus von nebenläufigen Java-Programmen, welcher reale Java-Anwendungen und Nebenläufigkeitsfehler enthält, durchgeführt. Wir fanden heraus, dass das maximale k einerseits und das optimale k gemäß vier Cluster-Validierungsindizes andererseits selten drei überschreitet. Gelegentlich sind jedoch Thread-Cluster mit k > 3 verfügbar und auch optimal. Daher überarbeiteten wir sowohl die Clustering-Strategie als auch die Visualisierung als Teil unseres Debugging-Ansatzes, was zur ThreadFork-Visualisierung führte. Beide In-Situ Thread Visualisierungen, einschließlich ihrer zusätzlichen Funktionalitäten, die die Exploration der Thread-Daten unterstützen, sind in einem Werkzeug namens CodeSparks-JPT implementiert, d.h. als CodeSparks-Plugin für IntelliJ IDEA.
Mit verschiedenen empirischen Studien, darunter anekdotische Nutzungsszenarien, ein Usability-Test, Webumfragen, praktische Anwendung des Werkzeugs, Fragebögen und Interviews, haben wir Qualitätsaspekte der Thread-Visualisierungen und ihrer entsprechenden Werkzeuge untersucht. Erstens haben wir in einer Demonstrationsstudie die Nützlichkeit der ThreadRadar-Visualisierung bei der Untersuchung und Behebung von Nebenläufigkeitsfehlern und einem Performance-Problem aufgezeigt. Dies wurde durch einen anschließenden Usability-Test und ein Interview bestätigt, die auch formatives Feedback lieferten. Zweitens haben wir die Interpretierbarkeit und Lesbarkeit der ThreadFork-Glyphen sowie die Effektivität der ThreadFork-Visualisierung durch anonyme Webumfragen untersucht. Während wir festgestellt haben, dass die ThreadFork-Glyphen korrekt interpretiert werden und lesbar sind, bleibt es unbewiesen, dass die ThreadFork-Visualisierung das Verstehen des dynamischen Verhaltens von Threads, die nebenläufig Teile des Quellcodes ausführen, effektiv erleichtert. Darüber hinaus wird die Usability von CodeSparks-JPT insgesamt als "OK, aber nicht akzeptabel" empfunden, da das Werkzeug Probleme mit seiner Erlernbarkeit und Einprägsamkeit hat. Alle anderen untersuchten Usability-Aspekte von CodeSparks-JPT werden jedoch als "überdurchschnittlich" oder "gut" empfunden.
Unsere Arbeit unterstützt Forschende und Fachpersonen im Bereich Software-Engineering bei der flexiblen und schnellen Entwicklung neuartiger Glyphen-basierter Visualisierungen, die in den Quellcode-Editor eingebettet sind. Darüber hinaus stellen wir In-situ Thread Visualisierungen bereit, die das Bewusstsein für die nebenläufige oder parallele Ausführung von Quellcode fördern. Diese In-situ Thread Visualisierungen können beispielsweise angepasst, erweitert und zur Analyse anderer Anwendungsfälle oder zur Replikation der Ergebnisse verwendet werden. Durch empirischen Studien haben wir die Gestaltung der In-situ Thread Visualisierungen schrittweise durch datengetriebene Entscheidungen geformt und verschiedene Qualitätsaspekte der In-Situ Thread Visualisierungen und der entsprechenden Werkzeuge auf ihre Nützlichkeit für das Verstehen und das Debuggen von nebenläufigen Programmen untersucht
Digital leadership in meta-organizations? Emergence of a renewed relevance of leadership in the context of digitization
Full text linkIn the face of uncontrollable complexity, the concept of a rational design of the organization is being replaced by the notion of an open future that is inherently unpredictable and unplanable. In rapidly changing environments, organizations and leaders are confronted with a constant stream of irritations and unexpected developments, that require ongoing attention. This prompts the question of whether the conceptualization of digital transformation as a paradigm shift also implies the need for new forms of leadership. The article analyzes the discourse on digital leadership and assesses the extent to which this concept relativizes leadership in the context of the evolution of leadership theory, which is characterized by a persistent process of modification and relativization of preceding concepts. Leadership concepts are not only responsive to general needs, but also vary according to specific contexts, such as non-profit leadership or leadership in social welfare organizations and meta-organizations. Results of a discourse analysis, which underscore the significance of adopting a complexity theory perspective on digital leadership, will therefore be contrasted with the initial findings of an empirical study on digitization in such meta-organizations. This allows for a discussion of the general findings on the revitalization of leadership, which will serve as a paradigmatic example of the previously developed context. The article concludes with implications for further theory development with the aim of making a specific contribution to organization-sensitive digitization research. The findings of the empirical study indicate the significance of employing informal structures and a heightened emphasis on subjectivity within meta-organizations, as opposed to the formal structures of organizations. The concept of digital leadership does not signify the obsolescence of traditional leadership; rather, it can be conceptualized as an advanced form of unheroic leadership within the context of external and internal complexity
« On a quand même encore le droit de dire ça, non ? » : Comment aborder les théories du complot et les propos extrémistes à l’école et en classe
Get PDFUn débat politique passionnant a lieu en classe. La plupart de vos élèves sont attentif·ve·s, intéressé·e·s et engagé·e·s. Tout se passe à merveille, jusqu’à ce qu’un·e élève lance – délibérément ou sans réfléchir – des propos extrémistes ou complotistes. Comment réagir
Des sentiments puissants : Aborder avec les enfants la question des émotions dans les conflits
Full text linkLes émotions sont le reflet de nos besoins personnels. Dans les discussions sur les conflits ou dans la médiation, en particulier, il est important de ne pas se concentrer uniquement sur le moment où un conflit est survenu, mais de déceler aussi les besoins et les émotions qui ont eu un impact sur nos actions, nos réflexions et notre ressenti. Le matériel que nous allons vous présenter vous permettra de découvrir comment aborder, en tant qu’enseignant·e, les émotions et les disputes avec des enfants dans l’enseignement fondamental
Service de conseil externe en gestion de conflits : Entretien avec Lis De Pina, directrice du Service de médiation scolaire au Luxembourg
Full text linkAu Luxembourg, des médiateur·trice·s scolaires externes apportent leur aide quand des conflits surgissent en milieu scolaire. Le Service de médiation scolaire fournit un soutien en cas de risque de décrochage scolaire et de conflits en lien avec l’inclusion et l’intégration d’élèves à besoins éducatifs spécifiques ou issu·e·s de l’immigration. Michèle Schilt s’est entretenue avec la directrice du service, Lis De Pina, sur le travail des médiateur·trice·s scolaires
Jahresbericht 2023 Universtitätsbibliothek Trier
Full text linkBericht über die Ereignisse und Entwicklungen der UB Trier 2023
Politikwissenschaftlicher Jahresrückblick 2024 des Trierer Institut für Demokratie- und Parteienforschung
Full text link
