Effective Segmentation of Large Execution Traces Using Probabilistic and Gaussian Mixture Models

Software maintenance is known to be a costly and time consuming activity. Software engineers need to spend a considerable amount of time in understanding the system before maintaining it. This is due to many reasons including the lack of good documentation and the shift of the original developers of the system to other projects or companies. Dynamic analysis techniques, more particularly trace analysis, are used to alleviate the program comprehension problem by offering software engineers a set of techniques that can help them understand the behavioural aspects of software systems. Execution traces however can be extremely large, which makes them cumbersome for effective analysis. There is a need to develop techniques to help software engineers understand the content of large traces despite their massive size. In this thesis, we present, SumTrace, a novel trace analysis technique. SumTrace takes a trace as input and automatically segments it into smaller and more manageable groups that reflect the execution phases of the traced scenario. The execution phases are summarized to help software engineers understand quickly different parts of the trace without having to analyze its entire content. SumTrace relies on a combination of probabilistic and Gaussian mixture models. We applied SumTrace to the segmentation of large traces, generated from two software systems. The results are very promising. SumTrace is also fast since it only requires only one pass through a trace

Phase Flow Diagram: A New Execution Trace Visualization Technique

Software maintenance tasks are known to be costly and challenging. The main challenge is that software maintenance must understand how the software system works before making any changes to it. This is due to lack of adequate documentation if it exists at all. Program analysis techniques aim to reduce the impact of this problem. In this thesis, we focus on the ones that permit the understanding of the behavioural aspects of software. These techniques operate on execution traces, generated from the system under study. Traces are difficult to work with because of their size. One way to reduce their complexity is to automatically divide their content into meaningful clusters, each representing a particular execution phase. This is known as trace segmentation. Trace segmentation research is relatively new. The focus has been on building robust algorithms that achieve acceptable accuracy. In this thesis, we introduce a new trace visualization technique called Phase Flow Diagram to represent the execution phases and the relationship between them in a visual manner. The diagram has a number of notations that can be used by software engineers to represent a trace as a flow of execution phases instead of mere events. We introduce a supporting tool for the diagram. The new diagram and the tool are validated through a user study that involves several users

Cognitive constraints and island effects

Competence-based theories of island effects play a central role in generative grammar, yet the graded nature of many syntactic islands has never been properly accounted for. Categorical syntactic accounts of island effects have persisted in spite of a wealth of data suggesting that island effects are not categorical in nature and that nonstructural manipulations that leave island structures intact can radically alter judgments of island violations. We argue here, building on work by Paul Deane, Robert Kluender, and others, that processing factors have the potential to account for this otherwise unexplained variation in acceptability judgments. We report the results of self-paced reading experiments and controlled acceptability studies that explore the relationship between processing costs and judgments of acceptability. In each of the three self-paced reading studies, the data indicate that the processing cost of different types of island violations can be significantly reduced to a degree comparable to that of nonisland filler-gap constructions by manipulating a single nonstructural factor. Moreover, this reduction in processing cost is accompanied by significant improvements in acceptability. This evidence favors the hypothesis that island-violating constructions involve numerous processing pressures that aggregate to drive processing difficulty above a threshold, resulting in unacceptability. We examine the implications of these findings for the grammar of filler-gap dependencies

Time to Act: An Agenda for Advancing Adolescent Literacy for College and Career Success

Presents a vision for literacy instruction from fourth through twelfth grade; examines the challenges; outlines the elements of success, including professional development and use of data; and lays out a national agenda for change based on case studies

Computing homomorphic program invariants

Program invariants are properties that are true at a particular program point or points. Program invariants are often undocumented assertions made by a programmer that hold the key to reasoning correctly about a software verification task. Unlike the contemporary research in which program invariants are defined to hold for all control flow paths, we propose \textit{homomorphic program invariants}, which hold with respect to a relevant equivalence class of control flow paths. For a problem-specific task, homomorphic program invariants can form stricter assertions. This work demonstrates that the novelty of computing homomorphic program invariants is both useful and practical. Towards our goal of computing homomorphic program invariants, we deal with the challenge of the astronomical number of paths in programs. Since reasoning about a class of program paths must be efficient in order to scale to real-world programs, we extend prior work to efficiently divide program paths into equivalence classes with respect to control flow events of interest. Our technique reasons about inter-procedural paths, which we then use to determine how to modify a program binary to abort execution at the start of an irrelevant program path. With off-the-shelf components, we employ the state-of-the-art in fuzzing and dynamic invariant detection tools to mine homomorphic program invariants. To aid in the task of identifying likely software anomalies, we develop human-in-the-loop analysis methodologies and a toolbox of human-centric static analysis tools. We present work to perform a statically-informed dynamic analysis to efficiently transition from static analysis to dynamic analysis and leverage the strengths of each approach. To evaluate our approach, we apply our techniques to three case study audits of challenge applications from DARPA\u27s Space/Time Analysis for Cybersecurity (STAC) program. In the final case study, we discover an unintentional vulnerability that causes a denial of service (DoS) in space and time, despite the challenge application having been hardened against static and dynamic analysis techniques

Runtime visualisation of object-oriented software

Software is a complex and invisible entity, yet one which is core to modem life. The development and maintenance of such software includes one staple task, the need to understand the software at the implementation level. This process of program comprehension is difficult and time consuming. Yet, despite its importance, there remains very limited tool support for program comprehension activities. The results of this research show the role that runtime visualisation can play in aiding the comprehension of object-oriented software by highlighting both its static and dynamic structure. Previous work in this area is discussed, both in terms of the representations used and the methods of extracting runtime information. Building on this previous work, this thesis develops new representations of object-oriented software at runtime, which are then implemented in a proof of concept tool. This tool allowed the representations to be investigated on real software systems. The representations are evaluated against two feature-based evaluation frameworks. The evaluation focuses on generic software visualisation criteria, due to the lack of any specific frameworks for visualising dynamic information. The evaluation also includes lessons learnt in the implementation of a prototype visualisation tool. The object-oriented paradigm continues to grow in popularity and provides advantages to program comprehension activities. However, it also brings a number of new challenges to program comprehension due to the discrepancies between its static definition and its runtime structure. Therefore, techniques that highlight both the static definition and the runtime behaviour of object-oriented systems offer benefits to their comprehension. Software visualisation offers an approach to aid program comprehension activities through providing a means to deal with the size and complexity of the software and its invisible nature. This thesis highlights the generic issues that software visualisation faces, before focusing on how the visualisation of runtime information affects these issues. Many of the issues are compounded by the dynamic nature of the information to be visualised and the explosive growth in the volume of information that this dynamism can bring. Wider results of this research have allowed the proposal of the necessary concepts that should be considered in the design and evaluation of runtime visualisations. Software visualisation at runtime is still a relatively unexplored area and there remains many research challenges within it. This thesis aims to act as a first step to addressing these challenges and aims to promote interest and future development within this area

A New Technique for Utility-Class Detection in Object-Oriented Software

Understanding a very large execution trace is not a simple task due to the complexity of typical traces. Detecting and removing utilities is beneficial in that it decreases the size and complexity of the trace and will make the software comprehension process easier. This study concentrates on detecting utility classes from an execution trace of object-oriented software and removing them. To achieve this goal, two novel utility detection class metricsare proposed to determine the extent that a certain class can be counted as a utility class. These detection metrics mainly depend on dynamic coupling analysis to address object-oriented features such as polymorphism and late binding. A case study was conducted to demonstrate the effectiveness of the proposed technique where the results in this case study conform to the results in earlier studies. In addition, the case study demonstrates the practical usefulness of proposed technique which shows that, when 10%, 20% and 30% of total classes are excluded, the final execution trace size is reduced by 41%, 63% and 90% of its original size respectively