Two or more incompatible versions of a library are sometimes needed in one software artifact, which is so-called dependency hell. One likely faces the problem if he or she uses two or more libraries that depend on the same library. We propose a context-oriented programming language VL as a solution to the problem. It treats versions as contexts and allows multiple versions of definitions such as classes, methods, and functions coexist in a binary file, which gets rid of requiring two or more incompatible binaries. We show in this paper a sketch of VL by using an example situation of incompatibility among versions that is simplified from the one found in the ASM bytecode engineering library. We also show a core calculus of VL to discuss type safety in the case where definitions are available only in specific versions, which is a common and important nature of versioned programs.

Yudai Tanabe

Tokyo Institute of Technology

Japan

Tomoyuki Aotani

Tokyo Institute of Technology

Japan

Hidehiko Masuhara

Tokyo Institute of Technology

Japan

Context-oriented programming proposes a language-level technique to enable dynamic adaptations by the activation of contextual situations sensed from the environment. Context activation triggers the dynamic composition of behavioral adaptations with the running system. Currently, theres is a close relationship between contexts and the environment, narrowing the application of these techniques to systems that react to sensed data. This can also be a difficulty for system testing, where sensor data is not available, or in systems requiring explicit activation from users. Such systems require a uniform way to express the activation of different contexts based on a set of their defining properties. We posit a declarative language, CQL, that unifies different mechanisms to activate contexts. CQL can be incorporated as a domain-specific language to any context-oriented language. We validated the appropriateness of the language in two directions. First, we use the expressiveness of the language to realize different mechanisms for context activation in a uniform model. All existing mechanism in the literature are effectively implemented for CQL. Second, we use CQL to automate the explicit activation of many contexts, as is the case of a context-driven multi-versioning application. Both validation cases use Context Traits as a representative context-oriented programming language for their implementation.

Nicolás Cardozo

Universidad de los Andes

Colombia

I have been working on adaptive systems for the last couple of years. Currently I am approaching adaptive systems from programming language perspective, working on development (programming language design), verification (partial, and incremental techniques), and application (smart environments, CPS, and IoT) of these systems.

This paper presents the design of a simple context-oriented programming extension to Emfrp, a purely functional reactive programming language for resource-constrained embedded systems. Emfrp provides the ability to describe various sorts of embedded systems in clean and straightforward ways. However, because of the static nature of the language, it does not have suitable capabilities to modularize adaptive behaviors. The proposed extension provides a simple layer mechanism with explicitly specified activation conditions. Also, a feature to describe events along with the layer activation is introduced. As a result, the extension can eliminate various cross-cutting code that often appear in plain Emfrp programs.

Link to Publication: http://www.psg.c.titech.ac.jp/posts/2018-07-16-COP2018.html

Takuo Watanabe

Tokyo Institute of Technology

Japan

Takuo Watanabe is Professor in the Department of Computer Science at Tokyo Institute of Technology. He received his Ph. D. from the Department of Information Science at the Tokyo Institute of Technology in 1991. He is working in the area of programming languages, programming methodologies, and formal methods. His research focuses on understanding the nature of reflective behaviors in concurrent systems, inventing new applications of computational reflection, and developing new abstraction mechanisms and programming models for safe/secure systems.

Smart contracts formalize and automate interactions among and between individuals and systems in an executable way. They are analogous to objects in object-oriented programming, but their state is replicated across numerous participants in a network and messages sent to the object are relayed to all network participants, allowing everyone to keep its replica up-to-date. Originally introduced in the mid-1990s, their recent surge in popularity is linked to a rising interest in blockchain-backed, general-purpose smart contract platforms.

Manging contract-specific state and behavior associated with the interacting parties and shared objects is a modularity challenge in smart contracts. Due to the decentralized deployment and execution model, code of already existing objects cannot be amended. Each smart contract needs to manage object-specific state and behavior itself, often leading to a single monolithic mediator.

We aim at re-instating separation of concerns by allowing programmers to modularly express instance-specific state and behavior within the scope of a so called Activity Context. Activity Contexts are first-class entities that collect these modular adaptations and jointly overlay them over instances that participate in the activity modeled by the smart contract.

We demonstrate the benefits of Activity Contexts by refactoring an exemplary smart contract and discuss their trade-offs compared to traditional object-oriented decomposition and context-oriented layers.

Toni Mattis

Hasso Plattner Institute

Robert Hirschfeld

HPI, University of Potsdam

Germany

Cross-cutting concerns are an inherent property of the implementation of non-trivial software systems. Their study led to the development of advanced modularity constructs, usually supported by meta-level frameworks and programming language constructs, to improve comprehensibility. Because of to their invasive nature, systems need to be refactored or rewritten to take advantage of these constructs. However, practical considerations such as organizational or economical constraints often do not allow for such reengineering efforts, leaving those systems without explicit representations of their cross-cutting concerns.

We propose a lightweight, non-invasive approach to explicate and document cross-cutting, multi-party concerns called Cross-cutting Commentary, or Commentary for short. Our proposal is based on the observation that comments are co-located with the individual semantic units they are about and with that scattered and tangled in the absence of advanced modularity constructs for cross-cutting concerns and the assumption that well-crafted, natural language explanations of system properties (their intents and the mechanisms they provide) largely improve comprehensibility. Commentaries are to help communicate narratives about system properties that involve multiple participants, both co-located in a single module or cross-cutting several of them, and allow for navigating to and between them to explore the implementation artifacts involved.

In this work, we present our first attempt to provide Commentaries in Squeak/Smalltalk. We explain implementation details and discuss several application scenarios considering the documentation of basic mechanisms of this programming and runtime environment.

Robert Hirschfeld

HPI, University of Potsdam

Germany

Patrick Rein

Hasso Plattner Institute

Marcel Taeumel

Hasso Plattner Institute

Germany

Tobias Dürschmid

Hasso Plattner Institute

Germany

As part of our ongoing research on context-oriented software technology, we present a feature-oriented programming approach to context-oriented programming. Behavioural variations are implemented as fine-grained features that can be installed and activated dynamically, upon changing contexts. Given the highly dynamic nature of such a programming approach, and to cope with the complexity of many behavioural variations, that can depend on many varying contexts, developers could also benefit from visual inspection tools to analyse what contexts and features are currently active, in which order they have been activated, and what code they adapt. We are developing a prototype of such a visualisation tool, and are conducting user studies to assess the usability and potential of that tool.

Benoît Duhoux

Université catholique de Louvain, Belgium

Belgium

Kim Mens

Université Catholique de Louvain, Belgium

Belgium

Bruno Dumas