Jens Lincke

A comparison of context-oriented programming languages

Context-oriented programming (COP) extensions have been implemented for several languages. Each concrete language design and implementation comes with different variations of the features of the COP paradigm. In this paper, we provide a comparison of eleven COP implementations, discuss their designs, and evaluate their performance.

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.

Lively Wiki a development environment for creating and sharing active web content

Wikis are Web-based collaborative systems designed to help people share information. Wikis have become popular due to their openness which gives users complete control over the organization and the content of wiki pages. Unfortunately existing wiki engines restrict users to enter only passive content, such as text, graphics, and videos and do not allow users to customize wiki pages. Thus, wikis cannot be used to host or author rich dynamic and interactive content. In this paper we present Lively Wiki, a development and collaboration environment based on the Lively Kernel which enables users to create rich and interactive Web pages and applications - without leaving the Web. Lively Wiki combines the wiki metaphor with a direct-manipulation user interface and adds a concept for Web programming as well as programming tool support to create an easy to use, scalable, and extendable Web authoring tool. Moreover, Lively Wiki is self-supporting, i.e. the development tools were used for creating its own implementation thereby giving users the freedom to customize every aspect of the system.

Declarative Layer Composition with the JCop Programming Language

Program behavior that relies on contextual information, such as physical location or network accessibility, is common in todays appli- cations, yet its representation at the source code level is not suciently supported by programming languages. With context-oriented program- ming (COP), context-dependent behavior can be explicitly modularized and dynamically activated. The available COP implementations oer lan- guage constructs that allow to describe context-dependent functionality and to specify for which control flows this functionality should be exe- cuted. Since these language constructs require modifications to the source code, the contemporary approaches limit the use of COP to program parts whose source code is accessible to the developer (the user code). The dy- namic control over context-dependent behavior in frameworks cannot be directly addressed by COP as this would imply changes to the source code. Instead, context-dependent behavior is addressed whenever a control flow from the framework code enters the user code. Context composition must be addressed at any of these control flow entry points, which may lead to a redundant specification of this functionality. As a result, dynamic control over layers emerges as a crosscutting concern that obstructs the separation of concerns. In this article, we discuss crosscutting layer composition in framework- based applications in detail. Moreover, we discuss limitations for the ex- pression of semantic relationships of layers that might lead to code du- plication. We present a framework-based application, a simple action ad- venture game that we implemented using a conventional COP language. Along this example, we show how our JCop language supports the decla- ration of layer composition and expression of layer relationships.

Lively Fabrik A Web-based End-user Programming Environment

Lively Fabrik is a Web-based general-purpose end-user programming environment. Based on the Lively Kernel, Lively Fabrik extends the ideas of the original Fabrik system by empowering end-users to create interactive Web content entirely within their Web browsers. Web applications created with Lively Fabrik typically combine Web sources, data manipulation, and interactive user interface elements. The result can be a Mashup, but due to the powerful underlaying system, any general-purpose application. Connecting components with wires and scripting components is all that is needed to do so.

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.

Scoping changes in self-supporting development environments using context-oriented programming

Interactive development in self-supporting systems like Smalltalk or the Lively Kernel allows for an explorative and direct development workflow. Because of the immediate and direct feedback loops, changes to core behavior can lead to accidentally breaking the programming tools themselves. By separating the tools from the objects they work on, this fatal self referentiality can be avoided, but at the expense of interactive development. In this paper we show how context-oriented programming (COP) can be used to separate tools from the objects under development. Instead of directly modifying meta-structures, changes should go into layers on top of these structures. Since layers can be scoped at run-time, changes do not affect the programming tools. We demonstrate this approach by showing examples of adapting core behavior in our self-supporting development environment Webwerkstatt with Context JS, our COP extension for JavaScript.

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.

Babelsberg/JS

�� � � � � � �� � ��� �� � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � �� � � � � � � � � � � Constraints provide a useful technique for ensuring that desired properties hold in an application. As a result, they have been used in a wide range of applications, including graphical layout, simulation, scheduling, and problem-solving. We describe the design and implementation of an Object Constraint Programming language, an object-oriented language that cleanly integrates constraints with the underlying language in a way that respects encapsulation and standard object-oriented programming techniques, and that runs in browser-based applications. Prior work on Object Constraint Programming languages has relied on modifying the underlying Virtual Machine, but that is not an option for web-based applications, which have become increasingly prominent. In this paper, we present an approach to implementing Object Constraint Programming without Virtual Machine support, along with an implementation as a JavaScript extension. We demonstrate the resulting language, Babelsberg/JS, on a number of applications and provide performance measurements. Programs without constraints in Babelsberg/JS run at the same speed as pure JavaScript versions, while programs that do have constraints can still be run efficiently. Our design and implementation also incorporate incremental re-solving to support interaction, as well as a cooperating solvers architecture that allows multiple solvers to work together to solve more difficult problems.

Efficient Layer Activation in Context JS

Context-oriented programming (COP) describes language extensions for modularizing behavioral or structural variations that are to be composed at run-time. Different COP infrastructures and implementations offer several strategies for scoping, activation, and deactivation of such compositional units. Often, the mechanisms employed cause substantial execution overhead. In this paper we present an optimization technique for ContextJS -- our COP extension to JavaScript -- that can significantly reduce this overhead to run context-aware code efficiently.