=Paper=
{{Paper
|id=Vol-3217/paper24
|storemode=property
|title=Conversation Starter: Imagining Autotelic IDEs
|pdfUrl=https://ceur-ws.org/Vol-3217/paper24.pdf
|volume=Vol-3217
|authors=Kate Compton
|dblpUrl=https://dblp.org/rec/conf/aiide/Compton21
}}
==Conversation Starter: Imagining Autotelic IDEs==
https://ceur-ws.org/Vol-3217/paper24.pdf
Conversation Starter: Imagining Autotelic IDEs
Kate Compton
Department of Computer Science
Northwestern University
Abstract When compared to writing code in a non-specialized
text editor and running it in a separate program (or via
We know what to expect from an IDE, right? We will type a command line), some IDEs can be more approach-
some code, the code will be executed, we will observe the out- able for novice users as they provide a single entry
put, and iterate as many times as needed. The IDE will assist
us in that goal with reliable syntax highlighting, code comple-
point to start programming. A novice user can down-
tion, and debugging tools, in order to be the most demure and load Processing[Reas and Fry2006], type some rudimentary
unobtrusive possible partner in our work. That’s exactly what Java, hit the play button, and see the results of their code,
we want when we want to get work done, but are there IDEs without needing to understand what a compiler or executable
that are themselves autotelic1 experiences? Can we imagine JAR files are. Processing’s interface, on starting up, contains
systems that extend or subvert traditional IDE abilities, creat- primarily a text editor, a play and pause button, and a console
ing IDEs that are playfully over-responsive, mysterious, gen- output window, which gives the user a clear hint that their
erative, or improvisational? primary activity loop will be typing code, pressing play, and
viewing the output.
We have many IDEs that are great for performing useful Noticing that coding has an edit-execute-observe
work and writing good, reliable, productive code. What hap- loop allows us to examine particular moments
pens if we let an IDE break free from productivity? Can we [Hutchins, Hollan, and Norman1985] in the loop where
consider an IDE as an autotelic experience in itself, rather there may be problems or opportunities, or even consider
than as a means to create useful code? This paper is a provo- the whole loop cycle as a way to ‘grok’ the possibility
cation to the community to consider not only IDEs for en- space of the program, or ‘grokloop’ [Compton2019]. For
tertainment, but IDEs as entertainment: example, Hutchins, Hollan, and Norman identify the “gulf
• What does is mean to make a non-productive IDE? of execution” (the moment where you must know both what
to input into your system, and how to input it) and “gulf
• What goals could an IDE have outside of productivity? of evaluation” (the moment you observe what the system
• What are the common features of an IDE that support pro- has responded with, and must understand what that output
ductivity goals? means). The faster we go around this loop, the faster we
can iterate on our programs, so many IDEs have features
• How can a non-productive/autotelic framing let us imag- that shorten one or the other of these gulfs, such as code
ine warping those tools in ways that were unthinkable in completion and syntax highlighting (gulf of execution)
a productivity-focused framing? and error logging with line numbers and variable tracking
(gulf of evaluation). REPLs (read–eval–print loop) are also
What do we expect from an IDE? available: these IDEs (often web-based IDEs) can re-run
An IDE (integrated development environment) is a bundle of code each time the user edits the code. If we can sufficiently
utilities that are useful for programming. Usually at a bare shorten the two gulfs and the time it takes to re-execute the
minimum, there is a place to write and edit code, and a way code, then the core loop of the IDE can start to feel like a
to run the code and view its output. They may have addi- continuous manipulation of the code.
tional features to specify how a program is compiled or ex-
ecuted, and features that can help organize and annotate the Speeding up the turtle
raw source code. LOGO [Papert2020] is a full programming language best re-
Copyright © 2021for this paper by its authors. Use permitted under membered for drawing generative spirals with turtles. When
Creative Commons License Attribution 4.0 International (CC BY you program in LOGO (or many of its copycats) you watch
4.0). the turtle painstakingly walk through its path. Papert thought
1
from the Greek “for its own purpose” that one could more easily understand the code by “playing
Turtle”, either watching it move or physically walking the also annotations, formatting, links and UI features. Are there
path yourself. But the gulf of evaluation for that paradigm is currently any systems where the IDE itself is given enough
painfully slow. Nicky Case’s “Joy.js” (https://ncase.me/joy/) agency to be surprising, or to have a character? Can an IDE
re-imagines LOGO as a continuously running REPL, but as have enough agency to feel like it is improvising with the
the user edits the code, the turtle’s path redraws itself in user, rather than acting as a transparent tool?
an instant. Not content with bridging the gulf of evaluation,
Joy.js also shortens the gulf of execution by replacing plain- IDEs with mystery
text code with sliders for numbers. The result: a user can Finally, there is a potential to also experiment with IDEs that
continuously update the program a dozen times in a second oppose or challenge the user. An example of this in a pro-
by sliding a slider and seeing the changes, which the side ductive framing would be teaching IDEs that provide a set
claims makes Joy.js “more creative, more alive” and “lets of tests that the user must write code to pass, as in the on-
you improvize, and discover ‘happy little accidents’”. line teaching apps Check.IO6 and CodeCombat7 . Normally,
Joy.js is one of many continuously-updating REPLs avail- the user of an IDE can program anything within the space
able, which also includes Tidal2 for generative audiovisual of the language. These IDEs subvert that by restricting what
experiences, Sonic PI3 for music and Shader.place4 for We- the user can program and when, or which syntax is accessi-
bGL shader code. All these IDEs focus on emergent genera- ble. If we consider an IDE as a way that we feed instructions
tive programming. One notable feature of generativity is that to a computer, we can consider games with antagonistic or
the eventual pattern that will emerge from an instruction is mysterious UIs like “The Gostak” (Muckenhoupt, 2001) and
hard to predict from the instruction itself. By shortening the “Mu Cartographer” (Millet, 2017) as playful IDEs.
grokloop, these IDEs allow the emergent pattern to change As we look forward towards a future filled with more
simultaneously with the code, without waiting, so that the machine-learning than we might want, we can also look at
user can playfully explore the space and enjoy the emergent interacting with machine-learned models as a form of IDE.
patterns, or even do so as a live performance (‘algorave’). To “program” with these models we must find a shared syn-
In the case of Shader.place, the code is also live-synced to tax that both model and the humans understand, referred to
multiple other players in a virtual room, who can all simul- as ‘prompt engineering’ [Gwern2020] or ‘prompt hacking’8 .
taneously edit the shader together. Though the code often This trial-and-error conversational programming often re-
breaks (shader code is very fragile) the code will recompile sembles an adventure game like “The Gostak” more than
as all the users are typing, and will continue to recompile un- a traditional IDE.
til it runs again. Continuous execution makes the chaos of a In conclusion, we will still need productivity-focused
multiperson shader-editor viable and even enjoyable, rather IDEs with which to write games and digital entertainment.
than frustrating. But let us imagine also a world where we make IDEs that
are generative, playful, and even mysteriously alien.
IDEs with agency
So far we have just talked about IDEs that assist the user References
to edit and execute code. But many IDEs will also play an [Compton2019] Compton, K. 2019. Casual creators:
active role in annotating or even writing code themselves. Defining a genre of autotelic creativity support systems.
Common ways that IDEs take an active role when coding University of California, Santa Cruz.
include:
[Gwern2020] Gwern, B. 2020. Gpt-3 creative fiction,
• detecting the syntax of parts of the code and coloring or https://www.gwern.net/gpt-3prompts-as-programming.
formatting it (syntax highlighting, auto-indentation) [Hutchins, Hollan, and Norman1985] Hutchins, E. L.; Hol-
• alerting the user to malformed, nonstandard code (linting) lan, J. D.; and Norman, D. A. 1985. Direct manipulation
• tracking how identifiers or variable names are used across interfaces. Human–computer interaction 1(4):311–338.
code to create clickable links, indexes of identifiers, or [Kreminski et al.2020] Kreminski, M.; Dickinson, M.; Os-
one-click renaming UIs born, J.; Summerville, A.; Mateas, M.; and Wardrip-
• identifying possible identifiers that could fit in the current Fruin, N. 2020. Germinate: A mixed-initiative casual
context (code completion) creator for rhetorical games. In Proceedings of the AAAI
Conference on Artificial Intelligence and Interactive Dig-
There are systems where an advanced AI autocompletes ital Entertainment, volume 16, 102–108.
user’s code while the users is writing code in a productivity-
focused environment5 , and systems where an advanced AI [Papert2020] Papert, S. A. 2020. Mindstorms: Children,
generates emergent new code that the user can inspect in computers, and powerful ideas. Basic books.
an autotelic tool[Kreminski et al.2020]. There seems to be [Reas and Fry2006] Reas, C., and Fry, B. 2006. Processing:
potential for autotelic systems to generate not only code, but programming for the media arts. Ai & Society 20(4):526–
538.
2
https://tidalcycles.org
3 6
https://sonic-pi.net/ https://checkio.org/
4 7
https://www.shader.place/ https://codecombat.com/
5 8
https://copilot.github.com/ https://twitter.com/ArYoMo/status/1399801016669835268