Software maintenance is a significant phase of a software life-cycle. Once a system is developed the main focus shifts to maintenance to keep the system up to date. A system may be changed for various reasons such as fulfilling customer requirements, fixing bugs or optimizing existing code. Code needs to be studied and understood before any modification is done to it. Understanding code is a time intensive and often complicated part of software maintenance that is supported by documentation and various tools such as profilers, debuggers and source code analysis techniques. However, most of the tools fail to assist in locating the portions of the code that implement the functionality the software developer is focusing. Mining execution traces can help developers identify parts of the source code specific to the functionality of interest and at the same time help them understand the behaviour of the code. We propose a use-driven hybrid framework of static and dynamic analyses to mine and manage execution traces to support software developers in understanding how the system's functionality is implemented through feature analysis. We express a system's use as a set of tests. In our approach, we develop a set of uses that represents how a system is used or how a user uses some specific functionality. Each use set describes a user's interaction with the system. To manage large and complex traces we organize them by system use and segment them by user interface events. The segmented traces are also clustered based on internal and external method types. The clusters are further categorized into groups based on application programming interfaces and active clones. To further support comprehension we propose a taxonomy of metrics which are used to quantify the trace. To validate the framework we built a tool called TrAM that implements trace mining and provides visualization features. It can quantify the trace method information, mine similar code fragments called active clones, cluster methods based on types, categorise them based on groups and quantify their behavioural aspects using a set of metrics. The tool also lets the users visualize the design and implementation of a system using images, filtering, grouping, event and system use, and present them with values calculated using trace, group, clone and method metrics. We also conducted a case study on five different subject systems using the tool to determine the dynamic properties of the source code clones at runtime and answer three research questions using our findings. We compared our tool with trace mining tools and profilers in terms of features, and scenarios. Finally, we evaluated TrAM by conducting a user study on its effectiveness, usability and information management.

This thesis investigates the building of a textual tracing language that operates at the model level to allow trace specification of textually modeled UML constructs. Current tracing approaches focus on manually injecting tracepoints into targeted systems at the source code level. Such approaches are useful in code-centric development styles where the majority of the code is handwritten. However, in the case of Model Driven Development (MDD), where models are utilized to generate some or all of the code, current tracing technology results in low level trace specification and generation of execution traces that are not aware of or linked to the originating model-level constructs. Dynamic analysis hence becomes harder for a modeler adopting an MDD approach. This field, which we call model-oriented tracing, is currently immature, with little pre-existing research. In this thesis, we present a textual model-level tracing language, implemented as part of Umple, that overcomes some of the limitations of existing tracing methods. The language facilitates model-level tracing, in a fashion very similar to code tracing. The language, which we call MOTL (Model-Oriented Tracing Language) allows tracing of UML associations, attributes and state machines. Constraints can be imposed to limit the scope of tracing. As a result of this work, modelers will gain the ability to specify traces of UML constructs at the model level without the need to modify the generated code, and then generate execution traces when the generated system is run. The resulting trace links back to the model constructs. Modelers can choose from among several tracing technologies including basic file or console output, Java logging framework, Log4J and LTTng. This thesis defines the language syntactically and semantically. Model-Driven Development (MDD) and Test-Driven Development (TDD) were followed to implement the language architecture to ensure high quality code generation. MOTL was used in the development in two of Umple subprojects. An empirical evaluation was conducted to evaluate the language’s usability.

Nous proposons une approche semi-automatique pour la rétro-ingénierie des diagrammes de séquence d’UML. Notre approche commence par un ensemble de traces d'exécution qui sont automatiquement alignées pour déterminer le comportement commun du système. Les diagrammes de séquence sont ensuite extraits avec l’aide d’une visualisation interactive, qui permet la navigation dans les traces d'exécution et la production des opérations d'extraction. Nous fournissons une illustration concrète de notre approche avec une étude de cas, et nous montrons en particulier que nos diagrammes de séquence générés sont plus significatifs et plus compacts que ceux qui sont obtenus par les méthodes automatisées. / We propose a semi-automated approach for the reverse engineering of UML sequence diagrams. Our approach starts with a set of execution traces that are automatically aligned to determine the common behavior. Sequence diagrams are then extracted with the help of an interactive visualization, which allows navigating though execution traces and performing extraction operations. We provide a concrete illustration of our approach with a case study, and show in particular that the resulting diagrams are more meaningful and more compact than those extracted by automated approaches.

Nous proposons une approche semi-automatique pour la rétro-ingénierie des diagrammes de séquence d’UML. Notre approche commence par un ensemble de traces d'exécution qui sont automatiquement alignées pour déterminer le comportement commun du système. Les diagrammes de séquence sont ensuite extraits avec l’aide d’une visualisation interactive, qui permet la navigation dans les traces d'exécution et la production des opérations d'extraction. Nous fournissons une illustration concrète de notre approche avec une étude de cas, et nous montrons en particulier que nos diagrammes de séquence générés sont plus significatifs et plus compacts que ceux qui sont obtenus par les méthodes automatisées. / We propose a semi-automated approach for the reverse engineering of UML sequence diagrams. Our approach starts with a set of execution traces that are automatically aligned to determine the common behavior. Sequence diagrams are then extracted with the help of an interactive visualization, which allows navigating though execution traces and performing extraction operations. We provide a concrete illustration of our approach with a case study, and show in particular that the resulting diagrams are more meaningful and more compact than those extracted by automated approaches.

Le marché de l'électronique grand public est dominé par les systèmes embarqués du fait de leur puissance de calcul toujours croissante et des nombreuses fonctionnalités qu'ils proposent.Pour procurer de telles caractéristiques, les architectures des systèmes embarqués sont devenues de plus en plus complexes (pluralité et hétérogénéité des unités de traitements, exécution concurrente des tâches, ...).Cette complexité a fortement influencé leur programmabilité au point où rendre difficile la compréhension de l'exécution d'une application sur ces architectures.L'approche la plus utilisée actuellement pour l'analyse de l'exécution des applications sur les systèmes embarqués est la capture des traces d'exécution (séquences d'événements, tels que les appels systèmes ou les changements de contexte, générés pendant l'exécution des applications).Cette approche est utilisée lors des activités de test, débogage ou de profilage des applications.Toutefois, suivant certains cas d'utilisation, les traces d'exécution générées peuvent devenir très volumineuses, de l'ordre de plusieurs centaines de gigaoctets.C'est le cas des tests d'endurance ou encore des tests de validation, qui consistent à tracer l'exécution d'une application sur un système embarqué pendant de longues périodes, allant de plusieurs heures à plusieurs jours.Les outils et méthodes d'analyse de traces d'exécution actuels ne sont pas conçus pour traiter de telles quantités de données.Nous proposons une approche de réduction du volume de trace enregistrée à travers une analyse à la volée de la trace durant sa capture.Notre approche repose sur les spécificités des applications multimédia, qui sont parmi les plus importantes pour le succès des dispositifs populaires comme les Set-top boxes ou les smartphones.Notre approche a pour but de détecter automatiquement les fragments (périodes) suspectes de l'exécution d'une application afin de n'enregistrer que les parties de la trace correspondant à ces périodes d'activités.L'approche que nous proposons comporte deux étapes : une étape d'apprentissage qui consiste à découvrir les comportements réguliers de l'application à partir de la trace d'exécution, et une étape de détection d'anomalies qui consiste à identifier les comportements déviant des comportements réguliers.Les nombreuses expériences, réalisées sur des données synthétiques et des données réelles, montrent que notre approche permet d'obtenir une réduction du volume de trace enregistrée d'un ordre de grandeur avec d'excellentes performances de détection des comportements suspects. / The consumer electronics market is dominated by embedded systems due to their ever-increasing processing power and the large number of functionnalities they offer.To provide such features, architectures of embedded systems have increased in complexity: they rely on several heterogeneous processing units, and allow concurrent tasks execution.This complexity degrades the programmability of embedded system architectures and makes application execution difficult to understand on such systems.The most used approach for analyzing application execution on embedded systems consists in capturing execution traces (event sequences, such as system call invocations or context switch, generated during application execution).This approach is used in application testing, debugging or profiling.However in some use cases, execution traces generated can be very large, up to several hundreds of gigabytes.For example endurance tests, which are tests consisting in tracing execution of an application on an embedded system during long periods, from several hours to several days.Current tools and methods for analyzing execution traces are not designed to handle such amounts of data.We propose an approach for monitoring an application execution by analyzing traces on the fly in order to reduce the volume of recorded trace.Our approach is based on features of multimedia applications which contribute the most to the success of popular devices such as set-top boxes or smartphones.This approach consists in identifying automatically the suspicious periods of an application execution in order to record only the parts of traces which correspond to these periods.The proposed approach consists of two steps: a learning step which discovers regular behaviors of an application from its execution trace, and an anomaly detection step which identifies behaviors deviating from the regular ones.The many experiments, performed on synthetic and real-life datasets, show that our approach reduces the trace size by an order of magnitude while maintaining a good performance in detecting suspicious behaviors.

Les techniques dynamiques de vérification et validation (V&V) de modèles sont nécessaires pour assurer la qualité des modèles exécutables. La plupart de ces techniques reposent sur la concept de trace d'exécution, une séquence contenant un ensemble d'informations sur une exécution. Par conséquent, pour permettre la V&V dynamique de modèles exécutables conformes à n'importe quel langage de modélisation dédié exécutable (LMDx), il est crucial de fournir des outils pour construire et manipuler toutes sortes de traces d'exécution. À cet effet, nous proposons d'abord une approche de clonage efficace de modèles afin de pouvoir construire des traces d'exécution génériques à base de clones. À l'aide d'un générateur aléatoire de métamodèles, nous montrons que cette approche passe à l'échelle avec seulement un léger surcoût lors de la manipulation de clones. Nous présentons ensuite une approche générative pour définir des métamodèles dédiés et multidimensionnels pour représenter des traces d'exécution, qui consiste à créer la structure de données spécifique aux traces d'exécution d'un LMDx donné. Ainsi, les traces d'exécution de modèles conformes à ce LMDx peuvent être capturées et manipulées efficacement de manière dédiée et à l'aide de différentes dimensions. Nous appliquons cette approche à deux techniques de V&V dynamiques existantes, à savoir la différentiation sémantique et le débogage omniscient. Nous montrons qu'un tel métamodèle de traces d'exécution généré fournit une bonne facilité d'usage et un bon passage à l'échelle pour la V&V dynamique au plus tôt pour n'importe quel LMDx. Nous avons intégré notre travail au sein du GEMOC Studio, un environnement de définition de langages et de modélisation issu de l'initiative internationale du même nom. / Dynamic verification and validation (V&V) techniques are required to ensure the correctness of executable models. Most of these techniques rely on the concept of execution trace, which is a sequence containing information about an execution. Therefore, to enable dynamic V&V of executable models conforming to any executable domain-specific modeling language (xDSML), it is crucial to provide efficient facilities to construct and manipulate all kinds of execution traces. To that effect, we first propose a scalable model cloning approach to conveniently construct generic execution traces using model clones. Using a random metamodel generator, we show that this approach is scalable in memory with little manipulation overhead. We then present a generative approach to define multidimensional and domain-specific execution trace metamodels, which consists in creating the execution trace data structure specific to an xDSML. Thereby, execution traces of models conforming to this xDSML can be efficiently captured and manipulated in a domain-specific way. We apply this approach to two existing dynamic V&V techniques, namely semantic differencing and omniscient debugging. We show that such a generated execution trace metamodel provides good usability and scalability for dynamic early V&V support for any xDSML. Our work have been implemented and integrated within the GEMOC Studio, which is a language and modeling workbench resulting from the eponym international initiative.

Comprendre le comportement de haut niveau des programmes est nécessaire pour effectuer différentes tâches dans le développement et la maintenance des logiciels. Pour cela, on utilise régulièrement des traces d’exécution du système, enregistrées pendant des scénarios d’utilisation typiques. Cependant, une trace standard peut contenir un volume très important d’évènements, ce qui rend son interprétation difficile. Nous proposons d’utiliser une métaphore visuelle et un ensemble de filtres et d’outils pour assister le développeur dans la compréhension du comportement de haut niveau d’un logiciel. Notre environnement de visualisation interactive est basé sur une métaphore de traces lumineuses animées pour rejouer la trace d’exécution. Cette animation est accompagnée avec un ensemble de filtres et d’outils pour manipuler et réduire à l’essentiel les informations affichées. Nous démontrons l’utilité de notre approche au moyen de deux études de cas qui présentent des traces enregistrées sur un jeu d’échecs et un logiciel d’édition de diagrammes UML. / Understanding high-level behavior of programs is necessary to perform various tasks in software development and maintenance. This is usually done by analyzing execution traces extracted from typical scenarios. However, average execution traces consist of huge volumes of events and information that make it difficult to develop good insights from these traces. We propose to exploit a visualization metaphor and a set of filters and tools to assist developers grasping high-level behaviors of programs. Our interactive visualization is based on a metaphor of traces of light as part of an animation to explore execution scenarios. The animation is augmented with a set of structural and temporal filters to reduce the volume of information displayed. We showcase our visualization environment on two case studies featuring programs of a chess game and a UML diagram editor.