Bastian Steinert

An open implementation for context-oriented layer composition in ContextJS

Context-oriented programming (COP) provides dedicated support for defining and composing variations to a basic program behavior. A variation, which is defined within a layer, can be de-/activated for the dynamic extent of a code block. While this mechanism allows for control flow-specific scoping, expressing behavior adaptations can demand alternative scopes. For instance, adaptations can depend on dynamic object structure rather than control flow. We present scenarios for behavior adaptation and identify the need for new scoping mechanisms. The increasing number of scoping mechanisms calls for new language abstractions representing them. We suggest to open the implementation of scoping mechanisms so that developers can extend the COP language core according to their specific needs. Our open implementation moves layer composition into objects to be affected and with that closer to the method dispatch to be changed. We discuss the implementation of established COP scoping mechanisms using our approach and present new scoping mechanisms developed for our enhancements to Lively Kernel.

Immediacy through Interactivity: Online Analysis of Run-time Behavior

Visualizations of actual run-time data support the comprehension of programs, like examples support the explanation of abstract concepts and principles. Unfortunately, the required run-time analysis is often associated with an inconvenient overhead that renders current tools impractical for frequent use. We propose an interactive approach to collect and present run-time data. An initial shallow analysis provides for immediate access to visualizations of run-time information. As users explore this information, it is incrementally refined on-demand. We present an implementation that realizes our proposed approach and enables developers to instantly explore run-time behavior of selected code entities. We evaluate our interactive approach by measuring time and memory overhead in the context of ten different-sized projects. Our empirical results show that run-time data for an initial overview can be collected in less than 300 milliseconds for 95% of cases.

Interleaving of Modification and Use in Data-driven Tool Development

Programmers working in a Unix-like environment can easily build custom tools by configuring and combining small filter programs in shell scripts. When leaving such a text-based world and entering one that is graphics-based, however, tool building is more difficult because graphical tools are typically not prepared to be easily re-programmed by their users. We propose a data-driven perspective on graphical tools that uses concise scripts as glue between data and views but also as means to express missing data transformations and view items. Given this, we built a framework in Squeak/Smalltalk that promotes low-effort tool construction; it works well for basic programming tools, such as code editors and debuggers, but also for other domains, such as developer chats and issue browsers. We think that this perspective on graphical tools can inspire the creation of new trade-offs in modularity for both data-providing projects and interactive views.

CoExist: overcoming aversion to change

Programmers make many changes to the program to eventually find a good solution for a given task. In this course of change, every intermediate development state can of value, when, for example, a promising ideas suddenly turn out inappropriate or the interplay of objects turns out more complex than initially expected before making changes. Programmers would benefit from tool support that provides immediate access to source code and run-time of previous development states of interest. We present IDE extensions, implemented for Squeak/Smalltalk, to preserve, retrieve, and work with this information. With such tool support, programmers can work without worries because they can rely on tools that help them with whatever their explorations will reveal. They no longer have to follow certain best practices only to avoid undesired consequences of hanging code.

Continuous Selective Testing

A manual and explicit activity, the frequent selection and execution of tests requires considerable discipline. Our approach automatically derives a subset of tests based on actual modifications to the code base at hand, then continuously executes them transparently in the background, and so supports developers in instantly assessing the effect of their coding activities with respect to the overall set of unit tests to be passed. We apply techniques of selective regression testing, mainly relying on dynamic analysis. By taking advantage of the internal program representation available in IDEs, we do not need to rely on expensive comparisons of different program versions to detect modified code entities.

Agile Software Development in Virtual Collaboration Environments

Agile processes are gaining popularity in the software engineering community. We investigate how selected design practices and the mind-set they are based on can be integrated into Agile software development processes to make them even stronger. In a first step, we compared Agile methodologies with interaction and product design methodologies and discovered that both fields have much in common with respect to their underlying principles and values. Based on our findings and by applying both methodologies, we improved collaboration support for geographically-dispersed software development teams. We designed and implemented ProjectTalk and CodeTalk as part of our XP-Forums platform. Independently of their geographical location, team members can create and maintain user stories with ProjectTalk. CodeTalk enables team members to efficiently communicate their concerns regarding development artifacts in an informal manner.

ContextLua: dynamic behavioral variations in computer games

Behavioral variations are central to modern computer games as they are making the gameplay a more interesting user experience. However, these variations significantly add to the implementation complexity. We discuss the domain of computer games with respect to dynamic behavioral variations and argue that context-oriented programming is of special interest for this domain. This motivates our extension to the dynamic scripting language Lua, which is frequently used in the development of computer games. Our newly provided programming constructs allow game developers to use layers for defining and activating variations of the basic gameplay.

How to Compare Performance in Program Design Activities: Towards an Empirical Evaluation of CoExist

We present the design of an empirical experiment to compare programmers’ performance in program design tasks. The experiment is targeted to empirically examine the benefits of CoExist, a set of extensions to programming environments. CoExist supports programmers in dealing with unexpected and undesired consequences of making changes to their code base. Changing source code involves the risk of making errors. For example, a promising idea to simplify the code can suddenly turn out inappropriate, a situation that, if not prepared, requires programmers to manually withdraw recent changes. Traditionally, programmers have to strictly follow a structured and disciplined approach to reduce the costs of making errors. However, this traditional approach requires planning for upcoming but still uncertain changes in advance, which is time-consuming and also error prone. In addition, it requires significant effort to not forget the regular execution of the required activities, in particular in situations full of uncertainty. In contrast to this, CoExist offers dedicated tool support to recover fast and easily from undesired consequences. We believe that the presence of such tools encourages programmers to make source code changes at the moment they think of them, independent of whether or not the implications of such changes are already apparent. The presented experiment design to compare performance in program design tasks will help to examine this hypothesis.

CodeTalk Conversations about Code

Contemporary development environments do not directly and explicitly support developers in having a conversation about the code they write and maintain. This problem is aggravated when geographically dispersed teams need to collaborate on development artifacts. CodeTalk allows developers to have conversations about source code elements. They can mark code sections they are concerned about and annotate them. These annotations provide entry points for an informal discourse about the strengths and weaknesses of these sections and developers can work towards a conclusion on how to proceed on the raised issues. A Squeak/Smalltalk implementation of CodeTalk was evaluated by several small development teams, indicating improvement in the informal assessment of code.

Debugging into Examples

Enhancing and maintaining a complex software system requires detailed understanding of the underlying source code. Gaining this understanding by reading source code is difficult. Since software systems are inherently dynamic, it is complex and time consuming to imagine, for example, the effects of a methods source code at run-time. The inspection of software systems during execution, as encouraged by debugging tools, contributes to source code comprehension. Leveraged by test cases as entry points, we want to make it easy for developers to experience selected execution paths in their code by debugging into examples. We show how links between test cases and application code can be established by means of dynamic analysis while executing regular tests.