https://futureofcoding.org/ logo
Join Slack
Powered by
is this silly?
# devlog-together
l
a
You know.
In a good way. :)
e
Makes me think of that older mathematical notation that used over bars in place of parentheses.
m
Also curious to know what was actually happening with the new variable there. Sparked some nice imagination for me!
m
not sure, but I can tell you it's not sand
l
@Mattia Fregola I love it!!!
i
@Mattia Fregola Holy crap! I was just talking to Lu (and the folks at Ink & Switch) about how I want it to be like this instead of having a separate blue bar and memory line. Nicely done!
Is this too silly?
If you can see the contents of memory, you don't need algebra anymore…
l
nice now this is getting closer to cellpond again the Line is forming, i can see it!
m
l
I love seeing these variations. the highlighting is great there's one small consideration i had: i wanted the 'state of the memory line' to change between the lines of code. kind of in 'continuous' space. i think there's a chance of confusion from seeing the change happen when it's at the same time as a line of code. Like... does the change happen before the line of code? or after it?
m
yup, lazy me not doing transitions (and admittedly not really understanding the details of what goes on here)
also for more context, is this part of something or is it just this? (so is there an overarching project / goal or just a way to visualise this)
m
💁🏽‍♂️🦋 is this malloc?
l
@Mattia Fregola no no, lazy me for hoping for other people to do it instead 😆 this is part of some experimental work i'm doing for my residency at ink & switch. the project is called SEE IT. or SEET. or THE LINE. or something. still figuring it out. very very very early stages. i wanted to make a little animated demo that would ellicit some early reactions and responses. the actual planned project looks nothing like this, but I'm carving out some core concepts, and 'trying them out' with people. the project is about being able to SEE your program's memory. I'm currently exploring the tension between seeing your program's actual memory VS seeing your mental model of the program's memory
It's going weirdly, because I don't find the project very compelling so far. but responses have been strong (both positive and negative). so that's interesting to me. Why is there this difference? Why are other people's reactions different to my own? I'm developing my own understanding of it
m
l
@Mariano Guerra thanks! this is great
m
sounds like a fun project @Lu Wilson! hope you’ll discover a more intriguing facet to it other than the meta. curious to see what comes out of it!
l
here's a recent zoom-out i wrote up for the project's status:
# SEE IT: Scope Explosion Feels like the project needs a zoom-out.
## Original research questions
Q1. Is seeing a line of memory good?
Q2. Why? Why not?
Q3. Is this kind of thing exclusive to spatial programming?
## Current answers
A3. No.
A1. There seems to be a strong desire for it. Source: Lots and lots and lots of people have tried. My list is growing. Need to analyse more, but there doesn't seem to be any consistency between approaches. Lots of different things have been tried but nothing has stuck (statement questionable - further research needed).
A2. Debugging code seems to be a sore spot. I didn't expect as strong a reaction from either 'camp'. This has happened to me in all communities - industry, research, casual. Seems like a lucrative area to keep prodding. Maybe some wins have been missed because of this tension.
## Current design
There are forces pulling the designs in different directions.
- How can we satisfy both the coder's mental model as well as the code's "mental" model?
- There's interest in more expressive power. But there's also interest in provocative simplicity, with great sacrifice.
## Future work
I can see three potential projects that spawn out of this.
- Provocatively simple step debugger.
- Puppeteering tool for representing a coder's mental model.
- One-dimensional memory viewer for creative coding or shader coding.
I'll switch to another project for a while while I decide on which direction to take. - move SEE IT project from active incubation to passive incubation. - move FRACTAL BUCKET project from passive incubation to active incubation.
m
An explorable explanation about memory allocation: https://samwho.dev/memory-allocation/
3 Views
Open in Slack
PreviousNext
Powered by