Channels
administrivia
announcements
bot-dark-forest
devlog-together
in-alberta
in-boston
in-germany
in-israel
in-london
in-nyc
in-ontario
in-seattle
in-sf
in-socal
introduce-yourself
linking-together
of-ai
of-end-user-programming
of-functional-programming
of-graphics
of-logic-programming
of-music
present-company
random-encounters
reading-together
share-your-work
thinking-together
two-minute-week
wormholes
Title
k
Kartik Agaram
10/12/2022, 5:05 PMI've been having an extended, multimodal conversation with @Jack Rusher over the course of 2022, culminating in a couple of in-person conversations in recent weeks. Watching his Strange Loop talk (https://futureofcoding.slack.com/archives/CCL5VVBAN/p1665503282267399) finally got something to click in my head, and I put 70 lines of Lua together for this demo. I'm also including the .love file for anyone to try out, which is just a zip file containing said 70 lines of code. Instructions for running it: https://love2d.org/wiki/Getting_Started
I can imagine driving this through Emacs or some other Slime-like interface (e.g. https://github.com/jpalardy/vim-slime)
j
Jack Rusher
10/12/2022, 6:38 PMhttps://media.giphy.com/media/jErnybNlfE1lm/giphy.gif▾
One of the big things about using a livecoding approach for GUI applications is that you can inspect and fix a problem in your running program while it is already in the faulty condition. The inverse of this is when you need ten clicks into some sub-menu to recreate the state every time you attempt a fix, which is both tedious and flow destroying. One guy who came up to me after my SL talk mentioned that while workin on a big commercial video game he had to play the game for 30 minutes each time to get back to the part he was trying to fix!
k
Kartik Agaram
10/12/2022, 7:08 PMI've been suffering from Blub here.
Me: you should take charge of your tools, automate whatever you can.
Also me: bah, all this IDE stuff takes too long to set up, it's brittle, keeps breaking on me, I'm just gonna print, because it's reliable and I always have it.
(Except wait, I can't even get print to work reliably anymore. That's good reason to shop around.)
w
wtaysom
10/13/2022, 6:59 AMI like to understand regular GUI interaction as taking a path through some state space. Then I can use all the equipment of state machines and parsers to represent (syntax) and analyze (semantics) behavior.
For the pragmatics, the trick is to reify both state (what is here right now) and transition (the steps to get here) so that you can swap between the two: integrate steps to get state, derive steps from states. If it takes 30 minutes to get to the buggy state, then you should be able to get a pointer to that state.
From there my thoughts revolve around making richly interactive systems tractable by explicitly separating more and less embellished versions and from managing the embellishment in a principled way. For example if you want to find bugs or at least glitches, try touching anything animated. The animation usually increases the number and variety of states in ways that are easy to overlook as a developer.
c
Chris Maughan
10/13/2022, 8:02 AMNow you just need to make Time a parameter, and you've got a live coding performance tool 🙂
w
wtaysom
10/13/2022, 2:12 PMYes, exchanging time for space is a good way to think about things. What is a "script" if not a written version of something that usually happens over time? Steps in a procedure or lines of dialog.
j
jamii
10/13/2022, 6:29 PMhttps://pernos.co/ is perhaps relevant. Once I hit the screwed up state, I want to ask how I got here.
k
Kartik Agaram
10/15/2022, 5:26 AMWhen I built this I wasn't sure LÖVE had a good way to recover from errors, but I think it can be done. I just need to call the event loop through an
xpcallnfoobarfoon-1barnfoon+1foon+1barnnfoon+1foon+1n-1n+1j
Jack Rusher
10/15/2022, 7:49 PM@Kartik Agaram What if the visible bindings are a projection over a graph where every node is a versioned fn? (as opposed to versioning at the program level)
k
Kartik Agaram
10/15/2022, 7:58 PMYes, that feels like a more concise rephrasing of my comment. All the file fiddling could be seen as implementation details. Does that seem right?
One difference potentially is that I'm imagining a single global version number rather than versions by binding. But that's probably also just an implementation detail.
Today I'm playing with two communicating LÖVE apps, a driver and the app being driven live[1]. Stdin/stdout doesn't work very well when it's a machine on the other end (and I want to support Windows). I spent some time trying out sockets, but that goes against the grain of Windows firewalling. Now I'm just using a file for communication.
[1] After I'm done somebody else can implement the driver within Emacs 😄 I want some amount of structured editing that feels faster to prototype in LÖVE.
Some initial ideas of the protocol between driver and app:
DEFINE name ...
DELETE name
GET name [n] (returns definition as of version n)
MANIFEST [n] (names with active bindings at version n)
TIMELINE [n] (returns say 10 most recent interactions before version n)
j
Jack Rusher
10/15/2022, 8:08 PMYou might want
COMPLETE symbol-fragmentk
Kartik Agaram
10/15/2022, 8:14 PMOh, you mean for typing in part of a name and autocompleting it in queries? 💡
Current state. The app started out on the right without a love.draw, and updated on the fly after I sent the code on the left.
Now I can focus on implementing the protocol and the on-disk representation.
j
Jack Rusher
10/15/2022, 10:38 PM@Kartik Agaram Yeah, for this sort of thing in the editor:
k
Kartik Agaram
10/17/2022, 12:13 AMError recovery is looking extremely promising. I spent an hour live-coding with my kids and didn't have to pop a terminal once. I hope to do a video in a few hours. Lines of code needed to be live:
• Driver: 118 (over a basic text editor)
• App: 400 (just the framework bits before the app does anything)
Ok, here's a take I spent too much time on. It shows too little, takes too long, etc., etc. But it shows the error flow I have so far. It's clear much more is possible: providing commands to undo the previous edit, inspect variables, etc. The top-level options Common Lisp provides on an error.
https://spectra.video/w/wkDB5fsjBNBbsqKXGhGzwT (video; 5 minutes)
(Many thanks to @Ivan Reese for showing me how to finally up the volume on my mic.)
k
Konrad Hinsen
10/17/2022, 7:40 AMThis looks very interesting, and promising. And got me interested in LÖVE. Is there any high-level overview of that framework? I'd like to know in particular what its limits are. You mentioned somewhere the requirement of short (in time) state update and drawing functions. That's good to have in anything interactive, so it's not much of an additional constraint. Any other important limitations? How much of the embedding system can LÖVE access? Files, apparently yes. Network, probably. But can I use the microphone of my Android phone, for example? It's not obvious to find answers to such questions in the various tutorials and reference manuals.
k
Kartik Agaram
10/17/2022, 8:19 AMI find it's pretty full featured! Here's the microphone on Android, for example: https://love2d.org/wiki/love.audio.getRecordingDevices
One limitation I've run into is lack of https support. That's coming in the next version, but could be 1-2 years away.
On the other hand you can always add libraries for yourself from the larger Lua eco-system. Https comes from luasec. I've been ignoring that option in favor of a download-and-done cross-platform experience, but it's pretty well-trodden ground. Maybe even on Android 😄
k
Konrad Hinsen
10/17/2022, 9:48 AMThanks for that summary and pointer! Integration of Lua libraries was another point I was wondering about. It's not obvious with a framework. Good to know it's an option, while not forgetting that this is the entrance to dependency hell.
j
Jack Rusher
10/17/2022, 4:31 PMI especially like the note about how little code it really takes to have a nice experience like this. 🙂
c
Chris Maughan
10/18/2022, 9:25 AMYou have certainly excited me about the idea of using LÖVE as a prototyping platform! Love how simply you managed to put this together (a lesson I often need to relearn)
k
Kartik Agaram
10/19/2022, 5:36 AMIf any of you would like to try it out (say for some coroutine experiments, ahem @wtaysom), I've packaged up the two sides into a single repo at https://codeberg.org/akkartik/20221018-live.love
w
wtaysom
10/19/2022, 6:25 AMHa! You've tricked me. I'll have to give it a try.
Coroutines work! Super dumb example, text extracted from screenshot. Seemed better than sending an image:
x=x+10
if x > 100 then
x= 10
end
silly = function()
return x
end
cosilly = coroutine.create(function()
local = 3
while true do
coroutine.yield(r)
coroutine.yield(r + 1)
coroutine.yield(r + 2)
coroutine.yield(r + 3)
coroutine.yield(r + 2)
coroutine.yield(r + 1)
r=r+0.1
if > 100 then
r=3
end
end
end)
on.draw = function()
color(1,1,1)
for i,c in ipairs(Circles) do
if i == 1 then
circ('fill', c.x, c.y, silly())
else
local status, radius = coroutine.resume(cosilly)
circ('fill', c.x, c.y, radius)
end
end
endxCirclesError: text.lua:86: attempt to index local 'line_cache' (a nil value)
stack traceback:
[love "boot.lua"]:345: in function '__index'
text.lua:86: in function 'populate_screen_line_starting_pos'
text.lua:583: in function 'pos_at_start_of_screen_line'
text.lua:409: in function 'up'
text.lua:318: in function 'keychord_pressed'
edit.lua:293: in function 'keychord_pressed'
keychord.lua:11: in function <keychord.lua:5>
app.lua:34: in function <app.lua:25>
[C]: in function 'xpcall'k
Kartik Agaram
10/19/2022, 7:51 PMThank you for those reports! The text is on disk btw. Let me start printing out the location on startup. You can also select text in the driver with shift + arrow keys and press ctrl+c to copy to clipboard
I putI don't follow this. Did you mean you tried creating a new definition forin withxas a way to track syntax errors since pressing F4 fails silently in that case.Circles
xmanifestI'm not able to get your code snippet running, so I'd love to get a snapshot of your save directory, maybe do a call with you about what you saw.
However, I can confirm that coroutines seem to work:
silly = coroutine.create(function()
while true do
coroutine.yield(love.math.random())
end
end)on.draw = function()
local _, r = coroutine.resume(silly)
local _, g = coroutine.resume(silly)
local _, b = coroutine.resume(silly)
color(r,g,b)
for _,c in ipairs(Circles) do
circ('fill', c.x, c.y, c.radius)
end
endw
wtaysom
10/20/2022, 5:11 AMYeah, why
xx