title: Grace: the absence of (inessential) difficulty

authors:
Andrew P. Black
Kim B. Bruce
Michael Homer
James Noble

abstract: We are engaged in the design of a small, simple programming language for teaching novices object-oriented programming. This turns out to be far from a small, simple task. We focus on three of the problems that we encountered, and how we believe we have solved them. The problems are (1) gracefully combining object initialization, inheritance, and immutable objects, (2) reconciling apparently irreconcilable views on type-checking, and (3) providing a family of languages, each suitable for students at different levels of mastery, while ensuring conceptual integrity of their designs. In each case our solutions are based on existing research; our contribution is, by design, consolidation rather than innovation.


venue: onward

title: The structure of a programming language revolution

abstract: Engineering often precedes science. Incommensurability is real.


title: Growing a pattern language (for security)

authors:
Munawar Hafiz
Paul Adamczyk
Ralph E. Johnson

abstract: Researchers and practitioners have been successfully documenting software patterns for over two decades. But the next step--building pattern languages--has proven much more difficult. This paper describes an approach for building a large pattern language for security: an approach that can be used to create pattern languages for other software domains. We describe the mechanism of growing this pattern language: how we cataloged the security patterns from books, papers and pattern collections written by all security experts over the last 15 years, how we classified the patterns to help developers find the appropriate ones, and how we identified and described the relationships between patterns in the language. To our best knowledge, this is the largest pattern language in software. But the most significant contribution of this paper is the story behind how the pattern language is grown; it illustrates the steps that can be adapted to create and grow pattern languages for other domains.


title: Cognitive architectures: a way forward for the psychology of programming

authors:
Michael E. Hansen
Andrew Lumsdaine
Robert L. Goldstone

abstract: Programming language and library designers often debate the usability of particular design choices. These choices may impact many developers, yet scientific evidence for them is rarely provided. Cognitive models of program comprehension have existed for over thirty years, but the lack of quantitative (operational) validations for their internal components limits their utility for usability studies. To ease the burden of quantifying these existing models, we recommend using the ACT-R cognitive architecture - a simulation framework for psychological models. In this paper, we review the history of cognitive modeling in the psychology of programming. We provide an overview of the ACT-R cognitive architecture, and show how it could be used to fill in the gaps of an existing, yet incomplete, quantitative model (the Cognitive Complexity Metric). Lastly, we discuss the potential benefits and challenges associated with building a comprehensive cognitive model on top of a cognitive architecture.


title: MOST-flexiPL: modular, statically typed, flexibly extensible programming language

abstract: Even though extensible programming languages have been around for decades, they have not received much attention so far. To obtain a more attractive solution, where extending the language is almost as easy as writing normal programs, extensibility should not be provided as a separate add-on, but rather as the very heart of the language. Furthermore, syntactic flexibility should not only allow to extend, but also to completely change the syntax when desired. MOSTflexiPL follows this approach by allowing users to define new operators, control structures, type constructors, and even declaration forms almost as easily as functions without sacrificing static type safety. This is achieved by encoding all constructs as generalized operators possessing any number of names and operands in an arbitrary order, where users have full control over associativity, precedence, and even scoping rules. Even though the language is still under development, there is a working compiler that translates MOSTflexiPL programs to equivalent C++ code.


title: The dark side of agile software development

authors:
Andrea Janes
Giancarlo Succi

abstract: We believe, that like most innovations, Agile has followed the Gartner Hype Cycle and it has now reached the Trough of Disillusionment, where it is currently stuck. Moreover, we believe this is due to a "guru phenomenon."


title: Software development environments on the web: a research agenda

authors:
Lennart C. L. Kats
Richard G. Vogelij
Karl Trygve Kalleberg
Eelco Visser

abstract: Software is rapidly moving from the desktop to the Web. The Web provides a generic user interface that allows ubiquitous access, instant collaboration, integration with other online services, and avoids installation and configuration on desktop computers. For software development, the Web presents a shift away from developer workstations as a silo, and has the promise of closer collaboration and improved feedback through innovations in Web-based interactive development environments (IDEs). Moving IDEs to the Web is not just a matter of porting desktop IDEs; a fundamental reconsideration of the IDE architecture is necessary in order to realize the full potential that the combination of modern IDEs and the Web can offer. This paper discusses research challenges and opportunities in this area, guided by a pilot study of a web IDE implementation.


title: Managed data: modular strategies for data abstraction

authors:
Alex Loh
Tijs van der Storm
William R. Cook

abstract: Managed Data is a two-level approach to data abstraction in which programmers first define data description and manipulation mechanisms, and then use these mechanisms to define specific kinds of data. Managed Data allows programmers to take control of many important aspects of data, including persistence, access/change control, reactivity, logging, bidirectional relationships, resource management, invariants and validation. These features are implemented once as reusable strategies that can apply to many different data types. Managed Data is a general concept that can be implemented in several ways, including reflection, metaclasses, and macros. In this paper we argue for the importance of Managed Data and present a novel implementation of Managed Data based on interpretation of data models. We show how to inherit and compose interpreters to implement the features described above. Our approach allows Managed Data to be used in object-oriented languages that support reflection over field access (overriding the "dot" operator) or dynamic method creation. We also show how self-describing data models are useful for bootstrapping, allowing Managed Data to be used definition of Data Managers themselves. As a case study, we used Managed Data in a web development framework from the Ensō project to reuse database management and access control mechanisms across different data definitions.


title: Escaping the maze of twisty classes

abstract: Programmers demand more extensive class libraries so they can reuse more code and write less of their own. However, these libraries are often so large that programmers get lost in deep hierarchies of classes and their members that are very broad in number. Yet language designers continue to focus on computation, leaving tools to solve library exploration problems without much help from the language.


title: Socio-PLT: principles for programming language adoption

authors:
Leo A. Meyerovich
Ariel S. Rabkin

abstract: Why do some programming languages fail and others succeed? What does the answer tell us about programming language design, implementation, and principles? To help answer these and other questions, we argue for examining the sociological groundings of programming language theory: socio-PLT.


title: Progressive types

authors:
Joe Gibbs Politz
Hannah Quay-de la Vallee
Shriram Krishnamurthi

abstract: As modern type systems grow ever-richer, it can become increasingly onerous for programmers to satisfy them. However, some programs may not require the full power of the type system, while others may wish to obtain these rich guarantees incrementally. In particular, programmers may be willing to exploit the safety checks of the underlying runtime system as a substitute for some static guarantees. Progressive types give programmers this freedom, thus creating a gentler and more flexible environment for using powerful type checkers. In this paper we discuss the idea, motivate it with concrete, real-world scenarios, then show the development of a simple progressive type system and present its (progressive) soundness theorem.


title: Alternative programming interfaces for alternative programmers

abstract: This paper seeks to broaden the view of what programming is, who programs, and how programming fits in to larger systems. With growing frequency, people are approaching programming from unlikely backgrounds such as the arts. Often these new programmers bring with them ways of working which are incompatible with mainstream programming practices, but which allow for new possibilities in programming interfaces. This paper makes suggestions for the design of these new programming interfaces. It presents as a case study and demonstration Recursive Drawing. Recursive Drawing is a reimplementation of the textual programming language Context Free as a graphical, directly manipulable interface. Instead of a compiler or interpreter, Recursive Drawing's programming interface is modeled as a constraint solver. This allows the programmer to modify the program's source code by manipulating the program's output. Additionally, the design of the interface focuses on program transformation, rather than program construction.


title: The VIVIDE programming environment: connecting run-time information with programmers' system knowledge

authors:
Marcel Taeumel
Bastian Steinert
Robert Hirschfeld

abstract: Programmers benefit from concrete program run-time information during code-centric comprehension activities. Unfortunately, state-of-the-art programming environments distract programmers from their task-oriented thinking by forcing them to cope with (1) tool-driven run-time information access and with (2) tool-driven changing information views. However, current research projects address these problems with new concepts for capturing run-time behavior as needed and for organizing all information on-screen according to the programmers' mental model.


title: The power of interoperability: why objects are inevitable

abstract: Three years ago in this venue, Cook argued that in their essence, objects are what Reynolds called procedural data structures. His observation raises a natural question: if procedural data structures are the essence of objects, has this contributed to the empirical success of objects, and if so, how?


title: Game programming by demonstration

authors:
Mikaël Mayer
Viktor Kuncak

abstract: The increasing adoption of smartphones and tablets has provided tens of millions of users with substantial resources for computation, communication and sensing. The availability of these resources has a huge potential to positively transform our society and empower individuals. Unfortunately, although the number of users has increased dramatically, the number of developers is still limited by the high barrier that existing programming environments impose.


title: Building connections between theories of computing and physical systems

abstract: The theory and semantics of programming languages are typically formulated using abstract mathematical models that have no obvious connection to any physical theory. While this approach has a number of advantages, it does not generalize to complex nondiscrete systems, and it obscures the underlying mathematical connections between computational and physical theory. Moreover, it can lead to inaccurate models of more complex phenomena such as concurrency. In this paper, we describe the current directions and initial results of our efforts to build connections between programming language theory and semantics and physical theory. The first and most mature of these efforts aims to develop a denotational semantic model that expands upon the mathematical formulation of quantum systems to provide a denotational foundation for concurrent languages. The second effort aims to generalize the notion of type systems to a probability inference system based on Bayesian probability. The third and final effort aims to develop an understanding of the dynamics of concurrent processes, with the goal of reasoning about the real behavior of processes in greater detail. In each of these efforts, we aim to draw connections between computing and other scientific disciplines.


title: Usable live programming

abstract: Programming today involves code editing mixed with bouts of debugging to get feedback on code execution. For programming to be more fluid, editing and debugging should occur concurrently as live programming. This paper describes how live execution feedback can be woven into the editor by making places in program execution, not just code, navigable so that evaluation results can be probed directly within the code editor. A pane aside the editor also traces execution with entries that are similarly navigable, enabling quick problem diagnosis. Both probes and traces are refreshed continuously during editing, and are easily configured based on debugging needs. We demonstrate the usefulness of this live programming experience with a prototype.


title: Model-based, event-driven programming paradigm for interactive web applications

authors:
Aleksandar Milicevic
Daniel Jackson
Milos Gligoric
Darko Marinov

abstract: Applications are increasingly distributed and event-driven. Advances in web frameworks have made it easier to program standalone servers and their clients, but these applications remain hard to write. A model-based programming paradigm is proposed that allows a programmer to represent a distributed application as if it were a simple sequential program, with atomic actions updating a single, shared global state. A runtime environment executes the program on a collection of clients and servers, automatically handling (and hiding from the programmer) complications such as network communication (including server push), serialization, concurrency and races, persistent storage of data, and queuing and coordination of events.


title: KScript and KSWorld: a time-aware and mostly declarative language and interactive GUI framework

authors:
Yoshiki Ohshima
Aran Lunzer
Bert Freudenberg
Ted Kaehler

abstract: We report on a language called KScript and a GUI framework called KSWorld. The goal of KScript and KSWorld is to try to reduce the accidental complexity in GUI framework code and application building. We aim for an understandable, concise way to specify an application's behavior and appearance, minimizing extra details that arise only because of the medium being used.


title: Conversational programming: exploring interactive program analysis

abstract: Our powerful computers help very little in debugging the program we have so we can change it into the program we want. We introduce Conversational Programming as a way to harness our computing power to inspect program meaning through a combination of partial program execution and semantic program annotation. A programmer in our approach interactively selects highly autonomous "agents" in a program world as conversation topics and then changes the world to explore the potential behaviors of a selected agent in different scenarios. In this way, the programmer proactively knows how their code affects program execution as they explore various contexts. This paper describes conversational programming through design principles and use cases.


title: What's wrong with git?: a conceptual design analysis

authors:
Santiago Perez De Rosso
Daniel Jackson

abstract: It is commonly asserted that the success of a software development project, and the usability of the final product, depend on the quality of the concepts that underlie its design. Yet this hypothesis has not been systematically explored by researchers, and conceptual design has not played the central role in the research and teaching of software engineering that one might expect.


title: Content over container: object-oriented programming with multiplicities

abstract: In object-oriented programs, the relationship of an object to many objects is usually implemented using a collection. This is in contrast to a relationship to one object, which is usually realized as a direct value. However, using collections for relationships to many objects does not only mean that accessing the related objects always requires accessing the collection first, it also presents a lurking maintenance problem that manifests itself when a relationship needs to be changed from to-one to to-many or vice versa. To address these issues, we suggest the extension of object-oriented programming with multiplicities, that is, with expressions that evaluate to an arbitrary number of objects not wrapped in a container.


title: Growing solver-aided languages with rosette

authors:
Emina Torlak
Rastislav Bodík

abstract: SAT and SMT solvers have automated a spectrum of programming tasks, including program synthesis, code checking, bug localization, program repair, and programming with oracles. In principle, we obtain all these benefits by translating the program (once) to a constraint system understood by the solver. In practice, however, compiling a language to logical formulas is a tricky process, complicated by having to map the solution back to the program level and extend the language with new solver-aided constructs, such as symbolic holes used in synthesis.


title: Usable security as a static-analysis problem: modeling and reasoning about user permissions in social-sharing systems

authors:
Hannah Quay-de la Vallee
James M. Walsh
William Zimrin
Kathi Fisler
Shriram Krishnamurthi

abstract: The privacy policies of many websites, especially those designed for sharing data, are a product of many inputs. They are defined by the program underlying the website, by user configurations (such as privacy settings), and by the interactions that interfaces enable with the site. A website's security thus depends partly on users' ability to effectively use security mechanisms provided through the interface.


title: One VM to rule them all

authors:
Thomas Würthinger
Christian Wimmer
Andreas Wöß
Lukas Stadler
Gilles Duboscq
Christian Humer
Gregor Richards
Doug Simon
Mario Wolczko

abstract: Building high-performance virtual machines is a complex and expensive undertaking; many popular languages still have low-performance implementations. We describe a new approach to virtual machine (VM) construction that amortizes much of the effort in initial construction by allowing new languages to be implemented with modest additional effort. The approach relies on abstract syntax tree (AST) interpretation where a node can rewrite itself to a more specialized or more general node, together with an optimizing compiler that exploits the structure of the interpreter. The compiler uses speculative assumptions and deoptimization in order to produce efficient machine code. Our initial experience suggests that high performance is attainable while preserving a modular and layered architecture, and that new high-performance language implementations can be obtained by writing little more than a stylized interpreter.


title: User model and system model: the yin and yang in user-centered software development

authors:
Han Xu
Oliver Creighton
Naoufel Boulila
Ruth Barbara Demmel

abstract: Software systems can be viewed from both external and internal perspectives. They are called user model and system model respectively in the human-computer interaction community. In this paper, we employ the yin-yang principle as an analytical tool for reviewing the relationship between the user model and the system model. In the traditional system-centered approach, the engineer is more concerned with the system model and does not pay much attention to the user model. However, as the user-centered approach has gained increasing acceptance in a number of projects, we claim that the user model and system model are the yin and yang in user-centered software development and, following the yin-yang principle, call for equal emphasis on both models. Particularly, we propose using video-based scenarios as the representation of user models and reveal the benefits of the use of video in software development. As a case study, we describe how we have employed scenario videos in a project course and share best practices that we have identified for the creation of demo scenario videos.


title: Metamorphic Domain-Specific Languages: A Journey into the Shapes of a Language

authors:
Mathieu Acher
Benoît Combemale
Philippe Collet

abstract: External or internal domain-specific languages (DSLs) or (fluent) APIs' Whoever you are - a developer or a user of a DSL - you usually have to choose side; you should not! What about metamorphic DSLs that change their shape according to your needs? Our 4-years journey of providing the "right" support (in the domain of feature modeling), led us to develop an external DSL, different shapes of an internal API, and maintain all these languages. A key insight is that there is no one-size-fits-all solution or no clear superiority of a solution compared to another. On the contrary, we found that it does make sense to continue the maintenance of an external and internal DSL. Based on our experience and on an analysis of the DSL engineering field, the vision that we foresee for the future of software languages is their ability to be self-adaptable to the most appropriate shape (including the corresponding integrated development environment) according to a particular usage or task. We call metamorphic DSL such a language, able to change from one shape to another shape.


title: Unifying Textual and Visual: A Theoretical Account of the Visual Perception of Programming Languages

abstract: Firm principles which can be relied on to analyze and discuss textual and graphical code representations are still missing. We propose a framework relying on ScanVis, an extension of the Semiology of Graphics that models the perception and scanning of abstract graphics, to model and to provide plausible explanations of phenomena pertaining to the visual perception of representations of code. This framework unifies many aspects of the visual layout and appearance of programming languages and reveals similarities and substantial differences in the visual operations required by those notations. We also show how the framework may help compare and generate representations of programming languages with respect to visual perception. This work suggests that the gap between textual and graphical languages is narrow, and that all kind of programming languages should rely on the capability of the human visual system.


title: I Throw Itching Powder at Tulips

abstract: Programming comes in many shapes & sizes.


title: Coverage and Its Discontents

authors:
Alex Groce
Mohammad Amin Alipour
Rahul Gopinath

abstract: Everyone wants to know one thing about a test suite: will it detect enough bugs? Unfortunately, in most settings that matter, answering this question directly is impractical or impossible. Software engineers and researchers therefore tend to rely on various measures of code coverage (where mutation testing is considered a form of syntactic coverage). A long line of academic research efforts have attempted to determine whether relying on coverage as a substitute for fault detection is a reasonable solution to the problems of test suite evaluation. This essay argues that the profusion of coverage-related literature is in part a sign of an underlying uncertainty as to what exactly it is that measuring coverage should achieve, as well as how we would know if it can, in fact, achieve it. We propose some solutions and mitigations, but the primary focus of this essay is to clarify the state of current confusions regarding this key problem for effective software testing.


title: Capturing and Exploiting IDE Interactions

authors:
Zhongxian Gu
Drew Schleck
Earl T. Barr
Zhendong Su

abstract: Integrated development environments (IDEs) dominate the production and maintenance of software. Developers interact intensively with their IDEs while working. These interactions reflect a developer's thought process and work habits. By capturing and exploiting comprehensive, fine-grained IDE interactions, we can build intelligent IDEs that improve programmer productivity. This next generation of IDEs will incorporate a general framework to capture and exploit IDE interactions, and create an ecosystem of developer-aware applications and plugins. IDE++ realizes this framework on top of the popular Eclipse IDE and can be downloaded from the Eclipse marketplace. To demonstrate IDE++'s comprehensive and granular capture of interactions, we capture, then faithfully replay, a developer's IDE actions on six nontrivial programming tasks. We built four applications upon IDE++ to illustrate 1) the need for capturing comprehensive, fine-grained IDE interactions, and 2) the promise of developer-aware IDEs.


title: Phrase-Based Statistical Translation of Programming Languages

authors:
Svetoslav Karaivanov
Veselin Raychev
Martin T. Vechev

abstract: Phrase-based statistical machine translation approaches have been highly successful in translating between natural languages and are heavily used by commercial systems (e.g. Google Translate).


title: In Search of Types

abstract: The concept of "type" has been used without a consistent, precise definition in discussions about programming languages for 60 years1. In this essay I explore various concepts lurking behind distinct uses of this word, highlighting two traditions in which the word came into use largely independently: engineering traditions on the one hand, and those of symbolic logic on the other. These traditions are founded on differing attitudes to the nature and purpose of abstraction, but their distinct uses of "type" have never been explicitly unified. One result is that discourse across these traditions often finds itself at cross purposes, such as overapplying one sense of "type" where another is appropriate, and occasionally proceeding to draw wrong conclusions. I illustrate this with examples from well-known and justly well-regarded literature, and argue that ongoing developments in both the theory and practice of programming make now a good time to resolve these problems.


title: Versionable, Branchable, and Mergeable Application State

authors:
David H. Lorenz
Boaz Rosenan

abstract: NoSQL databases are rapidly becoming the storage of choice for large-scale Web applications. However, for the sake of scalability these applications trade consistency for availability. In this paper, we regain control over this trade-off by adapting an existing approach, version control (VC), to application state. By using VC, the data model is defined by the application and not by the database. The consistency model is determined at runtime by deciding when to merge and with whom. We describe the design of a VC system named VERCAST that provides fine-grained control over the consistency model used in maintaining application state.


title: Programming with Managed Time

authors:
Sean McDirmid
Jonathan Edwards

abstract: Most languages expose the computer's ability to globally read and write memory at any time. Programmers must then choreograph control flow so all reads and writes occur in correct relative orders, which can be difficult particularly when dealing with initialization, reactivity, and concurrency. Just as many languages now manage memory to unburden us from properly freeing memory, they should also manage time to automatically order memory accesses for us in the interests of comprehensibility, correctness, and simplicity. Time management is a general language feature with a large design space that is largely unexplored; we offer this perspective to relate prior work and guide future research.


title: Getting to Flow in Software Development

abstract: Humans are amazing at processing information. This ability has enabled humans to create software development projects that comprise a tremendous amount of information of various forms from predominantly natural language documents like requirements to blended natural language and structured artifacts like issues to predominantly structured source and test code. So much information is generated daily in a software product that it exceeds the ability of humans to find and process all of the information that may be useful or critical for decisions that must be made. The majority of tools used in practice to access information do not help as they are predominantly aimed at returning complete information rather than just what is needed to complete a task-at-hand. In this paper, I outline the situation facing most developers today and outline new tool interaction styles that are emerging that can help address this problem and keep a software developer in the flow of a task. By improving flow, I argue that we can enable developers (and eventually a broader set of knowledge workers) to work smarter, work better and have more fun.


title: Towards Tierless Web Development without Tierless Languages

authors:
Laure Philips
Coen De Roover
Tom Van Cutsem
Wolfgang De Meuter

abstract: Tierless programming languages enable developing the typical server, client and database tiers of a web application as a single mono-linguistic program. This development style is in stark contrast to the current practice which requires combining multiple technologies and programming languages. A myriad of tierless programming languages has already been proposed, often featuring a JavaScript-like syntax. Instead of introducing yet another, we advocate that it should be possible to develop tierless web applications in existing general-purpose languages. This not only reduces the complexity that developers are exposed to, but also precludes the need for new development tools. We concretize this novel approach to tierless programming by discussing requirements on its future instantiations. We explore the design space of the program analysis for determining and the program transformation for realizing the tier split respectively. The former corresponds to new adaptations of an old familiar, program slicing, for tier splitting. The latter includes several strategies for handling cross-tier function calls and data accesses. Using a prototype instantiation for JavaScript, we demonstrate the feasibility of our approach on an example web application. We conclude with a discussion of open questions and challenges for future research.


title: It's Only Illegal If You Get Caught: Breaking Invariants and Getting Away with It

authors:
Raphaël Proust
Alan Mycroft

abstract: Programming languages and coding standards provide invariants to ease reasoning about the correctness of code. Although useful, invariants are often intentionally broken by programmers for performance or compatibility purposes. An operation that consists of multiple steps can preserve an invariant overall even though it breaks it temporarily during the process - e.g., inserting a node into a doubly linked list takes two operations between which the list is ill-formed. It is important that intermediate states of these operations are not observable by the rest of the program. We explore various devices that are used to bundle together the different steps of such an operation in a way that hides intermediate states - bringing some form of atomicity. However, while all these constructs might work in a certain context there is no way to ensure they still work for extensions and new versions of the programming language, the underlying operating system, the linked libraries, or even the processor architecture. We propose a new construct, opaque}, to overcome these problems - decoupling code correctness and execution context - and future-proof invariant-breaking code by insisting that both current and future versions of the compiler treat the enclosed block as having no observable intermediate states.


title: Multi-Tier Functional Reactive Programming for the Web

authors:
Bob Reynders
Dominique Devriese
Frank Piessens

abstract: The development of robust and efficient interactive web applications is challenging, because developers have to deal with multiple programming languages, asynchronous events, propagating data and events between clients and servers, data consistency and much more. Several approaches for (partly) addressing these challenges have been proposed. Two relevant ones are (1) multi-tier languages and (2) functional reactive programming (FRP). Multi-tier programming languages support the development of client and server in a single language, and hide much of the complexity related to distribution. FRP offers the right abstractions to make event-driven programming convenient, safe and composable. However, existing web frameworks and programming languages exploit the benefits of both approaches separately, for example by restricting the use of FRP to the client side.


title: Call by Meaning

authors:
Hesam Samimi
Chris Deaton
Yoshiki Ohshima
Alessandro Warth
Todd D. Millstein

abstract: Software development involves stitching existing components together. These data/service components are usually not well understood, as they are made by others and often obtained from somewhere on the Internet. This makes software development a daunting challenge, requiring programmers to manually discover the resources they need, understand their capabilities, adapt these resources to their needs, and update the system as external components change.


title: Description Logic as Programming Language

abstract: This paper introduces the use of Description Logic as a programming language, giving: a logic with appropriate concept constructors and sentential forms; some example programs; requirements for the results of program execution; a tableau algorithm that provably produces the desired results; principles for discarding sentences once no longer needed so that algorithms that take more time than space can be implemented; a worked example of program execution; and a discussion of outstanding theoretical challenges.


title: Mining the Ecosystem to Improve Type Inference for Dynamically Typed Languages

authors:
Boris Spasojevic
Mircea Lungu
Oscar Nierstrasz

abstract: Dynamically typed languages lack information about the types of variables in the source code. Developers care about this information as it supports program comprehension. Basic type inference techniques are helpful, but may yield many false positives or negatives.


title: The Programming Language Wars: Questions and Responsibilities for the Programming Language Community

authors:
Andreas Stefik
Stefan Hanenberg

abstract: The discipline of computer science has a long and complicated history with computer programming languages. Historically, inventors have created language products for a wide variety of reasons, from attempts at making domain specific tasks easier or technical achievements, to economic, social, or political reasons. As a consequence, the modern programming language industry now has a large variety of incompatible programming languages, each of which with unique syntax, semantics, toolsets, and often their own standard libraries, lifetimes, and costs. In this paper, we suggest that the programming language wars, a term which describes the broad divergence and impact of language designs, including often pseudo-scientific claims made that they are good or bad, may be negatively impacting the world. This broad problem, which is almost completely ignored in computer science, needs to be acted upon by the community.


title: The Semantics of Version Control

authors:
Wouter Swierstra
Andres Löh

abstract: As software becomes increasingly complex, software configuration management is becoming ever more important. This paper shows how logics for reasoning about mutable state, such as separation logic, can also be used to give semantics for version control systems. By applying these ideas from the programming language research community, developers may reason formally about the broader software development process.


title: Interleaving of Modification and Use in Data-driven Tool Development

authors:
Marcel Taeumel
Michael Perscheid
Bastian Steinert
Jens Lincke
Robert Hirschfeld

abstract: 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.


title: Korz: Simple, Symmetric, Subjective, Context-Oriented Programming

authors:
David M. Ungar
Harold Ossher
Doug Kimelman

abstract: Korz is a new computational model that provides for context-oriented programming by combining implicit arguments and multiple dispatch in a slot-based model. This synthesis enables the writing of software that supports contextual variation along multiple dimensions, and graceful evolution of that software to support new, unexpected dimensions of variability, without the need for additional mechanism such as layers or aspects. With Korz, a system consists of a sea of method and data slots in a multidimensional space. There is no fixed organization of slots into objects - a slot pertains to a number of objects instead of being contained by a single object - and slots can come together according to the implicit context in any given situation, yielding subjective objects. There is no dominant decomposition, and no dimension holds sway over any other. IDE support is essential for managing complexity when working with the slot space and with subjectivity, allowing the task at hand to dictate what subspaces to isolate and what dominance of dimensions to use when presenting nested views to the user. We have implemented a prototype interpreter and IDE, and used it on several examples. This early experience has revealed much that needs to be done, but has also shown considerable promise. It seems that Korz's particular combination of concepts, each well-known from the past, is indeed more powerful than the sum of its parts.


title: A Language Designer's Workbench: A One-Stop-Shop for Implementation and Verification of Language Designs

authors:
Eelco Visser
Guido Wachsmuth
Andrew P. Tolmach
Pierre Neron
Vlad A. Vergu
Augusto Passalaqua
Gabriël Konat

abstract: The realization of a language design requires multiple artifacts that redundantly encode the same information. This entails significant effort for language implementors, and often results in late detection of errors in language definitions. In this paper we present a proof-of-concept language designer's workbench that supports generation of IDEs, interpreters, and verification infrastructure from a single source. This constitutes a first milestone on the way to a system that fully automates language implementation and verification.


title: Variational Data Structures: Exploring Tradeoffs in Computing with Variability

authors:
Eric Walkingshaw
Christian Kästner
Martin Erwig
Sven Apel
Eric Bodden

abstract: Variation is everywhere, and in the construction and analysis of customizable software it is paramount. In this context, there arises a need for variational data structures for efficiently representing and computing with related variants of an underlying data type. So far, variational data structures have been explored and developed ad hoc. This paper is a first attempt and a call to action for systematic and foundational research in this area. Research on variational data structures will benefit not only customizable software, but many other application domains that must cope with variability. In this paper, we show how support for variation can be understood as a general and orthogonal property of data types, data structures, and algorithms. We begin a systematic exploration of basic variational data structures, exploring the tradeoffs among different implementations. Finally, we retrospectively analyze the design decisions in our own previous work where we have independently encountered problems requiring variational data structures.


title: One parser to rule them all

authors:
Ali Afroozeh
Anastasia Izmaylova

abstract: Despite the long history of research in parsing, constructing parsers for real programming languages remains a difficult and painful task. In the last decades, different parser generators emerged to allow the construction of parsers from a BNF-like specification. However, still today, many parsers are handwritten, or are only partly generated, and include various hacks to deal with different peculiarities in programming languages. The main problem is that current declarative syntax definition techniques are based on pure context-free grammars, while many constructs found in programming languages require context information. In this paper we propose a parsing framework that embraces context information in its core. Our framework is based on data-dependent grammars, which extend context-free grammars with arbitrary computation, variable binding and constraints. We present an implementation of our framework on top of the Generalized LL (GLL) parsing algorithm, and show how common idioms in syntax of programming languages such as (1) lexical disambiguation filters, (2) operator precedence, (3) indentation-sensitive rules, and (4) conditional preprocessor directives can be mapped to data-dependent grammars. We demonstrate the initial experience with our framework, by parsing more than 20000 Java, C#, Haskell, and OCaml source files.


title: Towards secure integration of cryptographic software

authors:
Steven Arzt
Sarah Nadi
Karim Ali
Eric Bodden
Sebastian Erdweg
Mira Mezini

abstract: While cryptography is now readily available to everyone and can, provably, protect private information from attackers, we still frequently hear about major data leakages, many of which are due to improper use of cryptographic mechanisms. The problem is that many application developers are not cryptographic experts. Even though high-quality cryptographic APIs are widely available, programmers often select the wrong algorithms or misuse APIs due to a lack of understanding. Such issues arise with both simple operations such as encryption as well as with complex secure communication protocols such as SSL. In this paper, we provide a long-term solution that helps application developers integrate cryptographic components correctly and securely by bridging the gap between cryptographers and application developers. Our solution consists of a software product line (with an underlying feature model) that automatically identifies the correct cryptographic algorithms to use, based on the developer's answers to high-level questions in non-expert terminology. Each feature (i.e., cryptographic algorithm) maps into corresponding Java code and a usage protocol describing API restrictions. By composing the user's selected features, we automatically synthesize a secure code blueprint and a usage protocol that corresponds to the selected usage scenario. Since the developer may change the application code over time, we use the usage protocols to statically analyze the program and ensure that the correct use of the API is not violated over time.


title: Toward tool support for interactive synthesis

authors:
Shaon Barman
Rastislav Bodík
Satish Chandra
Emina Torlak
Arka Aloke Bhattacharya
David E. Culler

abstract: Syntax-guided synthesis searches for an implementation of a given specification by exploring large spaces of candidate programs. Sketches reduce these search spaces, making synthesis more tractable, by predefining the structure of the desired implementation. Typically, this structure is obtained through human insight---this paper introduces a method for interactive, tool-supported discovery of such structure. The key idea is to decompose the specification into subcomputations such that the decomposition dictates the sketch. We rely on a readily obtainable specification that is nothing more than a finite set of sample input-output pairs or execution traces of the desired program. We introduce two complementary decomposition operators and demonstrate them on case studies. We find that our interactive methodology to discover structure extends the reach of computer-aided programming to problems that cannot be solved with synthesis alone.


title: Towards fully reflective environments

authors:
Guido Chari
Diego Garbervetsky
Stefan Marr
Stéphane Ducasse

abstract: Modern development environments promote live programming (LP) mechanisms because it enhances the development experience by providing instantaneous feedback and interaction with live objects. LP is typically supported with advanced reflective techniques within dynamic languages. These languages run on top of Virtual Machines (VMs) that are built in a static manner so that most of their components are bound at compile time. As a consequence, VM developers are forced to work using the traditional edit-compile-run cycle, even when they are designing LP-supporting environments. In this paper we explore the idea of bringing LP techniques to the VM domain for improving their observability, evolution and adaptability at run-time. We define the notion of fully reflective execution environments (EEs), systems that provide reflection not only at the application level but also at the level of the VM. We characterize such systems, propose a design, and present Mate v1, a prototypical implementation. Based on our prototype, we analyze the feasibility and applicability of incorporating reflective capabilities into different parts of EEs. Furthermore, the evaluation demonstrates the opportunities such reflective capabilities provide for unanticipated dynamic adaptation scenarios, benefiting thus, a wider range of users.


title: The moldable inspector

authors:
Andrei Chis
Oscar Nierstrasz
Aliaksei Syrel
Tudor Gîrba

abstract: Object inspectors are an essential category of tools that allow developers to comprehend the run-time of object-oriented systems. Traditional object inspectors favor a generic view that focuses on the low-level details of the state of single objects. Based on 16 interviews with software developers and a follow-up survey with 62 respondents we identified a need for object inspectors that support different high-level ways to visualize and explore objects, depending on both the object and the current developer need. We propose the Moldable Inspector, a novel inspector model that enables developers to adapt the inspection workflow to suit their immediate needs by making the inspection context explicit, providing multiple interchangeable domain-specific views for each object, and supporting a workflow that groups together multiple levels of connected objects. We show that the Moldable Inspector can address multiple kinds of development needs involving a wide range of objects.


title: Runtime metric meets developer: building better cloud applications using feedback

authors:
Jürgen Cito
Philipp Leitner
Harald C. Gall
Aryan Dadashi
Anne Keller
Andreas Roth

abstract: A unifying theme of many ongoing trends in software engineering is a blurring of the boundaries between building and operating software products. In this paper, we explore what we consider to be the logical next step in this succession: integrating runtime monitoring data from production deployments of the software into the tools developers utilize in their daily workflows (i.e., IDEs) to enable tighter feedback loops. We refer to this notion as feedback-driven development (FDD). This more abstract FDD concept can be instantiated in various ways, ranging from IDE plugins that implement feedback-driven refactoring and code optimization to plugins that predict performance and cost implications of code changes prior to even deploying the new version of the soft- ware. We demonstrate existing proof-of-concept realizations of these ideas and illustrate our vision of the future of FDD and cloud-based software development in general. Further, we discuss the major challenges that need to be solved be- fore FDD can achieve mainstream adoption.


title: Type systems for the masses: deriving soundness proofs and efficient checkers

authors:
Sylvia Grewe
Sebastian Erdweg
Pascal Wittmann
Mira Mezini

abstract: The correct definition and implementation of non-trivial type systems is difficult and requires expert knowledge, which is not available to developers of domain-specific languages (DSLs) in practice. We propose Veritas, a workbench that simplifies the development of sound type systems. Veritas provides a single, high-level specification language for type systems, from which it automatically tries to derive soundness proofs and efficient and correct type-checking algorithms. For verification, Veritas combines off-the-shelf automated first-order theorem provers with automated proof strategies specific to type systems. For deriving efficient type checkers, Veritas provides a collection of optimization strategies whose applicability to a given type system is checked through verification on a case-by-case basis. We have developed a prototypical implementation of Veritas and used it to verify type soundness of the simply-typed lambda calculus and of parts of typed SQL. Our experience suggests that many of the individual verification steps can be automated and, in particular, that a high degree of automation is possible for type systems of DSLs.


title: Musiplectics: computational assessment of the complexity of music scores

authors:
Ethan Holder
Eli Tilevich
Amy Gillick

abstract: In the Western classical tradition, musicians play music from notated sheet music, called a score. When playing music from a score, a musician translates its visual symbols into sequences of instrument-specific physical motions. Hence, a music score's overall complexity represents a sum of the cognitive and mechanical acuity required for its performance. For a given instrument, different notes, intervals, articulations, dynamics, key signatures, and tempo represent dissimilar levels of difficulty, which vary depending on the performer's proficiency. Individual musicians embrace this tenet, but may disagree about the degrees of difficulty. This paper introduces musiplectics (musiplectics = music + plectics, Greek for the study of complexity), a systematic and objective approach to computational assessment of the complexity of a music score for any instrument. Musiplectics defines computing paradigms for automatically and accurately calculating the complexity of playing a music score on a given instrument. The core concept codifies a two-phase process. First, music experts rank the relative difficulty of individual musical components (e.g., notes, intervals, dynamics, etc.) for different playing proficiencies and instruments. Second, a computing engine automatically applies this ranking to music scores and calculates their respective complexity. As a proof of concept of musiplectics, we present an automated, Web-based application called Musical Complexity Scoring (MCS) for music educators and performers. Musiplectics can engender the creation of practical computing tools for objective and expeditious assessment of a music score's suitability for the abilities of intended performers.


title: Towards a theory of conceptual design for software

abstract: Concepts are the building blocks of software systems. They are not just subjective mental constructs, but are objective features of a system's design: increments of functionality that were consciously introduced by a designer to serve particular purposes. This essay argues for viewing the design of software in terms of concepts, with their invention (or adoption) and refinement as the central activity of software design. A family of products can be characterized by arranging concepts in a dependence graph from which coherent concept subsets can be extracted. Just as bugs can be found in the code of a function prior to testing by reviewing the programmer's argument for its correctness, so flaws can be found in a software design by reviewing an argument by the designer. This argument consists of providing, for each concept, a single compelling purpose, and demonstrating how the concept fulfills the purpose with an archetypal scenario called an 'operational principle'. Some simple conditions (primarily in the relationship between concepts and their purposes) can then be applied to reveal flaws in the conceptual design.


title: Towards a dynamic object model within Unix processes

abstract: Programmers face much complexity from the co-existence of "native" (Unix-like) and virtual machine (VM) "managed" run-time environments. Rather than having VMs replace Unix processes, we investigate whether it makes sense for the latter to "become VMs", by evolving Unix's user-level services to subsume those of VMs. We survey the (little-understood) VM-like features in modern Unix, noting common shortcomings: a lack of semantic metadata ("type information") and the inability to bind from objects "back" to their metadata. We describe the design and implementation of a system, liballocs, which adds these capabilities in a highly compatible way, and explore its consequences.


title: Slimming languages by reducing sugar: a case for semantics-altering transformations

authors:
Junsong Li
Justin Pombrio
Joe Gibbs Politz
Shriram Krishnamurthi

abstract: Splitting a language into a core language and a desugaring function makes it possible to produce tractable semantics for real-world languages. It does so by pushing much of the language's complexity into desugaring. This, however, produces large and unwieldy core programs, which has proven to be a significant obstacle to actual use of these semantics. In this paper we analyze this problem for a semantics of JavaScript. We show that much of the bloat is *semantic bloat*: a consequence of the language's rich semantics. We demonstrate how assumptions about language use can confine this bloat, and codify these through several transformations that, in general, do not preserve the language's semantics. We experimentally demonstrate the effectiveness of these transformations. Finally, we discuss the implications of this work on language design and structure.


title: Separation of powers in the cloud: where applications and users become peers

authors:
David H. Lorenz
Boaz Rosenan

abstract: We challenge the widely accepted practice that web applications must be trusted with user data. We present an alternative model based on logic programming, where users and applications are equal peers in a shared cloud environment. User data is represented as a set of facts. The application is represented as a set of rules defining how user data is to be processed, but is not given direct access to the data. This way, end users remain the owners of their own data, and are able to determine who can see it and who can modify it. For concreteness, we define a data representation and query language, named Cloudlog, for a new family of deductive databases, named NoDatalog. We add access control to the language for guaranteeing that the rules provided by the application cannot change the choices made by users. We demonstrate how business logic can be expressed in Cloudlog, and discuss how an efficient Cloudlog-based database can be implemented.


title: Columnar objects: improving the performance of analytical applications

authors:
Toni Mattis
Johannes Henning
Patrick Rein
Robert Hirschfeld
Malte Appeltauer

abstract: 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.


title: The cuneiform tablets of 2015

authors:
Long Tien Nguyen
Alan C. Kay

abstract: We discuss the problem of running today's software decades, centuries, or even millennia into the future.


title: Against a universal definition of 'Type'

abstract: What is the definition of 'type'? Having a clear and precise answer to this question would avoid many misunderstandings and prevent meaningless discussions that arise from them. But having such clear and precise answer to this question would also hurt science, "hamper the growth of knowledge" and "deflect the course of investigation into narrow channels of things already understood". In this essay, I argue that not everything we work with needs to be precisely defined. There are many definitions used by different communities, but none of them applies universally. A brief excursion into philosophy of science shows that this is not just tolerable, but necessary for progress. Philosophy also suggests how we can think about this imprecise notion of type.


title: A bootstrapping infrastructure to build and extend Pharo-like languages

authors:
Guillermo Polito
Stéphane Ducasse
Noury Bouraqadi
Luc Fabresse

abstract: Bootstrapping is well known in the context of compilers, where a bootstrapped compiler can compile its own source code. Bootstrapping is a beneficial engineering practice because it raises the level of abstraction of a program making it easier to understand, optimize, evolve, etc. Bootstrapping a reflective object-oriented language is however more challenging, as we need also to initialize the runtime of the language with its initial objects and classes besides writing its compiler. In this paper, we present a novel bootstrapping infrastructure for Pharo-like languages that allows us to easily extend and modify such languages. Our bootstrapping process relies on a first-class runtime. A first-class runtime is a meta-object that represents a program’s runtime and provides a MOP to easily load code into it and manipulate its objects. It decouples the virtual machine (VM) and language concerns by introducing a clear VM-language interface. Using this process, we show how we succeeded to bootstrap a Smalltalk-based language named Candle and then extend it with traits in less than 250 lines of high-level Smalltalk code. We also show how we can bootstrap with minimal effort two other languages (Pharo and MetaTalk) with similar execution semantics but different object models.


title: Virtualization support for dynamic core library update

authors:
Guillermo Polito
Stéphane Ducasse
Noury Bouraqadi
Luc Fabresse
Max Mattone

abstract: Dynamically updating language runtime and core libraries such as collections and threading is challenging since the update mechanism uses such libraries at the same time that it modifies them. To tackle this challenge, we present Dy- namic Core Library Update (DCU) as an extension of Dy- namic Software Update (DSU) and our approach based on a virtualization architecture. Our solution supports the up- date of core libraries as any other normal library, avoiding the circular dependencies between the updater and the core libraries. Our benchmarks show that there is no evident per- formance overhead in comparison with a default execution. Finally, we show that our approach can be applied to real life scenario by introducing a critical update inside a web application with 20 simulated concurrent users.


title: Isolates, channels, and event streams for composable distributed programming

authors:
Aleksandar Prokopec
Martin Odersky

abstract: The actor model has been a model of choice for building reliable distributed systems. On one hand, it ensures that message-processing is serialized within each actor, preserving the familiar sequential programming model. On the other hand, programs written in the actor model are location-transparent. The model is sufficiently low-level to express arbitrary message protocols. Composing these protocols is the key to high-level abstractions. Unfortunately, it is difficult to reuse or compose message protocols with actors. Reactive isolates, proposed in this paper, simplify protocol composition with first-class typed channels and event streams. We compare reactive isolates and the actor model on concrete programs. We identify obstacles for composition in the classic actor model, and show how to overcome them. We then show how to build reusable, composable distributed computing components in the new model.


title: Constraints as a design pattern

authors:
Hesam Samimi
Alessandro Warth
Mahdi Eslamimehr
Alan Borning

abstract: Imperative programming has great merits. As the ubiquitous style, it is familiar, and its linear and step by step nature is favored by the human mind. Experienced programmers, however, are aware of its major flaw: it is easy for meanings to get lost in piles of code, making software hard to understand, extend, and debug. Constraint-based programming as an alternative has been observed to suffer much less from these flaws, where the "what" (the intention) is expressed rather than the "how" (the algorithm) in performing a computation. It is the job of the system to automatically achieve the intention through constraint solving. Sadly, poor performance and expressiveness has prevented this style from seeing widespread adoption. We propose a general programming model as a kind of a sweet spot between imperative and constraint-based programming. Our aim is to leverage many benefits of constraint-based programming such as understandability, behavioral modularity, extensibility, etc., in a practical way and without suffering the breakdown of the approach as with the traditional constraint-based paradigm. This model enforces a certain organization where at the top-level a program is simply composed of a set of constraints. However, the constraints aren't necessarily solved by an external entity, and the programmer uses imperative code to specify (1) how each constraint should be solved in isolation, and (2) how to combine individual solutions. We have implemented a tool called Sketchpad14 that incorporates this model in JavaScript, and built a number of realistic applications in it. In this paper we demonstrate the merits of our approach by comparing it with traditional imperative as well as constraint-based approaches.


title: Just-in-time data structures

authors:
Mattias De Wael
Stefan Marr
Joeri De Koster
Jennifer B. Sartor
Wolfgang De Meuter

abstract: Today, software engineering practices focus on finding the single ``right'' data representation for a program. The ``right'' data representation, however, might not exist: changing the representation of an object during program execution can be better in terms of performance. To this end we introduce Just-in-Time Data Structures, which enable representation changes at runtime, based on declarative input from a performance expert programmer. Just-in-Time Data Structures are an attempt to shift the focus from finding the ``right'' data structure to finding the ``right'' sequence of data representations. We present JitDS, a programming language to develop such Just-in-Time Data Structures. Further, we show two example programs that benefit from changing the representation at runtime.


title: The Cuban software revolution: 2016¿2025

abstract: Presented as a work of fiction, this essay is about software development— how it has come to be what it is and what it might have been. The concept and metaphor of culture is used to frame the discussion. What might have been is presented as an approach named “Living System Design” and its practice in a fictional Cuba of the near future.


title: Building white-box abstractions by program refinement

authors:
Mehrdad Afshari
Zhendong Su

abstract: Abstractions make building complex systems possible. Many facilities provided by a modern programming language are directly designed to build a certain style of abstraction. Abstractions also aim to enhance code reusability, thus enhancing programmer productivity and effectiveness.


title: Emergent software services

abstract: Services are normally composed following a structured model, or based on a particular goal that needs to be fulfilled. Such model is problematic for pervasive environments, since service components deployed in the environment are unknown beforehand. As a result, services may never execute due to the unavailability of one of the pre-specified components, or components missing to fulfill the service goal. This paper posits a new vision for service composition by inverting the control flow of service-oriented applications between users and the environment. Rather than having to request a particular service, services emerge from the environment based on interactions between available service components, and are pushed to be utilized by users. We present the architecture required to fulfill our vision in enabling service emergence in a pervasive environment. This vision architecture is realized by an initial prototype framework for software service emergence called Mordor. Early results of this vision are obtained from two examples demonstrating the feasibility of services emergence from previously unknown service components, and a case study demonstrating Mordor's usability in real world scenarios.


title: Moldable, context-aware searching with Spotter

authors:
Andrei Chis
Tudor Gîrba
Juraj Kubelka
Oscar Nierstrasz
Stefan Reichhart
Aliaksei Syrel

abstract: Software systems involve many different kinds of domain-specific and interrelated software entities. A common strategy employed by developers to deal with this reality is to perform exploratory investigations by means of searching. Nevertheless, most integrated development environments (IDEs) support searching through generic and disconnected search tools. This impedes search tasks over domain-specific entities, as considerable effort is wasted by developers locating and linking data and concepts relevant to their application domains.


title: How are programs found? speculating about language ergonomics with Curry-Howard

abstract: Functional languages with strong static type systems have beneficial properties to help ensure program correctness and reliability. Surprisingly, their practical significance in applications is low relative to other languages lacking in those dimensions. In this paper, the programs-as-proofs analogy is taken seriously to gain speculative insights by analysis of creation habits in the proof-centric discipline of mathematics. Viewed in light of this analogy, a sampling of mathematicians' attitudes towards formal proof suggests that the crucial role of intuition and experimentation in programming tasks may be under appreciated, hinting at a possible explanation of the challenges rigorously disciplined languages face in practical applications.


title: Bloqqi: modular feature-based block diagram programming

authors:
Niklas Fors
Görel Hedin

abstract: Automation programming is typically done using blocks and dataflow connections, in diagram languages that support user-defined block types. Often, these types are intended to be instantiated and connected to other blocks in common patterns, corresponding to anticipated variability. We present the new language mechanisms of wirings and recommendations that allow these intentions to be encoded as features in libraries. A wiring describes how a given block is typically connected to other blocks, and a recommendation describes where such a wiring is typically applied as a feature. This allows feature-based wizards to be generated for user-defined libraries, making it easy to construct applications that make use of the encoded patterns.


title: in the control room of the banquet

abstract: Creativity, AI, programming, the Turing Test, and mystery.


title: Helping Johnny encrypt: toward semantic interfaces for cryptographic frameworks

authors:
Soumya Indela
Mukul Kulkarni
Kartik Nayak
Tudor Dumitras

abstract: Several mature cryptographic frameworks are available, and they have been utilized for building complex applications. However, developers often use these frameworks incorrectly and introduce security vulnerabilities. This is because current cryptographic frameworks erode abstraction boundaries, as they do not encapsulate all the framework-specific knowledge and expect developers to understand security attacks and defenses. Starting from the documented misuse cases of cryptographic APIs, we infer five developer needs and we show that a good API design would address these needs only partially. Building on this observation, we propose APIs that are semantically meaningful for developers, we show how these interfaces can be implemented consistently on top of existing frameworks using novel and known design patterns, and we propose build management hooks for isolating security workarounds needed during the development and test phases. Through two case studies, we show that our APIs can be utilized to implement non-trivial client-server protocols and that they provide a better separation of concerns than existing frameworks. We also discuss the challenges and potential approaches for evaluating our solution. Our semantic interfaces represent a first step toward preventing misuses of cryptographic APIs.


title: A world of active objects for work and play: the first ten years of lively

authors:
Daniel Ingalls
Tim Felgentreff
Robert Hirschfeld
Robert Krahn
Jens Lincke
Marko Röder
Antero Taivalsaari
Tommi Mikkonen

abstract: The Lively Kernel and the Lively Web represent a continuing effort to realize a creative computing environment in the context of the World Wide Web. We refer to that evolving system simply as "Lively". Lively is a live object computing environment implemented using JavaScript and other techniques available inside the browser. When first built in 2006, it was a grand accomplishment to have created such a system that would run in any web browser. Since that time we have learned a lot about the goals we had, the challenges and opportunities that come with life in the browser, and the exciting possibilities that still lie ahead.


title: Exploring the role of sequential computation in distributed systems: motivating a programming paradigm shift

authors:
Ivan Kuraj
Daniel Jackson

abstract: Despite many advances in programming models and frameworks, writing distributed applications remains hard. Even when the underlying logic is inherently sequential and simple, addressing distributed aspects results in complex cross-cutting code that undermines such simplicity.


title: Nez: practical open grammar language

abstract: Nez is a PEG(Parsing Expressing Grammar)-based open grammar language that allows us to describe complex syntax constructs without action code. Since open grammars are declarative and free from a host programming language of parsers, software engineering tools and other parser applications can reuse once-defined grammars across programming languages.


title: Lightweight programming experiments without programmers and programs: an example study on the effect of similarity and number of object identifiers on the readability of source code using natural texts

authors:
Tim Marter
Paul Babucke
Philipp Lembken
Stefan Hanenberg

abstract: It is often said that controlled experiments should check the effect of programming languages or styles on programming. But it is also often said that running controlled experiments is a very time consuming and error prone task – that's why a lot of researchers do not run such experiments. Both arguments are plausible, but there is potentially an alternative: lightweight experiments where the effort to run such experiments is low and which (still) fulfill the requirements of controlled experiments with two exceptions: First, these experiments do not use programmers as subjects, and second, the experiments do not contain programming tasks. Instead, such experiments try to find analogies from other domains where the topic to be studied is (still) close enough to the original target domain but where it is easier to find participants and experimental setups. This paper illustrates such a lightweight experiment by introducing a study on the effect of number of identifiers and similarity of identifiers on (code) readability – without using source code and without programmers as subjects. The result of the experiment is comparable to other experimental results which gives a first indicator that it is possible to run such lightweight experiments that approximate the results of full-blown experiments. This paper argues that such lightweight experiments could be useful in the process of experimentation – they cannot and should not supersede full-blown experiments, but they can help in early stages of experimentation.


title: Object spreadsheets: a new computational model for end-user development of data-centric web applications

authors:
Matt McCutchen
Shachar Itzhaky
Daniel Jackson

abstract: Spreadsheets offer many advantages as the computational and data-storage engine for applications that are authored by end users. Paradoxically, however, their main failing in this regard is their computational model. Despite being used in almost all cases to represent data that is essentially relational (with some hierarchical structuring), the spreadsheet model treats the two-dimensional grid as largely unstructured, with formulas linking cells in an ad hoc way.


title: Function passing: a model for typed, distributed functional programming

authors:
Heather Miller
Philipp Haller
Normen Müller
Jocelyn Boullier

abstract: The most successful systems for "big data" processing have all adopted functional APIs. We present a new programming model we call function passing designed to provide a more principled substrate on which to build data-centric distributed systems. A key idea is to build up a persistent functional data structure representing transformations on distributed immutable data by passing well-typed serializable functions over the wire and applying them to this distributed data. Thus, the function passing model can be thought of as a persistent functional data structure that is distributed, where transformations to data are stored in its nodes rather than the distributed data itself. The model simplifies failure recovery by design-in the event of a failure, data is recovered by replaying function applications atop immutable data loaded from stable storage. Deferred evaluation is also central to our model; by incorporating deferred evaluation into our design only at the point of initiating network communication, the function passing model remains easy to reason about while remaining efficient in time and memory. We formalize our programming model using small-step operational semantics, and we provide an open-source implementation of our model in and for the Scala programming language, along with a case study of several example frameworks and end-user programs written atop of this model.


title: Exploring cheap type inference heuristics in dynamically typed languages

authors:
Nevena Milojkovic
Oscar Nierstrasz

abstract: Although dynamically typed languages allow developers to be more productive in writing source code, their lack of in- formation about types of variables is one of the main obstacles during program comprehension. Static type information helps developers to decrease software maintenance time. Inference of types of variables requires complex algorithms to avoid false positives or negatives. Their main aim is to shorten the list of possible types for a variable. We have developed a couple of cheap heuristics that use easily accessible information about the presence of each class in the available source code to promote the correct type towards the top of the list of possible types for a variable. Our evaluation of a proof-of-concept prototype, implemented in Pharo Smalltalk, shows that both for domain- specific types and standard libraries these heuristics tend to work well. The evaluated heuristics prove to be reasonably precise, promoting the correct types of a variable towards the top of the list in 50.67% up to 89.09% of cases on average, depending on the applied heuristic. The heuristic that has proved to be the best was compared with one existing type inference algorithm and the best heuristic yields significantly better results with less effort.


title: The left hand of equals

authors:
James Noble
Andrew P. Black
Kim B. Bruce
Michael Homer
Mark S. Miller

abstract: When is one object equal to another object? While object identity is fundamental to object-oriented systems, object equality, although tightly intertwined with identity, is harder to pin down. The distinction between identity and equality is reflected in object-oriented languages, almost all of which provide two variants of "equality", while some provide many more. Programmers can usually override at least one of these forms of equality, and can always define their own methods to distinguish their own objects.


title: Gramada: immediacy in programming language development

authors:
Patrick Rein
Robert Hirschfeld
Marcel Taeumel

abstract: Domain-specific languages (DSLs) improve software maintainability and programmer productivity by making domain concepts more explicit in the code. However, developing syntax and semantics of DSLs is often challenging and as a result developers seldom take advantage of the benefits of DSLs. One way to lower the entry barrier to DSL development is to give developers immediate and continuous feedback on modifications to a language. We propose Gramada, an environment for developing DSLs in Squeak/Smalltalk which is designed to provide such a live programming experience. It is based on a language development framework with additional support for incremental compilation to improve system response times and a set of tools which creates a steady frame and allows programmers to quickly explore changes to the syntax of a language. Our benchmarks and discussion illustrate how Gramada can give visual feedback on most changes to the language in a way that supports live programming. We conclude that Gramada’s feedback is fast and consistent enough to make exploring the effects of changes a lively and productive activity during the interactive development of DSLs.


title: Extracting code from programming tutorial videos

authors:
Shir Yadid
Eran Yahav

abstract: The number of programming tutorial videos on the web increases daily. Video hosting sites such as YouTube host millions of video lectures, with many programming tutorials for various languages and platforms. These videos contain a wealth of valuable information, including code that may be of interest. However, two main challenges have so far prevented the effective indexing of programming tutorial videos: (i) code in tutorials is typically written on-the-fly, with only parts of the code visible in each frame, and (ii) optical character recognition (OCR) is not precise enough to produce quality results from videos. We present a novel approach for extracting code from videos that is based on: (i) consolidating code across frames, and (ii) statistical language models for applying corrections at different levels, allowing us to make corrections by choosing the most likely token, combination of tokens that form a likely line structure, and combination of lines that lead to a likely code fragment in a particular language. We implemented our approach in a tool called ACE, and used it to extract code from 40 Android video tutorials on YouTube. Our evaluation shows that ACE extracts code with high accuracy, enabling deep indexing of video tutorials.


title: Leveraging a corpus of natural language descriptions for program similarity

authors:
Meital Zilberstein
Eran Yahav

abstract: Program similarity is a central challenge in many programming-related applications, such as code search, clone detection, automatic translation, and programming education.


title: The serverless trilemma: function composition for serverless computing

authors:
Ioana Baldini
Perry Cheng
Stephen J. Fink
Nick Mitchell
Vinod Muthusamy
Rodric Rabbah
Philippe Suter
Olivier Tardieu

abstract: The field of serverless computing has recently emerged in support of highly scalable, event-driven applications. A serverless application is a set of stateless functions, along with the events that should trigger their activation. A serverless runtime allocates resources as events arrive, avoiding the need for costly pre-allocated or dedicated hardware.


title: How can our publication models best serve our research? (panel)

abstract: Research and publication have a long history together, with models that date back millennia. Our experience in Computer Science has much in common with other areas of scholarship, but also some distinctive characteristics. One issue discussed and explored extensively involves the role of conferences and journals. This panel has specific focus on how our publication model might best help the research itself. Issues that arise still include the pragmatic, but also a range of other topics particular to our discipline: the role of artifacts and empirical research, the potential for new tools and infrastructure similar to those we use for software, and how best to structure research publications to support practice.


title: Assessing user preferences in programming language design

abstract: The design of new programming languages has primarily been guided by the preferences of a few (the authors of the language), rather than systematic study of the various options available. This is in part due to the fact that user studies to effectively test usability or understandability hypotheses are cumbersome and expensive. An interesting question is whether crowdsourcing techniques can be leveraged to improve this situation.


title: You can have it all: abstraction and good cache performance

authors:
Juliana Franco
Martin Hagelin
Tobias Wrigstad
Sophia Drossopoulou
Susan Eisenbach

abstract: On current architectures, the optimisation of an application's performance often involves data being stored according to access affinity --- what is accessed together should be stored together, rather than logical affinity --- what belongs together logically stays together. Such low level techniques lead to faster, but more error prone code, and end up tangling the program's logic with low-level data layout details.


title: Infra: structure all the way down: structured data as a visual programming language

authors:
Christopher Hall
Trevor Standley
Tobias Höllerer

abstract: We present Infra, a new baseline medium for representing data. With Infra, arbitrarily-complex structured data can be encoded, viewed, edited, and processed, all while remaining in an efficient non-textual form. It is suitable for the full range of information modalities, from free-form input, to compact schema-conforming structures. With its own equivalent of a text editor and text-field widget, Infra is designed to target the domain currently dominated by flat character strings while simultaneously enabling the expression of sub-structure, inter-reference, dynamic dependencies, abstraction, computation, and context (metadata).


title: Unbounded superoptimization

authors:
Abhinav Jangda
Greta Yorsh

abstract: Our aim is to enable software to take full advantage of the capabilities of emerging microprocessor designs without modifying the compiler.


title: Concept analysis in programming language research: done well it is all right

abstract: Programming language research is becoming method conscious. Rigorous mathematical or empirical evaluation is often demanded, which is a good thing. However, I argue in this essay that concept analysis is a legitimate research approach in programming languages, with important limitations. It can be used to sharpen vague concepts, and to expose distinctions that have previously been overlooked, but it does not demonstrate the superiority of one language design over another. Arguments and counter-arguments are essential to successful concept analysis, and such thoughtful conversations should be published more.


title: Some were meant for C: the endurance of an unmanageable language

abstract: The C language leads a double life: as an application programming language of yesteryear, perpetuated by circumstance; and as a systems programming language which remains a weapon of choice decades after its creation. This essay is a C programmer's reaction to the call to abandon ship. It questions several aspects commonly held to define the experience of using C; these include unsafety, undefined behaviour, and the motivation of performance. It argues all these are in fact inessential; rather, it traces C's ultimate strength to a communicative design which cannot be understood within the usual conception of "a programming language", but can be seen as the antithesis of so-called "managed" languages. This communicativity is understood as facilitating the essential aspect of system-building: creating parts which interact with other remote parts---being "alongside" not "within", and of "alien" origin.


title: Selfie and the basics

abstract: Imagine a world in which virtually everyone at least intuitively understands the fundamental principles of information and computation. However, computer science, in research and in education, is still a young field compared to others and lacks maturity despite the enormous demand created by information technology. To address the problem we would like to encourage everyone in the computer science community to go back to their favorite topic and identify the absolute basics that they feel are essential for understanding the topic. We present here our experience in trying to do just that with programming languages and runtime systems as our favorite topic. We argue that understanding the construction of their semantics and the self-referentiality involved in that is essential for understanding computer science. We have developed selfie, a tiny self-compiling C compiler, self-executing MIPS emulator, and self-hosting MIPS hypervisor all implemented in a single, self-contained file using a tiny subset of C. Selfie has become the foundation of our classes on the design and implementation of programming languages and runtime systems. Teaching selfie has also helped us identify some of the absolute basics that we feel are essential for understanding computer science in general.


title: ChimpCheck: property-based randomized test generation for interactive apps

authors:
Edmund S. L. Lam
Peilun Zhang
Bor-Yuh Evan Chang

abstract: We consider the problem of generating relevant execution traces to test rich interactive applications. Rich interactive applications, such as apps on mobile platforms, are complex stateful and often distributed systems where sufficiently exercising the app with user-interaction (UI) event sequences to expose defects is both hard and time-consuming. In particular, there is a fundamental tension between brute-force random UI exercising tools, which are fully-automated but offer low relevance, and UI test scripts, which are manual but offer high relevance. In this paper, we consider a middle way---enabling a seamless fusion of scripted and randomized UI testing. This fusion is prototyped in a testing tool called ChimpCheck for programming, generating, and executing property-based randomized test cases for Android apps. Our approach realizes this fusion by offering a high-level, embedded domain-specific language for defining custom generators of simulated user-interaction event sequences. What follows is a combinator library built on industrial strength frameworks for property-based testing (ScalaCheck) and Android testing (Android JUnit and Espresso) to implement property-based randomized testing for Android development. Driven by real, reported issues in open source Android apps, we show, through case studies, how ChimpCheck enables expressing effective testing patterns in a compact manner.


title: I¿¿¿: a calculus for internet of things automation

authors:
Julie L. Newcomb
Satish Chandra
Jean-Baptiste Jeannin
Cole Schlesinger
Manu Sridharan

abstract: Programmatically controllable home devices are proliferating, ranging from lights, locks, and motion sensors to smart refrigerators, televisions, and cameras, giving end users unprecedented control over their environment. New domain-specific languages are emerging to supplant general purpose programming platforms as a means for end users to configure home automation. These languages, based on event-condition-action (ECA) rules, have an appealing simplicity. But programmatic control lets users write programs with bugs, introducing the frustrations of software engineering with none of the tool support. The subtle semantics of the home automation domain---and the varying interfaces and implementation strategies that existing home automation platforms use---exacerbates the problem. In this work, we present the Internet of Things Automation (Iota) calculus, the first calculus for the domain of home automation. Iota models an ECA language equipped with first-class notions of time, state, and device aggregation, and comes equipped with a precise semantics inspired by a careful analysis of five existing home automation platforms. We show that the Iota calculus is useful by implementing two analyses from the software engineering literature, and expressive by encoding sixteen programs from these home automation platforms. Along the way, we highlight where the design of the Iota semantics rules out subtle classes of bugs.


title: Encoding the building blocks of communication

abstract: Distributed systems are often built from the simplest building blocks such as message sends and RPCs. Since many communication patterns have to be reinvented every time a distributed system is created, implementing a high-level system is usually expensive. The recently proposed reactor model alleviates this cost by expressing distributed computations as reusable components, however, encodings for various communications patterns in this model are missing.


title: Systems level liveness with extempore

authors:
Andrew Sorensen
Henry J. Gardner

abstract: Live programs can be modified while the program is executing in order to provide a more reactive experience for the programmer. In demanding applications, such programs traditionally utilise pre-defined function calls to compiled libraries. We present a system that enables demanding live programs to be built where the supporting stack of libraries is, itself, live. In such situations, the top level code might be thought of as a simple ``live environment'' that can be created live and that encapsulates code that has ``bubbled-up'' from the supporting libraries. Our system enables this bubbling up to be achieved in an ad-hoc way and with minimal performance penalty. The deep, systems-level liveness that it exhibits is described and compared with other approaches to Live Coding and liveness generally.


title: Replacing phrase structure grammar with dependency grammar in the design and implementation of programming languages

abstract: For decades, the design and implementation of programming languages has been based on phrase structure grammars, which divide a program recursively into phrases (represented by nonterminals), leaving the words of the program (the terminals) as the atoms of this division. By contrast, dependency grammar suggests that dependency between words, not constituency between phrases, is the primary grammatical relationship, and that a grammar capturing this relationship is basically a lexicon.


title: Generating chat bots from web API specifications

authors:
Mandana Vaziri
Louis Mandel
Avraham Shinnar
Jérôme Siméon
Martin Hirzel

abstract: Companies want to offer chat bots to their customers and employees which can answer questions, enable self-service, and showcase their products and services. Implementing and maintaining chat bots by hand costs time and money. Companies typically have web APIs for their services, which are often documented with an API specification. This paper presents a compiler that takes a web API specification written in Swagger and automatically generates a chat bot that helps the user make API calls. The generated bot is self-documenting, using descriptions from the API specification to answer help requests. Unfortunately, Swagger specifications are not always good enough to generate high-quality chat bots. This paper addresses this problem via a novel in-dialogue curation approach: the power user can improve the generated chat bot by interacting with it. The result is then saved back as an API specification. This paper reports on the design and implementation of the chat bot compiler, the in-dialogue curation, and working case studies.


title: Garbology: a study of how Java objects die

authors:
Raoul L. Veroy
Samuel Z. Guyer

abstract: In this paper we present a study of how Java programs dispose of objects. Unlike prior work on object demographics and lifetime patterns, our goal is to precisely characterize the actions that cause objects to become unreachable. We use a recently-developed tracing tool, called Elephant Tracks, which can localize object deaths within a specific method and tell us the proximal cause. Our analysis centers around garbage clusters: groups of connected objects that become unreachable at precisely the same time due to a single program action. We classify these clusters using traditional features, such as size, allocation site, and lifetime, and using new ones, such as death site and cause of death. We then use this knowledge about garbage clusters in a new GC algorithm: the Cluster Aware Garbage Collection (CAGC) algorithm.


title: Can we crowdsource language design?

authors:
Preston Tunnell Wilson
Justin Pombrio
Shriram Krishnamurthi

abstract: Most programming languages have been designed by committees or individuals. What happens if, instead, we throw open the design process and let lots of programmers weigh in on semantic choices? Will they avoid well-known mistakes like dynamic scope? What do they expect of aliasing? What kind of overloading behavior will they choose?


title: Error messages are classifiers: a process to design and evaluate error messages

authors:
John Wrenn
Shriram Krishnamurthi

abstract: This paper presents a lightweight process to guide error report authoring. We take the perspective that error reports are really classifiers of program information. They should therefore be subjected to the same measures as other classifiers (e.g., precision and recall). We formalize this perspective as a process for assessing error reports, describe our application of this process to an actual programming language, and present a preliminary study on the utility of the resulting error reports.


title: On the usage of pythonic idioms

authors:
Carol V. Alexandru
José J. Merchante
Sebastiano Panichella
Sebastian Proksch
Harald C. Gall
Gregorio Robles

abstract: Developers discuss software architecture and concrete source code implementations on a regular basis, be it on question-answering sites, online chats, mailing lists or face to face. In many cases, there is more than one way of solving a programming task. Which way is best may be decided based on case-specific circumstances and constraints, but also based on convention. Having strong conventions, and a common vocabulary to express them, simplifies communication and strengthens common understanding of software development problems and their solutions. While many programming ecosystems have a common vocabulary, Python's relationship to conventions and common language is a particularly pronounced. The "Zen of Python", a famous set of high-level coding conventions authored by Tim Peters, states "There should be one, and preferably only one, obvious way to do it". This 'one way to do it' is often referred to as the 'Pythonic' way: the ideal solution to a particular problem. Few other programming languages have coined a unique term to label the quality of craftsmanship gone into a software artifact. In this paper, we explore how Python developers understand the term 'Pythonic' by means of structured interviews, build a catalogue of 'pythonic idioms' gathered from literature, and conjecture on the effects of having a language-specific term for quality code, considering the potential it could hold for other programming languages and ecosystems. We find that while the term means different things to novice versus experienced Python developers, it encompasses not only concrete implementation, but a way of thinking — a culture — in general.