A new paradigm for programming is like a new genre in an art, akin to the “nonfiction novel” introduced by Truman Capote, postmodern poetry, and impressionism, cubism, and abstract expressionism in painting. The problem domain constrains what we want to talk about, and the paradigm domain constrains how we can say it.

We are talking about paradigms in the large, not small-scale paradigms like object-oriented, logic, or functional programming. We are talking about alternatives to the two governing metaphors of mainstream programming: program as text and software development as problem solving. Key concerns within these metaphors are correctness, productivity, (business) value-creation, and performance.

Programming accomplishes many different things—products, apps, science and engineering, learning, solving puzzles, uncovering mysteries, discovering and understanding, and supporting business. This has always been the case; but today we face a set of new issues and approaches for designing and developing software—some of these approaches are actually old but are now beginning to influence how we design and develop. Examples include the availability of big data; hardware systems that rely on software for reliability; AI and AI components; the need for autonomous systems; “app” and micro-service thinking; and the need to embrace legacy systems.

Whereas in the past we faced primarily the problem of requirements emerging from the design and code as they unfold or as slowly dawning insights into the problem and solution domains present themselves—a formidable problem that is not going away—now we also have unfamiliar realities adding to the fog of system making. This is the time for programming languages and development environments to step in to help.

The question of interest to us for this proposed workshop is how to frame this emerging paradigm to help us with problem setting, and which more narrowly focused areas in the new paradigm are ready for deeper exploration Unlike mainstream programming, we do not have strongly governing metaphors, which is why we use terms like “self-sustaining,” “live programming,” “exploratory programming,” and “extensible programming languages and environments” to point to the questions that interest us. Also, we are not sure whether we are talking about one paradigm or several.

Purely textual approaches focus on the abstract and thematic. Type correctness ensures only that thematic bugs are absent and that the form of the program is abstractly correct, but not that the program in fact does what is intended or needed. Proof of correctness ensures only that one view of the specifications agrees with another view. These guarantees are important but can disappoint when the notion of correctness is in flux or is not relevant. For example, is Google’s Go-playing program correct? It beats a lot of human players. Is a recommendation system correct? Is a software system that self-repairs correct? More troubling and surprising questions are beginning to arise: does a particular system have a “moral compass” (self-driving cars, for example), does it embody and thereby promote racism (various classifiers).

Live systems give the programmer a window into the concrete operation of the program. A program fragment that has been proven abstractly to be OK can be checked concretely. The chronology of the program can be observed, its intentions checked, and the problem domain (what the program is addressing) along with the paradigm details can be checked— both by direct human observation and by ad hoc, in situ testing. One way to look at it is that the program and human programmer are a symbiotic pair.

We observe that these two approaches—textual and live—are steps along a path which the new paradigms might extend in directions hard to envision at present.

We plan to compile a list of current alternative approaches to mainstream and exploratory programming; to create an annotated compendium of new approaches and paradigms; and to explore how such techniques might inform software engineering and mainstream software development. Moreover we will define governing metaphors to assist problem setting activities.

As preparation for the seminar we will gather in the form of short documents a set of existing and new ideas for approaches and paradigms along with any results associated with them. These approaches will be lightly evaluated and categorized to structure the actual seminar.

During the seminar we will explore these ideas with a series of micro-writers’ workshops to partition the approaches into two sets: one with approaches likely to succeed and the other interesting approaches. This will familiarize the participants with the ideas to consider, and will ensure that both risky and safe approaches are considered. During this phase, approaches not previously listed will be added to the sets. The writers’ workshop is a semi- formal, loosely directed discussion format similar to a Socratic dialog. It is used is some of the supporting workshops mentioned below, as well as in the software and design patterns conferences (PLoP conferences).

We will break into small groups to propose governing metaphors and to produce expanded documents describing each approach, where in the programming lifecycle the approach fits, what results have been gathered so far, the likely impact of the approach, and a set of questions the approach raises about programming in general.

The final outcome of the seminar will be a single document laying out the landscape of programming experience, programming environments, programming languages, and programming approaches within the new, large-scale paradigm.

The organizers have recently led a number of workshops on the topic of this proposal. These workshops were two Self-Sustaining Systems Workshops, four Future Programming Workshops, and four Programming Experience workshops (PX). Moreover, one of the organizers (Gabriel) created an earlier series of workshops collectively called “The Feyerabend Project,” holding eight workshops over a six-year period. To support publication of work in this area, he created a track at OOPSLA, which later became the ACM SIGPLAN Symposium on New Ideas in Programming and Reflections on Software (Onward!). To support publication of work in this new, larger paradigm, two of the organizers (Hirschfeld and Gabriel) created a new conference and associated journal: The Art, Science, and Engineering of Programming.

The list of invitees contains a mixture of people who have attended a workshop led by one of the organizers on the topic of this proposal (twenty, marked with [+]), people who have sent their students to such a workshop (one, marked with [-]), and newcomers (eleven).