With the widespread introduction of computer science as a new school subject, programming is experiencing a strong and promising upswing in primary school education. Programming concepts can be taught in a constructive manner, fostering students' precision and algorithmic problem-solving skills. Simultaneously, this form of learning is also inherently challenging and error-prone. During a year-long study, we collected a trace of all failing Logo programs committed in the \xlogo programming environment. Analyzing this data set allows us to confirm that Logo errors follow the same patterns as many other programming languages. In particular, we shed a light on the following three areas of Logo programming: (i) we determine which programming errors occur and their respective frequency, (ii) we verify previous work confirming that a handful of error classes account for the vast majority of all errors committed, and (iii) we highlight that some errors are rooted in deep misunderstandings of programming concepts rather than mere syntactical flaws. A core tenet, we argue, is that whilst errors cannot be eliminated entirely they offer an opportunity for both researchers and pupils alike.

Well-run datacenter application architectures are heavily instrumented to provide detailed traces of messages and remote invocations. Reconstructing user sessions, call graphs, transaction trees, and other structural information from these messages, a process known as sessionization, is the foundation for a variety of diagnostic, profiling, and monitoring tasks essential to the operation of the datacenter.

We report on the design and implementation of a general framework for interactively explaining the outputs of modern data-parallel computations, including iterative data analytics. To produce explanations, existing works adopt a naive backward tracing approach which runs into known issues; naive backward tracing may identify: (i) too much information that is difficult to process, and (ii) not enough information to reproduce the output, which hinders the logical debugging of the program. The contribution of this work is twofold. First, we provide methods to effectively reduce the size of explanations based on the first occurrence of a record in an iterative computation. Second, we provide a general method for identifying explanations that are sufficient to reproduce the target output in arbitrary computations -- a problem for which no viable solution existed until now. We implement our approach on differential dataflow , a modern high-throughput, low-latency dataflow platform. We add a small (but extensible) set of rules to explain each of its data-parallel operators, and we implement these rules as differential dataflow operators themselves. This choice allows our implementation to inherit the performance characteristics of differential dataflow, and results in a system that efficiently computes and updates explanatory inputs even as the inputs of the reference computation change. We evaluate our system with various analytic tasks on real datasets, and we show that it produces concise explanations in tens of milliseconds, while remaining faster -- up to two orders of magnitude -- than even the best implementations that do not support explanations.