Multiverse Debugging: Non-deterministic Debugging for Non-deterministic Programs

Many of today's software systems are parallel or concurrent. With the rise of Node.js and more generally event-loop architectures, many systems need to handle concurrency. However, its non-deterministic behavior makes it hard to reproduce bugs. Today's interactive debuggers unfortunately do not support developers in debugging non-deterministic issues. They only allow us to explore a single execution path. Therefore, some bugs may never be reproduced in the debugging session, because the right conditions are not triggered. As a solution, we propose multiverse debugging, a new approach for debugging non-deterministic programs that allows developers to observe all possible execution paths of a parallel program and debug it interactively. We introduce the concepts of multiverse breakpoints and stepping, which can halt a program in different execution paths, i.e. universes. We apply multiverse debugging to AmbientTalk, an actor-based language, resulting in Voyager, a multiverse debugger implemented on top of the AmbientTalk operational semantics. We provide a proof of non-interference, i.e., we prove that observing the behavior of a program by the debugger does not affect the behavior of that program and vice versa. Multiverse debugging establishes the foundation for debugging non-deterministic programs interactively, which we believe can aid the development of parallel and concurrent systems

Taming nondeterminism : programming language abstractions and tools for dealing with nondeterministic programs

Computer programs need to deal with nondeterministic environments. This nondeterminism may arise from many sources, like user input and concurrency for example. If program input were to be deterministic, there would be no need for complex programs. A word processor with deterministic input can simply present the user with their envisioned written document without them having to type it. Nondeterminism caused by concurrency stems from the unknown speed of each thread, the possibility of lost messages and so on. Although it leads to nondeterministic execution, we sometimes need it to fulfill real-world demands such as execution performance and high availability. If a program is nondeterministic, the next state may be one of multiple possibilities. When writing the program, the developer must imagine all possible executions to prevent bugs. Even if there are only two possibilities per program step, there are 2^n possible executions of n steps. This exponential state explosion is what makes working with nondeterminism so difficult. If a failure occurs in one of the myriad of execution traces, it is difficult to find its root cause. Typical debuggers only allow users the debug just one of the possible traces, while the failure may only manifest in very rare execution traces. Both humans and computers cannot deal with state explosion well. Programming languages have nondeterminism introducing constructs to facilitate working in nondeterministic environments. There are constructs for acquiring input, starting concurrent threads and so on. The chosen constructs greatly impact the nondeterminism the programmer has to deal with. In this dissertation we investigate the tree main ways programming systems can work with nondeterminism: embrace it, capture it, and avoid it. First, to embrace nondeterminism we must have the tools to deal with the state explosion it generates. In this dissertation, we present a tool called GraphRedex, which allows exploring the state space graph of nondeterministic programs. Our tool contributes a novel exploration technique for dealing with state explosion: interactive exploration. We allow developers to choose what path in the state space graph they want to follow. This helps developers see the wood for the trees when visualizing all possible execution paths of a program. We conducted a user study to confirm GraphRedex is user friendly and helps uncover bugs. Additionally, we used it to find errors in published research. A second option is to capture the nondeterminism. When something goes wrong in a program’s execution, it is often difficult to determine the exact conditions that triggered a bug. By keeping track of the nondeterministic choices the program makes during its execution, we can replay them, even backwards. If the program failed, stepping backwards can help find the bug that caused the failure. We have implemented such a backwards stepping functionality for a platform that is notoriously difficult to debug or even write programs for: microcontrollers. To do this, we created a WebAssembly virtual machine (VM) for these devices. Our VM, WARDuino allows programmers to use higher level languages to program microcontrollers. A language interoperability layer ensures that device peripherals are safely accessible. While higher level languages alone already prevent bugs, WARDuino additionally allows debugging applications remotely via a VSCode plugin. We show that our novel event-based out-of-place debugging technique reduces debugging latency and permits backwards stepping. Additionally, we determine that WARDuino is fast enough to implement IoT applications by carrying out micro benchmarks. Third, nondeterminism can be avoided by carefully selecting the provided language constructs. As an example of this approach, this dissertation presents Gaiwan. This is a general-purpose GPU (GPGPU) programming language intended for processing time series data. The language is based on a novel size-polymorphic type system we designed and implemented Additionally, Gaiwan only features race condition free constructs. By using our language, non-expert GPGPU users avoid two sources of nondeterminism: the nondeterministic size of the input, and the nondeterminism arising from data races on these extremely parallel devices. Gaiwan’s type system allows developers to use affine functions in one variable to declare the effect parts of their program have on data buffers. From this, our type system derives a set of constraints to which the input should adhere for the program to work. Inputs that do not satisfy these constraints will be rejected. Gaiwan prevents data races by only providing deterministic data race free language constructs. We provide the standard correctness proofs for our type system. Although our proof-of-concept evaluator is not yet fully optimized, we also implement a bitonic sorting algorithm in it and demonstrate that it only has a 25% overhead compared to a handwritten OpenCL implementation from Intel

GraphRedex : look at your research

A significant aspect of designing new programming languages is to define their operational semantics. Working with a pen and paper version of such a semantics is notoriously difficult. For this reason, tools for computer aided semantics engineering were created. Many of these tools allow programmers to execute their language's operational semantics. An executable semantics makes it easier to verify whether the execution of a program leads to the desired result. When a program exhibits unexpected behavior, the programmer can consult the reduction graph to see what went wrong. Unfortunately, visualization of these graphs is currently not well‐supported by most tools. Consequently, the comprehension of errors remains challenging. In this article, we present GraphRedex an open‐source tool that empowers language designers to interactively explore their reduction graphs, offering three main benefits. First, a global exploration mode allows users to obtain a bird's‐eye overview of the reduction graph and learn its high level workings. Second, a local exploration mode lets the programmer closely interact with the individual reduction rules. Third, our query interface allows the programmer to filter out and highlight specific regions of the reduction graph. We evaluated our tool by carrying out a user study showing that participants comprehend programs on average twice as fast while being able to answer questions more accurately. Finally, we demonstrate how GraphRedex helps to understand the semantics of two published works. Exploration of the semantics with GraphRedex unveiled an issue in one of the implementations of these works, which the author confirmed

unipept/unipept: 5.1.1

<p>This release of the Unipept Web application fixes a few bugs and inconsistenties that are the result from the big dependency upgrade that we performed for v5.1 of Unipept.</p> <p><strong>Bug fixes:</strong></p> <ul> <li>Fixed the styling and inner workings of the multi dataset heatmap (#1559)</li> <li>Fixed clicking on an app in the navigation bar did not reset the current app (#1559, #1557)</li> <li>Set a maximum width for the content of the pages (#1559)</li> <li>Fixed wrong GitHub repositories where used for news pages (#1559)</li> <li>Fixed styling of the cog icon on the EC-numbers and InterPro-entries summary pages (#1559)</li> <li>Updated parsing of changelogs for product releases such that it works with MarkDown (#1559)</li> <li>Fixed styling of links in peptide summary of TPA tool (#1559)</li> <li>Fixed inter-assay heatmap in MPA tool (#1558)</li> </ul&gt

unipept/unipept: 5.1.2

<p>Release 5.1.2 of the Unipept Web application fixes some textual inconsistencies that were present in the application.</p> <p><strong>Bug fixes:</strong></p> <ul> <li>Renamed "test" to "Feature type" in the heatmap wizard (https://github.com/unipept/unipept-web-components/pull/226)</li> <li>Capitalise "pride" in the dataset creation card (#1562)</li> <li>Rename "Equate I and L?" to "Equate I and L" (#1562)</li> </ul&gt

Unipept 4.0 : functional analysis of metaproteome data

Unipept (https://unipept.ugent.be) is a web application for metaproteome data analysis, with an initial focus on tryptic-peptide-based biodiversity analysis of MS/MS samples. Because the true potential of metaproteomics lies in gaining insight into the expressed functions of complex environmental samples, the 4.0 release of Unipept introduces complementary functional analysis based on GO terms and EC numbers. Integration of this new functional analysis with the existing biodiversity analysis is an important asset of the extended pipeline. As a proof of concept, a human faecal metaproteome data set from 15 healthy subjects was reanalyzed with Unipept 4.0, yielding fast, detailed, and straightforward characterization of taxon-specific catalytic functions that is shown to be consistent with previous results from a BLAST-based functional analysis of the same data