SPLASH Workshops 2017
2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH Workshops 2017)
Powered by
Conference Publishing Consulting

3rd ACM SIGPLAN International Workshop on Programming Experience (PX/17.2), October 22, 2017, Vancouver, BC, Canada

PX/17.2 – Proceedings

Contents - Abstracts - Authors

3rd ACM SIGPLAN International Workshop on Programming Experience (PX/17.2)

Title Page

Message from the Chairs
Imagine a software development task: some sort of requirements and specification including performance goals and perhaps a platform and programming language. A group of developers head into a vast workroom. In that room they design and code—and sometimes they discover they need to explore the domain and the nature of potential solutions.

Open Challenges in Incremental Coverage of Legacy Software Languages
Vadim Zaytsev
(Raincode Labs, Belgium)
Legacy software systems were often written not just in programming languages typically associated with legacy, such as COBOL, JOVIAL and PL/I, but also in decommissioned or deprecated 4GLs. Writing compilers and other migration and renovation tools for such languages is an active business that requires substantial effort but has proven to be a successful strategy for many cases. However, the process of covering such languages (i.e., parsing their close overapproximation and assigning the right assumed semantics to it) is filled with unconventional requirements and limitations: the lack of useful documentation, large scale of codebases, counter-intuitive language engineering principles, buggy reference implementations, fragile workarounds for them, etc.
In this short paper, we motivate the incremental nature of software language engineering when it concerns legacy languages in particular, and outline a few related challenges.

Publisher's Version Article Search
Kanto: A Multi-participant Screen-Sharing System for Etoys, Snap!, and GP
Yoshiki Ohshima, Bert Freudenberg, and Dan Amelang
(Y Combinator Research, Japan; Y Combinator Research, Germany; Viewpoints Research Institute, USA)
This paper demonstrates an implementation strategy for a general real-time remote collaboration framework called Kanto. Kanto is a web-based library that provides screen sharing, voice chat and bi-directional user interaction among participants over the Internet. The generality of Kanto's design makes it straightforward to add its facilities to the programming systems Squeak Etoys, Snap! and GP with little modification to those systems. Because Kanto is web-based, no additional software installation is required on the computers that use it.
Kanto takes advantage of the WebRTC framework, which supports peer-to-peer video, voice and other data transmission. One insight is that if an application uses a single HTML canvas to render all graphics, we can simply stream the contents of the canvas to other hosts to do screen sharing. Luckily, the above-mentioned blocks-based programming languages follow this single-canvas implementation strategy, which is influenced by Smalltalk.
Kanto embodies a particular set of choices within the vast design space of collaboration systems. For example, Kanto maintains its application state by designating one node as the state holder, and streaming just that node's display contents to the other nodes. This simplifies the implementation, but for a remote user introduces a delay between an action and its corresponding display update. In our experience the speed of response is acceptable even at intercontinental distances, but below we discuss alternative designs that would avoid this issue.

Publisher's Version Article Search Info
The Entangled Strands of Time in Software Development
Matthias Hauswirth and Mohammad Reza Azadmanesh
(University of Lugano, Switzerland)
We look at the experience of a software developer as multiple entangled strands of activities. Modern development environments provide means to navigate, or to time-travel, along each of those strands. We describe the different strands and the navigation within each. We then discuss their entanglement and what it means for the developer experience. We end up with a call to action, a set of recommendations to improve the developer experience by explicitly considering these strands and their entanglement.

Publisher's Version Article Search
Living in Your Programming Environment: Towards an Environment for Exploratory Adaptations of Productivity Tools
Patrick Rein, Jens Lincke, Stefan Ramson, Toni Mattis, and Robert Hirschfeld
(HPI, Germany)
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.

Publisher's Version Article Search
Designing a Live Development Experience for Web-Components
Jens Lincke, Patrick Rein, Stefan Ramson, Robert Hirschfeld, Marcel Taeumel, and Tim Felgentreff
(HPI, Germany; Oracle Labs, Germany)
Explorative and live development environments flourish when they can impose restrictions. Forcing a specific programming language or framework, the environment can better enhance the experience of editing code with immediate feedback or direct manipulation. Lively Kernel's user interface (UI) framework Morphic provides such a development experience when working with graphical objects in direct way giving immediate feedback during development. Our new development environment Lively4 achieves a similar development experience, but targeting general HTML elements. Web Components as a new Web standard provide a very powerful abstraction mechanism. Plain HTML elements provide direct building blocks for tools and applications. Unfortunately, Web Components miss proper capabilities to support run-time development. To address this issue, we use object migration to provide immediate feedback when editing UI code. The approach is evaluated by discussing known problems, resulting best practices and future work.

Publisher's Version Article Search
Towards Concept-Aware Programming Environments for Guiding Software Modularity
Toni Mattis, Patrick Rein, Stefan Ramson, Jens Lincke, and Robert Hirschfeld
(HPI, Germany)
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.

Publisher's Version Article Search

proc time: 0.7