Toni Mattis

Columnar objects: improving the performance of analytical applications

Growing volumes of data increase the demand to use it in analytical applications to make informed decisions. Unfortunately, object-oriented runtimes experience performance problems when dealing with large data volumes. Similar problems have been addressed by column-oriented in-memory databases, whose memory layout is tailored to analytical workloads. As a result, data storage and processing are often delegated to such a database. However, the more domain logic is moved to this separate system, the more benefits of object-orientation are lost. We propose modifications to dynamic object-oriented runtimes to store collections of objects in a column-oriented memory layout and leverage a jit to take advantage of the adjusted layout by mapping object traversal to array operations. We implemented our concept in PyPy, a Python interpreter equipped with a tracing jit. Finally, we show that analytical algorithms, expressed through object-oriented code, are up to three times faster due to our optimizations, without substantially impairing the paradigm. Hopefully, extending these concepts will mitigate some problems originating from the paradigm mismatch between object-oriented runtimes and databases.

Living in your programming environment: towards an environment for exploratory adaptations of productivity tools

Knowledge workers can benefit from adaptable software tools as they often have individual work flows adapted to their circumstances. To react directly to new use cases, users should be able to adapt the tools while using them and get immediate feedback on their adaptation. Exploratory programming environments already support such an exploratory style for developing software, however they are not used for everyday productivity tasks. In this paper, we describe our first steps towards an exploratory programming environment suitable for everyday productivity tasks. From our experiences of using the environment for eight months, we distilled features which improve adaptability and productivity of such environments.

Edit Transactions: Dynamically Scoped Change Sets for Controlled Updates in Live Programming

Live programming environments enable programmers to edit a running program and obtain immediate feedback on each individual change. The liveness quality is valued by programmers to help work in small steps and continuously add or correct small functionality while maintaining the impression of a direct connection between each edit and its manifestation at run-time. Such immediacy may conflict with the desire to perform a combined set of intermediate steps, such as a refactoring, without immediately taking effect after each individual edit. This becomes important when an incomplete sequence of small-scale changes can easily break the running program. State-of-the-art solutions focus on retroactive recovery mechanisms, such as debugging or version control. In contrast, we propose a proactive approach: Multiple individual changes to the program are collected in an Edit Transaction, which can be made effective if deemed complete. Upon activation, the combined steps become visible together. Edit Transactions are capable of dynamic scoping, allowing a set of changes to be tested in isolation before being extended to the running application. This enables a live programming workflow with full control over change granularity, immediate feedback on tests, delayed effect on the running application, and coarse-grained undos. We present an implementation of Edit Transactions along with Edit-Transaction-aware tools in Squeak/Smalltalk. We asses this implementation by conducting a case study with and without the new tool support, comparing programming activities, errors, and detours for implementing new functionality in a running simulation. We conclude that workflows using Edit Transactions have the potential to increase confidence in a change, reduce potential for run-time errors, and eventually make live programming more predictable and engaging.

Do Java programmers write better Python? Studying off-language code quality on GitHub

There are style guides and best practices for many programming languages. Their goal is to promote uniformity and readability of code, consequentially reducing the chance of errors. While programmers who are frequently using the same programming language tend to internalize most of its best practices eventually, little is known about what happens when they casually switch languages and write code in a less familiar language. Insights into the factors that lead to coding convention violations could help to improve tutorials for programmers switching languages, make teachers aware of mistakes they might expect depending on what language students have been using before, or influence the order in which programming languages are taught. To approach this question, we make use of a large-scale data set representing a major part of the open source development activity happening on GitHub. In this data set, we search for Java and C++ programmers that occasionally program Python and study their Python code quality using a lint tool. Comparing their defect rates to those from Python programmers reveals significant effects in both directions: We observe that some of Pythons best practices have more widespread adoption among Java and C++ programmers than Python experts. At the same time, python-specific coding conventions, especially indentation, scoping, and the use of semicolons, are violated more frequently. We conclude that programming off-language is not generally associated with better or worse code quality, but individual coding conventions are violated more or less frequently depending on whether they are more universal or language-specific. We intend to motivate a discussion and more research on what causes these effects, how we can mitigate or use them for good, and which related effects can be studied using the presented data set.

Mining concepts from code using community detection in co-occurrence graphs

Software modularity is a quality that determines how fluently individual parts (modules) of a system can vary and be understood if taken by themselves. However, modularity tends to degrade during program evolution – old concepts may get entangled with code introduced into their modules, while new concepts can be scattered over many existing modules. In this work, we propose to infer high-level concepts and relations between them independently from the current module decomposition by exploiting the vocabulary used by programmers. Our approach uses an extensible graph-based vocabulary representation in which we detect latent communities representing our concepts. Inferred concepts can be used to support program comprehension, track architectural drift over time, and provide recommendations for related code or refactorings.

Towards concept-aware programming environments for guiding software modularity

To design and implement a program, programmers choose analogies and metaphors to explain and understand programmatic concepts. In source code, they manifest themselves as a particular choice of names. During program comprehension, reading such names is an important starting point to understand the meaning of modules and guide the exploration process. On the one hand, understanding a program in depth by looking for names that suggest a particular analogy can be a time-consuming process. On the other hand, a lack of awareness which concepts are present and which analogies have been chosen can lead to modularity issues, such as redundancy and architectural drift if concepts are misaligned with respect to the current module decomposition. In this work-in-progress paper, we propose to integrate first-class concepts into the programming environment. We assign meaning to names by labeling them with a color corresponding to the metaphor or analogy this name was derived from. We hypothesize that aggregating labels upwards along the module hierarchy helps to understand how concepts are distributed across the program, collecting names belonging to a specific concept helps programmers to recognize which metaphor has been chosen, and presenting relations between concepts can summarize complex interactions between program parts. We argue that continuous feedback and awareness of how names are grouped into concepts and where they are located can help preventing modularity issues and ease program comprehension. As a first step towards an implementation, we define criteria that help to detect names belonging to the same concept. We then investigate how techniques from natural language processing can be re-used and modified to compute an initial concept allocation with respect to these criteria. Eventually, we show design sketches how we plan to arrange and present concepts to programmers through tools, and what kind of information they can provide to help programmers make informed implementation decisions.

Concept-aware Live Programming: Integrating Topic Models for Program Comprehension into Live Programming Environments

1 MOTIVATION Live programing environments, such as Smalltalk, are valued for allowing program changes at run-time while the full execution state is accessible for inspection [12]. The resulting immediacy of feedback motivates continuous and ne-grained change, exploration, and checking of hypotheses the programmer might have generated by recognizing familiar names and structures. However, liveness alone does not guarantee a high-level understanding of the system at hand. Programmers might be oblivious to the original mental model from which terminology and architecture were drawn [3, 8]. This promotes inconsistent naming, missing relevant dependencies during a change, duplicating functionality, or failure to nd a variation point to add a new requirement. A recent approach to allocate concepts to program parts are latent topic models, which identify concept-speci c terminology chosen by programmers. In the context of this work, we extend topic modeling to handle some of the information needs in a live programming environment. We hypothesize that machine learning and live programming can jointly contribute to program comprehension at the level of static code, run-time behavior, and state.