Future of Coding - Moving Beyond Syntax: Lessons from 20 Years of Blocks Programming in AgentSheets by Alexander Repenning

Episode Date: August 25, 2024

Alexander Repenning created AgentSheets, an environment to help kids develop computational thinking skills. It wrapped an unusual computational model with an even more unusual user interface. The result was divisive. It inspired so many other projects, whilst being rejected at every turn and failing to catch on the way Scratch later did. So in 2017, Repenning published this obit of a paper, Moving Beyond Syntax: Lessons from 20 Years of Blocks Programming in AgentSheets, which covers his findings over the years as AgentSheets evolved and transformed, and gives perspective on block-based programming, programming-by-example, agents / rule / rewrite systems, automata, and more. This is probably the most "normal" episode we've done in a while — we stay close to the text and un-clam many a thought-tickling pearl. I'm saying that sincerely now to throw you off our scent the next time we get totally lost in the weeds. I hear a clock ticking. Links $ Do you want to move beyond syntax? Frustrated by a lack of syntactic, semantic, or pragmatic support? Join our Patreon! Choose the tier that best reflects your personal vision of the future of coding. Get (frequently unhinged) monthly bonus content. Most of all: let us know that you enjoy this thing we do, and help us keep doing it for years to come. Argos, for our non-UK listeners. They were acquired by future TodePond sponsor, Sainsbury's. Once again, I am asking for your Marcel Goethals makes a lot of cool weird stuff and is a choice follow. Scratch isn't baby programming. Also, you should try this bizarre game Ivan programmed in 3 blocks of Scratch. Sandspiel Studio is a delightful block-based sand programming simulator automata environment. Here's a video of Lu and Max introducing it. Simple Made Easy, a seminal talk by Rich Hickey. Still hits, all these years later. Someday we'll do an episode on speech acts. Rewrite rules are one example of rewriting in computing. Lu's talk —and I quote— "at Cellpond", was actually at SPLASH, about Cellpond, and it's a good talk, about —and I quote— "actually, what if they didn't give up on rewrite rules at this point in history and what if they went further?" Oh yeah — Cellpond is cool. Here's a video showing you how it works. And here's a video studying how that video works. And here's a secret third thingthat bends into a half-dimension. Here's Repenning's "rule-bending" paper: Bending the Rules: Steps Toward Semantically Enriched Graphical Rewrite Rules I don't need to link to SimCity, right? You all know SimCity? Will Wright is, arguably, the #1 name in simulation games. Well, you might not have caught the fantastic article Model Metropolis that unpacks the (inadvertently?) libertarian ideology embodied within the design of its systems. I'd also be remiss not to link to Polygon's video (and the corresponding write-up), which lend a little more colour to the history. Couldn't find a good link to Blox Pascal, which appears in the paper Towards "Second Generation" Interactive, Graphical Programming Environments by Ephraim P. Glinert, which I also couldn't find a good link to. Projectional / Structural Editor. Here's a good one. Baba is You Vernacular Programmers Filling Typed Holes with Live GUIs is, AFAIK, the most current canonical reference for livelits. I'm not linking to Minecraft. But I will link to the Repeater 32 Checkboxes Wiremod is a… you know what, just watch this. Chomsky Hierarchy The Witness Ivan wrote a colorful Mastodon thread surveying the history of the Connection Machine. Harder Drive is a must-watch video by the inimitable Tom7. Also couldn't find a good link for TORTIS. :/ Programming by Example (PbE) Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo Alex Warth, one of the most lovely humans Ivan knows, is a real champion of "this, because that". Ivan's magnetic field simulations — Magnets! How do they work? Amit Patel's Red Blob Games, fantastic (fantastic!) explorable explanations that help you study various algorithms and techniques used in game development. Collaborative diffusion — "This article has multiple issues." Shaun Lebron, who you might know as the creator of Parinfer, made a game that interactively teaches you how the ghost AI works in Pac-Man. It's fun! Maxwell's Equations — specifically Gauss's law, which states that magnetic fields are solenoidal, meaning they have zero divergence at all points. University of Colorado Boulder has a collection of simulations called PhET. They're… mid, at least when compared to building your own simulation. For instance. Music featured in this episode: snot bubbles ! Send us email, share your ideas in the Slack, and catch us at these normal places: Ivan: Mastodon • Website Jimmy: Mastodon • Website Lu: Login • Website See you in the future! https://futureofcoding.org/episodes/073Support us on Patreon: https://www.patreon.com/futureofcodingSee omnystudio.com/listener for privacy information.

let's just say this episode today right here right now would be a great opportunity to do a clean break reset start over everybody's friends yeah all the beef that is going on between Ivan and Lou it's just wild you all don't see the half of it nothing has changed it's a sitcom nobody's on blast Ivan sent like a threatening message of biscuits like it was this weird image of biscuits that were just like super threatening and the thread on slack it was it's all wild i'm gonna rate that joke two out of five and i'm explicitly not using lou's uh star rating system the accursed three star rating system because uh it's bad oh i just use you know two i assume is the second best compared to one so i'm

i feel good about this joke guys i am not even keeping up with these in jokes and i'm one of the co-hosts way too meta this is all getting cut out i think the best way that we could have this conversation and make sure we resolve our differences is we all kind of make our own little script and we just follow it i exactly like we're like three different agents oh no this is a segway oh i thought it was not and then I thought it was and then I thought it wasn't no too soon actually we gotta keep this episode really short today

cause um cause I want to 5 hour episode anytime I have to keep an episode short he just wants to keep digging in on it that's fine because I have a new color of highlights in this uh and a new method of highlighting really whoa that will help with our keeping this short so i've mentioned my method for highlighting which is just swapping back and forth between

three colors green blue and yellow but i brought in the pin this time the pin tool not the highlighting tool and it's purple sorry how do you spell that word uh sorry so this is a thing that you're gonna that i is a fact about me i grew up in a part of america that has a southern dialect oh uh and southern dialects of american english don't make a distinction distinction between two sounds pen and pin uh they just uniformly make the one sound so my e's and i distinctions get smushed so which one was it have you been using the pen or the pen the pen so as in writing on a piece of paper not encircling the piece of paper with a boundary i intentionally

said i intentionally said that the way that people i thought about just saying it the way i would say it yeah which is those two words are identical in my dialect uh and so if you're listening to this listener and you're from the south and you've never realized this you're welcome um it was not fun when i realized that everyone else is saying words like ben and bin differently yeah i was gonna say is it mr franklin or is it the the uh pork and food yeah like to me those all i would just say ben for both of them and that the sound i make is kind of in the middle between the ben and the bin that's that's the that's the actual sound i make if i say them naturally but i try sound i make if i say them

naturally but i try to enunciate and say them all the weird ways that other people do so anyways i use the pen tool uh it's purple and it's just big x's all throughout lots of sections here so uh so this will help us and it's not it's not just to be clear it's not because i think this paper's bad it's because this is like the first paper we've done that i think really follows the like traditional academic formula yeah um where there's just sections that i i just don't think make great podcast even if they're relevant and important in the the broader academic world or whatever you want to argue for them i'm not trying to say that the the author did something bad here they're just following kind of the conventions of modern academia that i just don't think make great

podcast material not good for the film adaptation i mean the podcast adaptation right exactly exactly au contraire uh and i'm from canada so that's my uh quebecois oh for god's sake because i'm from western canada so my quebecois is uh terrible um those sections and i'm pretty sure i know what sections those are going to be will be interesting to talk about at a meta level there's some like you know hey this is our first paper that has this kind of stuff in it oh there are some some things we can think about about those sections being in papers that uh sorry this is going to be a short episode right see i i just this is what always happens i give some way of cutting out something in the content and then

ivan always brings it back in listen i brought back the uh some color coding um green means i like it uh pink means i like the aesthetic of it oh uh black is just like structural notes blue is oh this is interesting red means i don't like it and there was one like light blue i've forgotten what that one was so we'll find out all right so even though it's in the title of the episode, I'm sure, I always do like to make sure we say what it is we're doing because I don't always pay attention to titles of episodes when I click on stuff. And there's no way the full title of this paper is going to be the title of the episode.

It's super duper long. Yeah, yeah. Moving Beyond Syntex, colon, Lessons from 20 Years of Blocks Programming in Agent Sheets. By Alexander Reppening. Yeah, I intentionally skipped the name because it was like, how do I pronounce that last name? I should have planned this before I started talking. And why are we reading this one?

Why are we reading it? Because I said we should. And why did I say we should? Well, because I used this a lot. This was like my Bible when I was doing a lot of the spatial programming work I did. I think Marcel from Ink and Switch first pointed me to it. It's just this great summary.

It's like this signpost that points to a million other things. It was kind of fun looking through this, like, discovering all the things that we've talked about in various episodes. The paper has 120 references, and I had that same experience reading through it, where it's like, this is just like the, you know, SkyMall catalogue of concepts and projects and ideas. It's Argos. You know, i don't know what that is but for our uk listeners ah all right yeah so i don't know my experience with this paper

was very different because as i was reading through it i'll admit like i wasn't i wasn't getting it it didn't make sense to me what the point of this system was like i kind of you know i kind of know about it or whatever but it like i had a bunch of criticisms and problems and then we get to chapter six or section six the last section besides conclusions which is very short and it started all making sense and i just had wished that that section got moved up to the very front and had that been the first section i would have i would have had a totally different experience with this paper this is rich coming from the dude whose previous podcast episode didn't start talking about pig million until after the two hour mark wait you're blaming jimmy for that no i'm just saying

like we are so guilty of waiting until the very very last part of the episode to actually start talking about what the episode's about no big million had great introductions that it's exactly the opposite the point is i wanted them to talk about the meta stuff before they talk about the system just like pygmalion did i'm literally saying i wish the order was like the pygmalion paper of giving me some introduction right because section six does not talk about the actual tool it talks about its uses so it's the title is computational thinking tools yeah had i gotten this up front we'll talk Thinking Tools. And had I gotten this up front, we'll talk about it, but had I gotten this up front, it would have been more important to me.

So my strategy in this conversation is going to be to kind of get that out there from the beginning. Because I do think it's really important that this is not supposed to be a programming tool. It's supposed to be a computational thinking tool. And that is very different from what i was coming into this thinking so two notes on that one i found an interesting uh analog of that darn it that was inadvertent of that pattern but at a smaller scale where um i often found the final sentence of each paragraph was a great uh like not like

a summary but like a like a topic sentence whereas i'm used to you know or in each section rather sorry not each paragraph but like the final sentence of each section was like a great sort of like here's what this section is going to talk about kind of sentence whereas i'm much more used to oh you put that sentence at the beginning of the section so you know what the upcoming section is going to be about and then your final sentence is like bridging to the next section so that's yeah just to give you like a flavor of this because i i completely agree like the end of section one ends with section seven concludes the paper and that that was a great boy you think like skip ahead oh my god no no right i was just trying to find and the very first thing i find is oh yeah the

last sentence section seven concludes the paper it was true it was foreshadowing right you you didn't see it coming but like they told you to twist up front yeah yeah you gotta wait like here's an example the the final sentence from section six is the main point of this section is to suggest a new research direction and to illustrate the concept with a concrete starting point that is a like hey here's what this section is about to talk about kind of sentence not a yeah there's lots of there's lots of like good self-contained quotes right to pull out yeah um and i'm not going to find an example because this is a short episode and i and i want to say what the premise of this paper is right like so the the premise of this paper

have we earned it uh yes uh no haven't we suffered enough is my answer haven't we suffered enough we haven't talked about the first page the first page aesthetically uh yeah we have to talk about the first page okay it's an okay first let me know no no i i'm just messing we can actually talk about the paper let's hear the let's hear the premise here well the premise is this is like a a look back like a walk through history of 20 years and actually 25 years of Alexander Reppening's career with working with Bloch's programming. And actually like the what came before Bloch's programming as well. And what I really like about this paper is that it's actually quite personal, right? Like it's actually walking through some of his

thinking, some of his mistakes, some of the like challenges along the way. You know, like it strikes me as more personal than what I'm used to reading. Like he says like, hey, I was fascinated by the affordances of spreadsheets, right? Like it's written in first person in a lot of places, right? Like it's in 1989, sorry. In 1988, as a beginning PhD student, I was in charge of helping scientists use the connection machine, etc, etc. It's like, it almost reads like a CV at times. But like, I find this really useful because it gives me so much context

about like why certain things ended up the way the way they were. Why did he change from this? Like, why did he change from rewrite rules to blocks? And he explained some of the limitations of, of rewrite rules that he found, right? So yeah, that's the premise. And when we say block programming, obviously, we're going to hash this out more. But just to give people, you know, a starting point here, we're talking about Scratch. These are puzzle piece kind of blocks that you can move around instead of writing with text. So obviously there's more nuance to it than that,

since there's 20 years of history and we can talk about all of that. But just to make sure you kind of know where we're coming from. You can kind of drag around blocks of code and you you're not typing in text you're kind of putting them together as puzzle pieces or something like that yeah and the blocks can be different um like there's no prescriptive definition of like the blocks have to be at this level of granularity like a block like if has to be a block or plus has to be a block you can have blocks that are like ah this entire you know little subroutine is represented as a block or um uh or this one half of a number is a block yeah well i was gonna say i haven't seen any systems where you're like

putting together words with individual blocks for each letter but then uh we just did a bonus episode about baba is you where in fact that is one of the things you do yeah uh yeah patreon.com slash future of coding listen that's the premise but he also has a goal or some goals, right? And I quote, My aim in this paper is to strongly encourage blocks programming researchers to shift away from syntactic towards semantic and pragmatic programming challenges. Right. And these are like the three sort of recurring concepts. I mean, there's a number of recurring concepts, but I would say these are three three

of the main ones syntax semantics and pragmatics or pragmaticism or something right pragmatics yeah pragmatics so this and this is a sort of um these three things pertain to, um, ways in which you can have supports in a programming environment that's like support the programmer in, in, in doing their programming work. They relate to aspects of the language design. Um, and they are sort of like a,

like almost like, um, a hierarchy, like, like, you know, tears of a pyramid or like nesting dolls or something like that for, um, what what like how

narrowly the you know a feature or something like that might be focused on like just getting the program to work at all which is your like syntax versus zooming all the way out to helping the user ultimately achieve some goal that they have which is like the pragmatic end of the spectrum and so it's this these three terms syntactic semantic and pragmatic are used to sort of um bucket various ideas and say like oh hey is this an idea that's focused on the very fine grained like even getting the program to run getting the compiler to chew through it um you know constructing a correct program in the first place versus you know the much more zoomed out like are you helping the user discover what it is that they want to do

and express themselves in a much more high level kind of way there's there's one other thing i want to pull out from the introduction section as well is that the context for this it opens with talking about how accessible computing and computer science is to everyone particularly like this cites a report by google about why women tend to not like pursue computer science work and study. And that study cites things like women not getting enough social encouragement or thinking that they can't do it. It talks more widely about making computing and coding more accessible to kids from a diverse background. And I just want to draw out that this is a great framing

and it really heavily contrasts with like some other papers that we've seen. You know, this is just something small, but I think it's important to just commend that and say it's super easy to do. I think it's important that we read this first paragraph because I think this is kind of the crux of the paper and kind of the whole goal of this research.

I'm really bad at reading long paragraphs, so I haven't... May I? Yes, please. Reading? Okay, great. The first paragraph of the paper, Moving Beyond Syntax, Lessons from 20 Years of Blocks Programming in Agencies. Section 1, Introduction.

Programming is hard and boring. The statement, programming is hard and boring, made by a young girl when asked what she was thinking about programming approximately 20 years ago, does not suggest a workable trade-off, but instead a heartbreaking lose-lose proposition. Disappointingly, a recent report by Google exploring why women do not choose computer science as a field of study listed the top two adjectives describing women's perception of programming as hard and boring. These persisting concerns can be interpreted as a two-dimensional research space called the Cognitive Effective Challenges Computer Science Education space. The quote hard part is a cognitive challenge requiring programming to become more accessible. The quote boring part is an effective challenge requiring programming to become more

exciting. In other words, the big question is how does one transform hard and boring into accessible and exciting? Just because you picked on my pronunciation, it's affective when you're talking about affect. What did I say? Affect? Like you just said affective, like as in like to affect a change or whatever, but it's affect as in. Oh no, you mean effective. Yeah, yeah. It's yeah it's effective versus effective no affect in this case put these foolish something to rest you mean it's affect versus effect as opposed to effect versus effect there's three different ways of pronouncing this word yes is it affective effective or effect yeah and i'm saying it's affective in this case because it's talking

about affect as in like your emotion now enough enough sort of thing right so what would the what would the uh affect twin be yeah yeah yeah yeah so if you had more than one of them would they be the affects twins i just make i just wanted to make it clear because like it might not be clear from the reading that this is about the affect right this is about emotions it's about the way in which we react to these things so i okay i want to put out my caveat that i completely agree that programming should be more accessible um and i completely agree it should be more exciting what i find this paper so we have this statement and i and when we put it in this these terms i think you know making programming more accessible making it more exciting is great. But we also have a graph here, and the graph is about, we have on the x-axis boring and exciting being the two extremes, right?

And that's the affective part. And then we have a y-axis, and it's the cognitive access, and it's hard and easy. And then we have this line of a path, and there's compute prime numbers, C++, Emacs being hard and boring. And then there's the holy grail of CS education with this little dot and a little holy grail. And it is both easy and exciting. Now, this is my maybe a little bit nitpick, but I do actually think it really matters for me personally. I think saying accessible versus hard,

that's a fine contrast. Saying that the holy grail should be that programming is easy, I just find, or computer science computer science i guess in this technical case here i just find not quite the right phrasing right i mean i i think it's possible to misinterpret this phrasing as it is so so i think i can see what you're you're getting at and i wanted to say this as well like when this example this example is taken, right, of like, say, a young girl finding or saying that programming is hard and boring. That doesn't mean that like, that person or, or children in general, find programming hard and boring. It's just that their experiences of it have made them say that. Exactly. I agree with you.

I think kids all love hard things. Like, they like challenges, right? It's just that there's unnecessary challenges in their way, which is why I love the accessibility point. That you made, yes. Yeah, it's like, it can be hard and accessible, right? But it's about, like, the framing of it, right? So like, you know, like we live in a society that's telling kids and telling women and telling people from who are outside the norm of what computer science means that they're being told messages like you can't do this, this is too hard, right? So it's about flipping that around and saying, sure, this might be hard, but let's make it accessible. Like, I like this quote here in this in the introduction, that frames it around, like, how can we get kids programming in ways that they enjoy and in ways that they, that they will be, they will stop

thinking about how hard it is and start thinking about, like, if it's something they want to do and want to, like, pursue, right? And I i quote but what if kids could program games robots and maybe even simulations a key to overcome effective challenges and that's a effective challenges right and broaden participation with respect to gender and ethnicity is the support of creativity, ownership, and social computing. I am starved. I am starved for this kind of comment, right? Like, I want to see more stuff like this. This is really, really exciting to me, the fact that the whole thing is framed like this from the start. Yeah, and I want to be clear here that partially, maybe in some ways, I'm playing devil's advocate. And in other ways, I do think that this can sometimes, I don't think this paper does this,

but I think some people hear these kinds of statements and they think that what's being said is like, well, if you did find programming hard and you did find computing prime numbers exciting, then you are somehow wrong like you know i started programming as a kid and like the very reason i wanted to program was because my brother got a book on flash and he wanted to learn flash to do animations but the book was about programming and he said this is so hard it's's just impossible. Nobody could do this. That was like, oh my gosh, I have to learn this. If this is

so hard, nobody can do it, and my older brother said that, then I have to learn programming. The things that were exciting to me, I did not enjoy Flash. I did not want to do animations. I did not like things that let me do little simulations or little games i wanted to get down as as much where i felt like i was like doing

something not designed for kids right anything i saw that was designed for kids like just made me feel like a kid and i didn't want to do it and so like i i don't think that this is what this paper is saying is that you know oh if you found this stuff hard and that excited you that it's wrong or that we can't, that kids don't want something challenging and hard and something they have to work for. They just want something that they can get instantly. But I think that that's why I was, I was sad to see that the diagram didn't keep that accessibility versus hard. Because I think if those are opposites rather than easy, I think it makes the message better here, right? Like the point is not kids can't be challenged and they can't try to learn new things. The point is sometimes we dress up programming in ways that are artificially hard, where the hard things about the programming is not the computational thinking.

It's not about getting the computer to actually have a program that does what the kids wanted it to do from the beginning it's all sorts of things that like kids aren't great at like paying attention to a semicolon at the end of a line that now breaks your whole entire program that's the kind of artificial hardness that we don't need right because in the text it makes this distinction between hard and accessible but then in the figure it actually kind of switches it to hard and easy right it doesn't yes yeah i didn't notice that but it doesn't quite match up does it and i would say as well that like um i know like lots of people you're like yourself included would find say i don't know prime number challenges exciting, right?

But this is about reaching more people. Like there are plenty of people who already find it accessible. It's about making it accessible to people who like typically find themselves facing more barriers when trying to get into computer science. Agreed. And I think we need to open up those barriers. And it's not like research like this somehow deletes all prime

numbers and now you're no longer allowed to do prime number calculation if you find that exciting. But I wish it did. But I think that that's sometimes the discourse here. I think that sometimes the discourse here is like it kind of gets, yeah, but it kind of gets squashed where people think like, oh, they're saying kids can't learn

Python. they have to have a system like this and i just you know i think that that's not at all the point of this paper yeah i and i do want to touch on that briefly and this is something that steve actually touched on in some past episodes of the show steve and it's come up in a bunch of different places but it doesn't come up in this paper so i want to talk about this very briefly there's there is a tension where when kids are presented with something like scratch and they are used to seeing programming that looks like javascript or whatever they see the environment that's designed for kids with the cartoon graphics and the blocks and the you know mouse based interface and they reject it as

being like baby programming and they don't want to do baby programming they want to do real programming like they want to make real games they want to make you know cool stuff the way they see adults doing it and there's a lot of like perception issues to overcome when making a tool accessible in a way that you know would appeal and be useful to kids and yeah a lot of people have gone wrong by saying the way to make programming approachable for kids is to still have the you know pointer arithmetic but just do it with balloon animals or whatever um that's that's that's the i would say the wrong approach i'm in um yeah yeah of course yeah yeah for expert programmers balloon animal pointer arithmetic sounds like a great time um yeah like there's a there's a balance to be struck there and i think this like

ease versus accessibility is is a great like relevant facet of that and it's curious to me that uh uh alex didn't talk about that at all in this paper about that like like he does talk about a bunch of things that he found over the 20 years of you know using agent sheets with large groups of kids and and teachers and um it's fun funny to me that there was not a section talking about like oh yeah certain kids would reject it because it didn't feel like real programming and there's probably some some interesting lessons there about framing like if they weren't being presented with this thing as though it was programming if they were just presented with this thing as though it's like a creative environment and they just so happen to learn programming as they do it which gets down to some of the stuff we'll talk about when we get into computational thinking tools like that might

have been a good way to dodge the issue of people you know kids especially saying well this isn't real programming i don't want to do this and there's one other way in which that that failure mode is relevant which is when we're making our future of coding tools, we're making our weird coding experiments, we're making our visual programming environments or our novel editors, there's a flavor of the, well, I can't use this in my React app, so I'm not gonna kind of objection, which is, is well this isn't like the real programming that i do for my job so it doesn't have relevance to me there's a there's a you know when you see something that's too foreign or or you know too detached from the status quo you know a professional programmer will reject it as not being real programming the same way a kid would so i think there's some interesting lessons there that right are outside of what this paper talks about yeah this is this is why he actually started uh like

bringing this tool to children right like it was originally intended for scientists you know and it's and it and i quote the target audience of agent sheets had shifted from scientists to children. The main reason for the shift was that the exploration of the cognition of computing required untainted minds. The untainted minds of children did not reject this as fake programming. I think, and from all of the examples given, like there were lots of little anecdotes of like children being forced to leave the lab and they didn't want to leave because they wanted to make their games, you know. And the sort of impression I get is, like, there's a class of kids. They tell them, hey, do you want to make a simulation in a game? And the response seems to be pretty good.

I guess, like, with things like Scr things like scratch like i think there's so much difficulty with aesthetic like there's a real you know what's the meme you know like hey fellow kids how do you do fellow kids what and like looking at some of these screenshots and stuff it's almost like aesthetic lust right it's it kind of like, and I mean this with... No, no, no, no. Ivan's giving me a funny look. Right. I mean this with warmth in my heart.

It's like programmer design, right? Like it's kind of just very functional. Like you look at something like Scratch nowadays and it's much more like, I don't know, child-friendly looking. A lot of the time I noticed these things going wrong because the aesthetic is what an adult thinks a child would like when we were making sandersville studio we which is a block-based programming environment um we just made it intentionally shitty so it didn't look like we were trying to be cool

it was kind of yeah i think it worked i don't know i think i have to admit i know alan k kind of has a similar line about you know looking at kids because they have untainted minds and that kind of stuff i just find this to be such a cop out like i i just i don't buy it i don't buy it in the slightest like i i think that people always make this comment that like oh well programmers are just so biased and they don't want change i i don't think that's true it's not universally true but it is a very common experience that people have when trying to champion deviations from the status quo so there's something there yes of course whether we have pinned the fault correctly or not

is a great thing to debate. At the same time, people constantly complain about, oh, JavaScript's ecosystem changes every five minutes. So there's something here that is, yes, people are complaining about something real, I get it, that people won't uptake their tools, that's what they're complaining about, but they're blaming people's resistance to change because their minds are tainted in some way,

when really they haven't done the job they need to do to convince people that this is worth their time and effort. And you don't have to convince kids that it's worth their time and effort because they're being sat in a classroom and they have to use it yeah right right like like me this like i just realized like how biased i am to like this i like this is why i cannot like genuinely answer like or give my view on that because for me this is the this is how i learned programming right like this kind of system is how i was taught to program and then my mind got tainted by by alexander repining and then when i went to like javascript and stuff then i rejected that because that was the weird one

you know what i mean and then all my life has been trying to restore programming to what i grew up with and one day i will do it i took the words right out of my mouth that is that is yes extremely relatable i would it's weird i would not be the least bit surprised to learn because i think steve crouse had a similar kind of experience right i would not be surprised to learn that there's like a a strong undercurrent of folks in our community who just so happen to have you know a couple of i was going to name specific computers but i don't want to date myself it happened to have some some weirdo kid focused programming software in their in their school computer lab and that's how they first started playing around with programming and then learning java or whatever it was as their first real language and all you know text-based programming since then has felt like a crime

because it is yeah except for you jimmy no no j Jimmy's fine. I didn't do any of these things. You didn't. That's why you are the way you are. This explains so much. But the thing is, I'm open to these things, right? That's what I'm saying. But it's because of people taking the time to actually try to convince rather than just repeating the mantras over and over again that like, well, all these adults don't get it,

so I'm not even going to try to explain it. I'm going to like well all these adults don't get it so i'm not even going to try to explain it i'm going to shift to or programmers don't get it so i'm going to shift to not programmers or adults don't get it so i'm going to shift to kids i i just don't think this is healthy discourse that's why i'm interested in this podcast right is because we actually can dive in and find out the the edges of where this stuff is good it's why i think like functional programming started to have a comeback or whatever is because people stopped just saying functional programming is just better for you take your vitamins right and started like actually giving reasons for why they liked functional programming i don't buy that argument. I don't think that had any relation

to why functional programming took off. I mean, I think, how not? There's so many talks that were influential in converting people to a functional mindset. I mean, the obvious one being Simple Made Easy by Rich Hickey. Right, but that talk was backed up by the fact that there was this brand new functional language on the scene that was designed with modern sensibilities

rather than just like i think programming languages are also arguments for what when they're done well yeah for how this is a new way of doing it so i think that's you know i don't think that's antithetical to what i'm saying speech Speech acts as speech acts, if you would. Yeah, yeah. These systems that people all try to do, and when they don't convince adults, I think the wrong lesson to take from that is adults' minds are tainted and to say instead, what have I failed to do to convince adult programmers?

And how could I convince them? Yeah. Speaking of programming languages can i just say that i think agent talk agent talk a agent orc like agentic no like it's just such a terrible name for a programming language right like it's leaving off that extra t yeah right it's not agent talk it's agent talk with a capital t it's like small talk or real talk and i i think those are terrible names anyway like just drop the talk like i i small this is my programming language small no no this is my programming

language real drop the drop the talk it's cleaner and then drop the reel and then make something better drop the book just face listen it's just an aesthetic thing anything that's like javascript like two things i just it's just bad like lisp is that's great loo that's great come on this is great like that's a great name uh-huh all of your languages would just be called sand no listen this comes i say this because i regret it toad i regret it right like dragon that's a great name nogon great space toad terrible right dream bird is fine because it's parodying the bad ones i already made anyway okay so what is agent sheets a what is agent talk uh yeah agent talk yes agent so we kind of start off with some early experiments that were more like spreadsheet ish and the idea was this grid of agents this is

why these all have these concept of agents agents you can think of like objects but that kind of have a life of their own right you're thinking of thinking of it like simulations. You have a car or the frog or the ghost in Pac-Man. Like these are all kinds of, you know, examples and they all have their own little behavior and they kind of act in parallel in this whole simulation. So every agent kind of gets its own turn to go run or whatever, but it all kind of happens simultaneously. That's kind of like the big system here. Everything is about, one, simulation, and two, massively parallel. Whether the computer actually implements it as parallel or not

is a different question, but semantically, that's what's happening. Independent might be a, yeah, semantically parallel. Yeah, yeah. These are like each thing in its own cell runs in its own, you know, runs in its own way. Yeah. Independently of the things around it. Aware of them, but not like beholden to them.

It's a silly little automaton, right? Yeah. Essentially, it's a form. It's like maybe an asynchronous one, but it is. And a lot of these early experiments involved rewrite rules, like before and after pictures, where, you know, you have a picture before, a picture afterwards, and the simulation then sort of makes a while, it got abandoned. And I can tell you why.

And I quote, While it had become tremendously simple to get started, you know, with the rewrite rule approach, this approach essentially dead-ended at a certain level of project complexity. When users were trying to do more than just having agents move around and change their appearance graphical rewrite rules were powerful powerful enough to create very basic games or animations but my original goal was to create a framework that could also be used for more sophisticated games and simulations. Graphical rewrite rules fell short of this vision. And this is what my

talk at Cellpond was about. It was about actually what if they didn't give up on rewrite rules at this point in history and what if they went further. There's another paper called Rule Bending something or other where there's a real brief paragraph about rotation and symmetry and i quote the application of these transformations i assume is there a missing s here is that a typo there's tons of typos in this paper right so maybe but you're reading a different paper yeah also by by the same person so maybe the application of these transformations to entire situations consisting of complex objects is less obvious. And that was basically the end of that.

And I feel like there is an alternate reality of history where they did try to pursue rotations and symmetries more than just in a theoretical land, and they ended up with something like cell pond and i don't know maybe we'd be either in dystopia or utopia right now so just to give a an example of like what we mean by these symmetries and rewrite rules and stuff imagine you're trying to make a sim city style game and you have you want to lay out some streets and you want to have cars go on them you can do a very simple thing of you know

having a little if then like well if you see a uh a car on the road and there's open road to the right move the car to the right so it's like if you see the car move the car but this can be generalized to not just moving to the right but moving to the left moving up moving down to making corners etc right so this is kind of these symmetries and in fact it seems that they go as far as to like you can just draw one street and they'll give you all of the different permutations of that street so it could be a t it could be a curve it could be left right up down etc um and so like a kid only has to go and draw one road and now they can kind of get all the possible road configurations going on right which is pretty neat it's pretty neat and i but the thing is i think it started to get quite

complicated right just to make these very specific um like cases work like a car moving along a track or a train sorry no a car moving along a road or a train moving along a track and allowing them to like share that code it got really complicated and it felt unsatisfying because i think it kind of felt like these specific cases were kind of hard coded you know like these things uh these systems were built to support a lot of like movement but i don't know if you wanted to take this to other kinds of simulation you're a bit stuck and that's why rewrite rules basically ended there that's that's cool i didn't actually um put those two things together yeah like that Like that feeling of, you know, hey, this pattern works well

for things moving along a path. But if you want to do something more, I don't know, applied to a different domain or different kinds of motion or like, oh, what if you wanted to do like ripples in a pond, right? Like circular expanding ripples where a pond right like circular expanding

ripples where they like reflect off of things or have interference patterns like this um you know specialization on motion along a path might not help you all that much with with that or so that is what i spent like freaking three four years of my life trying to do with cell pond right um yeah sincerely did that how how how did that go like did you find that there was more ground to be gained from rewrite rules i mean i could go i could go for hours on this but i won't but like there was there's a few like key uh solutions um one of them is so like the problem with rotations is that you typically have the concept of like the agent like what is in charge of the rule um in cell pond there is no like it's not object oriented it's more pattern matching so you don't get so much weirdness with

rotations um another thing is that there is like this concept of like conservation in cell pond. So that like, results are less chaotic, you can write simpler rules. And it's kind of similar to like, generics in like TypeScript or something. That's basically what cell pond does. And it does it automatically like in most languages that support generics you have to like specify that something is a generic but in a visual programming system like that's harder because it's really abstract so basically cellpond does it automatically based on pattern matching and it saves you a lot of time and you can turn it instead of having to turn it on you can choose to turn it off and that is something that i've just basically completely failed to explain ever so don't worry

if you don't understand i'm still working on explaining it yeah and this this failure in alex's mind here alexander i don't know uh but like this failure here was what led to blocks being the thing so you know this failure of rewrite rules in his mind to generalize to all of these situations was how we ended up getting blocks introduced into agent sheets so uh it was borrowed from Blocks Pascal, B-L-O-X, which is just the right way to spell blocks, B-L-O-X. So Blocks Pascal had this puzzle piece scratch idea before, and this is where this idea came from. It was borrowed to try to overcome this limit of visual rewrite rules.

Yeah, and I think that's really exciting. I had no idea that this is where block-based coding came from until like a couple years well i probably like a year ago year and a half ago and uh like i think a lot of people are very familiar with scratch and block-based coding but they might not know that it came from from this right i don't know i think i think that's pretty cool yeah and so we move on from the rewrite rules we get into blocks and we have this like whole section section three on like the four key affordances for block programming yeah and alex says like it makes sense to identify a minimal set of affordances that need to be provided in order to be considered a modern blocks programming

system so these are the like criteria for what makes a blocks language number one blocks are end user composable the description of this is basically that you can drag and drop manipulate blocks around to put them together into you know different things like a sequence or like a hierarchy of you know things inside of each of the branches of an if it can be two-dimensional or 3d if you have some vr environment or something like that some kind of minecraft style interface where you're putting blocks together there must be some kind of scaffolding mechanism to make sure that the way that you're putting the blocks together is correct like you're making these syntactically correct programs so in that way block editors are probably the most popular version of a projectional or a structural editor

where you are only allowed to make syntactically valid programs um because there's you know you can stick them together basically yeah yeah you can stick them together in the right way which i'm i read this and i go like as opposed to what like how do you have a blocks language that has some of the other qualities but not this exactly that's his point right that's his point yeah but you couldn't have a block sign language without the syntactically correct part if you just had all squares you can just put them anywhere aka bob is you yes yes bob is you does not require syntactic structures we talked about this and it's so good wait a minute but we did say that it's good didn't we we? But it's good, actually. But that's also, right, right, right.

But later on, Alexander is going more into, maybe there's too much emphasis on this syntactic correctness. Well, yeah, that it's like we need to treat that as a baseline and keep going, not just treat that as the final be-all, end-all. Number two, blocks are end user editable so this i'm rereading this one because i didn't i didn't understand this one when i do either of you get this one actually i prefer the term vernacular programmers so all this means is you can put type in values or pick a color or whatever the block isn't just static you could put a number five

or you could drop a picture on it or you could pick a color or yeah give it a name or whatever yeah we gotta unpack this one because it's saying like oh you could have a color block but it lets you pop up a color picker to pick which color that color block represents yeah so there's a little bit of that kind of like these are widgets or kind of like live lits is another project in this space doing this kind of thing that these blocks aren't just a rectangle with a word in them that they can have some some more affordances um as a result of them being a visual thing that you manipulate with your mouse say um there's there's some interesting maybe conflation here um between like blocks as a a way of representing like a command or an instruction with a little bit of parametrization and blocks as a like an agent or a house of state

that i feel creeps in a little bit with this this one that there's like oh yeah if these blocks are not just representing like a source for a program but are actually representing you know um things that that those parameters that they hold could be changed by other blocks at runtime or something like that there's a there might be a little bit there that uh that creeps in with this one that makes me a little uncomfortable i don't think you have to allow them to be runtime editable for this criteria here like again i'll think of minecraft and you have a repeater and it has an editableness to it, which is

how long the delay is on your repeater. You just right-click on it and it adds more delay or less delay or whatever. That meets this criteria. But there's no... You can't change that delay other than by blocking it by putting a redstone signal

to the side. If you haven't played Minecraft, sorry. If you haven't programmed in Minecraft. Done redstone in Minecraft. My point is it has some editability, but there's no runtime feature to that. I don't think this requires that. I don't know why. I'll be honest, this criteria seems criteria seems you could replace all of those things with just like to me it doesn't seem like it's a necessary

requirement here because imagine you have a color picker but instead of it being in the block it has a hole that you have to drop a color in i think think that would count. Yeah. Right. But if all your blocks were that way and they only had the syntactical composition rather than editable state, this seems either unnecessary or just a restatement of the previous one. So point number one is saying, hey, if you're going to do a good job of blocks,

at least make sure that they offer syntactic support you could in theory make a block like language that doesn't offer syntactic support like help the user construct correct programs but why would you because that's you know you're not fulfilling that would be terrible you're not fulfilling the promise of blocks number two is saying yeah this is a modern you're number two is saying you're in a visual environment you're using the mouse presumably to manipulate stuff or at the very least you're concerned with the affordances of manipulating these blocks if you're going to do that at least have the good grace to let people manipulate values concretely in a in a like you know a format appropriate way

don't just make them type in the color as like an RGB triple with numbers, right? Like make it so that you can type in color, you know, R colon 255G, whatever. At least give them a color picker. That's what this is saying. It's like, like have the decency. Come on, come on, come on, come on. And then number three is that blocks can be nested to represent tree structures.

Yeah, as opposed to what? I don't know. Exactly. Baba is you does not have tree structures. It doesn't have if. It doesn't have loops. Those things emerge from the dynamics. Yes, and so Baba is you does not meet this criteria

because they can't be composed recursively into tree structures to contain blocks which in turn may contain more blocks i mean if you are writing like assembly code with a block based language you wouldn't need the tree structure you just need two types of blocks a zero and a one and then you just put them together and you have six 32 of them you just need 32 check boxes right 32 blocks uh no no no check boxes um yeah so i i think this is you know i get it at the same time this is why i yeah this rule sucks you're just recreating textual programming but with blocks yeah like this rule sucks because it's basically saying the only thing that we're interested in here is is a very particular prescriptive version of what

a blocks language is no longer is it meant to be like the first two are nice because they're about like at least have the decency to support the user this one's like hey at least conform to our norms like the the thing that they could say which would be absurd is like in order to be a visual programming language or like a like a good block language you have to have the blocks like touching each other you couldn't use like a wire to connect them or something like that that would make them look at number four number four blocks are arranged geometrically to define syntax the semantics of block combinations emerges from where blocks are connected by having the blocks touch each other directly or be placed in particular positions relative to one another rather than being linked indirectly by additional explicit graphical connectors like lines bullshit what sucks no i i'm so mad wait it's like no no

so why matt why are you mad okay so devil's advocacy like why why they think that this is a good thing is that the um there's this question about like what is it that lets you read the program how do you read the program do you read it by the geometric arrangement of these blocks like like putting them together like bricks in a wall so that there's some kind of like clear sequence that you read through them or do you read them by following this kind of like graph topology where any one of these blocks can have, you know, lines possibly fanning out to many other blocks. And there is likely to be a nonlinear, like less approachable way of reading the program. that like especially since this is an environment for kids not scientists that that doing the thing where you connect the blocks with lines does make it harder to follow what the program does especially if you go off the deep end in that direction um and it is an interesting way of like

separating these things into different categories where it's like oh yeah the blocks touching each other gives you room for affordances like jigsaw puzzle pieces to represent different syntactic rules so they don't have to touch each other right like they it says or be placed in particular positions relative to one another it just means that it can't they can't be like agnostically placed you can't just chuck them anywhere and then connect them up with like wires. And I think this is fine. Like it's, you know, if you want to do that, good for you, Matt. But like it ain't block based. It ain't block based.

Yeah, I think that's the real reading here is that not that they're saying it's bad, although there's definitely statements other places that say, you know, these lines are bad. But this is just saying it's not a block-based programming language at this point. It's a visual programming language, but they want to make sure that they separate blocks programming as a mere synonym for visual programming. Yes. So I think that's really the distinction here. As soon as you're doing this now, again, to use my Minecraft example, Minecraft only has blocks blocks but it also

connects blocks with redstone wires which are also blocks right right yeah that's so they have to be connected and they are connected with blocks right there's just some blocks that only serve the role of a connection that are wires but if you ever used wire mod in gary's mod right then it was just like arbitrary wires you can just attach them anywhere there's like no collision they don't take up any space you know that is not block based coding for the one or two people who played that played gary's mod wire mod i'm gonna use uh editor's privilege which in this case means that I was editing our previous episode yesterday and have in mind all the context of stuff we talked about in that episode.

Oh. And I'm going to throw back to in that episode, I can't remember which one of us it was. I think it was Lou. That's how good my memory is. Why don't you tell us what it is we might know was saying like i hate how all these papers do this thing where they say this isn't visual programming this is graphic i'm pretty sure it was lou probably this isn't you know such and such

thing yeah oh no yeah this isn't a programming language. This is a programming system. Yes, exactly that. And so what this paragraph here is saying is it's saying those other styles of visual language with the pearls on strings or whatever it is, those aren't visual programming in the blocks style. Those are visual programming in some other style. It's that category um sort of what's excluded what's included which i am 100 here for but but like the the thing that i like here is that alexander repining is calling these things for what they are he says they are languages he says blocks languages and he compares them to visual languages. And I think it's weird when people try and deny that these are languages. It feels like, hey, don't worry. Don't worry.

It's not a language. Don't worry. You don't have to use a program. Well, the reason these end up becoming, I think, definitively languages is because of three. Blocks can be nested to represent tree structures, and there's this recursive structure. This is part of the definitions that we get for languages. So in many ways, number three is just reinforcing the fact

that these have to be languages. Whereas I would agree, I think, withivan's idea of hest is not really quite making a language it's making a system uh how so i don't understand just take it i want to but i actually want to learn from jimmy here yeah yeah so if you take point one that there's this or sorry yeah point one where there's this uh idea that they have to be draggable and there have to be kind of this syntactically correct structures that get put into them right that you can only connect up certain things and then you take three where it's this recursive tree structure you get just a new rule which says blocks have to have a grammar.

That is what those two things are saying. There's syntactically correct ways of putting them together, and they form a tree-like structure. And that's exactly what we think of. That's what, you know, if you go with Chomsky's language hierarchies and all of that stuff, you know, formal ways of thinking about language, that's what natural languages do as well, right? We have this grammar of what parts can go where, and they form this recursive tree when you parse them. And that's what these rules are saying.

And that's why I disagree with this premise, because this strict adherence to this grammar view of language, I think, is what I disagree with. And I state that code language is, it's about transmitting something that gets something done. And you can do that in HEST, but it just looks very different. But listen, I understand people think differently, but that's why I say that this is a wonderful space that we're in where it's like what we're doing right now is trying to determine what do we mean when we say language and right you should read my conditionally accepted essay that me and

dave put together i want to but somebody has not sent it to me on back channel yeah i would say where have i been sent this? Well, listen, we're going to have to edit it and stuff. We're going to have to edit it. Yeah. I can get a preprint. But I don't know that I would say just communicating is quite right for me, at least, in what I would think of as a language. So if we think of a painting, I think paintings communicate.

If we think of a Dada happening, you know, these art exhibitions where someone does something, I can think of all of these as, you know, things that communicate, but that do it without language. Or if we think of, you know, somebody teaching somebody to make a fire without ever speaking, right? It's this kind of mimicry, and you kind of watch somebody and you learn how to make a fire which we did pretty linguistically like that just doesn't feel quite like language to me so what you're saying is there's a there's a video game that somebody could make where you could communicate a whole bunch of things without using i intentionally kept off where my references were

coming from there and you had to bring in the witness disgusting from jonathan blow disgusting filthy i intentionally i knew i've been new the fire example comes from jonathan blow i had to say otherwise otherwise it wouldn't make sense when i put it in our show notes for this episode. Listen, you're just going to have to reference me if it gets accepted. It's that, like, body language, right? Body language is a language that we speak. We have, like, a visual language that we use when we make paintings. There is a design language that we we use in games right like i think that we

should embrace that when we talk about code and because it will allow us to just like freely explore some of these other um like affordances available to us i would agree that these things can rise to languages because we can parse them out into grammars and we can start making sense of the conventional parts that we use and why we use certain things. But I think in and of themselves, that's kind of a meta framework put on them, that we can start seeing conventional things

that culture helps us create. They kind of become a language over time because that's just how we, I think, linguistic humans like to structure everything. I just think in and of themselves, they aren't language in and of themselves in their raw forms. We just start layering on more and more conventional aspects. So yeah, I mean, I agree. I think Ivan's being a little pretentious not wanting to call it a language he just wants it to sound cooler that's the real

signal here i wasn't gonna say it and then we get i wasn't gonna say it and then we get like richard gabriel who distinguishes between language being the static thing and system being a living thing right that's why he wants to call it a system versus a language, because it has this runtime behavior, and the actual behavior is separate from the code, because you could have an image that does these things, and the code for that image doesn't exist anymore.

You can't think of it as a programming language. It's got to be a programming system. I think there's uses of it. I think Ivan's just trying to signal that he's different and cooler. I'm going to ignore that and respond instead to something you were getting at earlier which is i think that it's a an accident of history that oh my god that the use of the word language to describe the thing that we make when we make a program like that that that thing has so much overlap with language that we use for human to

human communication and the study of linguistics and those sorts of things like if we had instead embraced ways of programming computers that were not about creating these sort of grammatical constructions or this stuff that fits that definition of language that were closer to the meaning of language when we say body language, or these things that aren't about parsing and grammar and that are more just about expression and sort of a looser sense. We wouldn't have to make this distinction. But because programming has this history of being about a particular meaning of language, not the full breadth that that word can be applied to but a specific notion of that

word we have to have this debate where we say some things are a language in the broader sense but not in the narrower sense and so yeah this this uh this whatever this programming language that i'm working on is called um see there i'm back to not referring to it hest no no no no the witness it's uh it's a great game you should play it there's there's a paper about this that's like how programming became language we have to keep this episode short you guys this is too i'm trying to remember what the paper is though guys but we should do it whilst you're remembering he's doing that what's lou doing right now i i i want to say that okay so i think that we need to see code in terms of like code transmissions right like when we make code do something we're transmitting some code which is like language in in a large sense and it has an execution and it does something, right?

So like that's pretty clear, I think, when it's like, say, a compiled language, right? You like transmit some code. It executes into something else. And then maybe that has an effect. Or maybe that turns into something else that then gets interpreted and and gets executed and has an effect right i think it's more helpful to talk about code in terms of transmissions and executions code does nothing by itself right like it just

sits there like language just sits there it's by language, by transmitting and executing it, that it does something. So like with HEST, right, or with agent sheets, you're interacting with this system as a form of transmitting code, right? Like in agent sheets, you know, there's a back and forth, you can make new rules or, like, drag together blocks. And when you click run, then you're going to transmit that, and it's going to do something. I think this is something we've got to read more papers on. Like, what the kind of, like I said,

there is a paper on this topic that I just cannot think of. I thought it was Tomasz Petrczyk, but it's not. Anyways, or Stephen Kell, but it's also not. It seemed like the people who would write these papers. But like, I think that this is a topic where we really need to dive into what is a language, how are programming languages languages. I think this is just, I love this topic. I think it's really fun. I think you're're right that one big function of languages is communication and i think that that's really important i just am not sure that i completely go into anything that communicates is a language that would be my only point of

disagreement shall we move on all right i have something that i wanted to get into at the beginning of the paper and we didn't get into it we skipped over it and now seems like as good a time as any to take us back to the beginning of the paper oh no i gotta keep this episode short hurry up um i have a a giant paragraph highlighted in green on page two. And it is a paragraph where Alex Repning. Repning. Repning. Repning.

Alex. Hold on. How are you pronouncing that E in Repning? Oh, I thought you meant Alex. It definitely sounds like an E to me than an sound i'm saying i'm saying repning two syllables i put a little uh apostrophe in there repning okay repping got it good to know um i'm just gonna read this whole paragraph with a with a big shit-eating grin on my face in 1988 as a beginning phd student i was in charge of helping scientists use the connection machine an intriguing looking

massively parallel supercomputer with up to 65 536 cpus connected up as a 12 dimensional hypercube this this thing the connection machine i did a mastodon thread about this the other day you've been going viral uh it did well um this thing is amazing i have always loved the connection machine it is iconic it's this like beautiful looking five foot by five foot by five foot cube black made up of like smaller sort of you know these eight smaller cubes put together to make this big cube and on one of the faces it has these kind of arrays of leds so it's got this like streaming red cyberpunk-y looking led stuff on the front of this very stark black cube it's a beautiful beautiful industrial design for a computer and the other night i had insomnia and i was up at 3 a.m and i was like i want to go learn more about how this thing actually worked like what what was it right it's this five computer. It's like in the mini-computer era, presumably.

It's smaller than like a big mainframe, maybe, but like bigger than a desk PC. And so I went and I watched like an architecture talk about how it was engineered and what the programming model for it was and what's the deal with this 12-dimensional hypercube stuff. And this thing is so cool it's this massively parallel array of thousands of processors originally each of them storing just like a single bit worth of memory to operate on at a time there's this way that the you know if you imagined it like a three-dimensional lattice structure of data where each of the little cells of the machine could communicate with their neighbors that would just be a three-dimensional cube like lattice arrangement but instead what they did is they had

each of the little cells of the machine wired up to more than just its immediate neighbors and that's how you get the 12-dimensional hypercubiness of it so it's just a way of saying any individual processor can reach out and talk to not just its immediate neighbors but some more detached neighbors as well and all of the processors would do instructions in lockstep and they could like look at the data that was in their neighbors and because it was all fixed wire networking they would do these tricks like there's this sort of like intricate routing system that you could use to get data at a distance and they could do things like start transmitting some data along one of these fixed wires and be routing that data around and making decisions about what to do with the data even

before all the data had been put on the wire is one thing or they could put some data onto a wire and while that data is in flight put the next value on the same wire and you could have up to three values in flight on these fixed wire networks at the same time using the wires as an extra storage layer you could store extra data just in transit because these are all one bit processors they don't have a lot of storage so it's like let's just use data in flight which is like um if you've seen the tom 7 video yeah harder drives where he uses dns as a as a hard drive yeah it's like that but in practice yeah yeah these these machines were made by like a tiny team of people it was just like a couple of

you know like a the company was co-founded by an mit grad and and hired a bunch of other kids i think they were like maybe you know like 10 people or so at this company when they started actually designing and engineering these things just a tiny little team like we're gonna buy a bunch of hardware and wire them together and make these supercomputers that are like totally different from what other computers were like at the era they were like massively data parallel leaned hard into simd were sort of like the ultimate machine for doing cellular automata style calculations at least up until you know t2 tile and maybe some more recent things are are would be a better fit for doing uh cellular automata but uh for the time it was like you know just the the coolest little quirk of history and unfortunately the company uh died off uh after

about a decade and uh and are now relegated to the dustbin of history. But I love these things. And I love that this was the starting point for agent sheets, was, you know, Reppening as a PhD student was in charge of helping scientists use this connection machine, right? And started trying to build things that would work in that model. And that's what agent sheets came out of. I thoroughly enjoyed this love letter and like i don't know i ship it yeah and they made their own lisp they made star lisp and this

this uh this reppening paper talks about star lisp a bit more which is this weird lisp variant that you'd use to tap into this weird programming model for the now that is a good name yeah starlisp is a good name unlike agent talk agent talk agentic yeah because if you if you slur agent talk it sounds like you're saying agentic which i like i i i ship that i don't think that's intentional yeah but i'm sure his name's not intentionally supposed to be pronounced rip no pig million yeah a million of them yes yes the millionth yeah that's that's a great start yeah related work there's this whole section that we're not going to talk about in the interest of time uh where i just went through basically like highlighting e-toys scratch blocky pig million

prograph database like there's so many like so many great names of things in here so many references at the same time the meta point here is they do exactly what every academic paper does which is here's this other work here's why it's not as good as mine. Here's where it differs, interestingly. There were actually, I found, in all seriousness, I see your joke, I acknowledge your joke, your joke is acknowledged. That's funny.

Pat him on the back. But there are actually bits in here where they point to other tools and say, like, here's how it differs in a way that makes me want to go learn more about that thing. Like TORTIS. T-O-r-t-i-s all caps snot bubbles that use this like card system for you know controlling a like they they have this like slot machine or something where there's these plastic cards and you the cards can be considered this is a quote the cards can be considered blocks in the sense that they represent program instructions such as move forward or turn.

Tortoise featured blocks that can be composed physically that have a limited sense of nesting, as in cards could not contain other cards, but a card could be a placeholder for another box containing more cards. And the sequence of program steps was determined by their geometry. It's like, I want to go see what this is. Like a little physical card thing. That seems super um yeah yeah loved this section okay but you know what like there is a way that it differs i think from from many other papers this is chronological right and the whole like framing and premise of this paper is that it's like a walkthrough history and i think this is really helpful like as someone trying to like understand, like why certain things were done or weren't done or was changed or was stopped, right? This is really helpful, like as a researcher in the future

of coding space. One of those is, it draws attention to when there was a change from representing semantics in the shapes of blocks to representing syntax with the shapes of blocks you know like we're now very used to that with scratch you know like but but it wasn't always like that and it changed so that's really interesting and another interesting part is he says that programming by example lost momentum for whatever reason. What does he say? Right, I have a quote. Perhaps due to the perception that modern blocks programming languages

are already highly accessible, programming by example research appears to have lost some momentum, particularly for educational applications, right? So part of the benefit of programming by example is that it's highly accessible. appears to have lost some momentum, particularly for educational applications, right? So like, part of the benefit of programming by example is that it's highly accessible. But block based coding is already highly accessible. So there was less interest in programming by example. So like, I don't know, like, from my point of view, right, if I want to go and do some programming by example work, right, it's helpful to know that actually, no, it still can be really good for some stuff.

It's just there was less of a need to. And that's the kind of information I took to go work more on this rewrite rules work. It wasn't that they discovered that it was bad or that they couldn't figure out how to do it it's just that more attention or or like there were some issues but they weren't investigated any further because attention went to block-based coding which means that there was like i don't know like very treasured right there was actually things to discover there and i think this indicates that programming by example potentially there's work to do there i think there's there's absolutely work to do in pbe yeah it's it's funny to see that looking back like from a from a modern perspective on

blocks versus everything pbe well yeah but specifically those two and saying like oh you know blocks kind of won out because it seemed perhaps like blocks were more promising or they solved more problems or they were easier to get right and PBE was hard and nuanced and underexplored. And so it's like, well, okay, let's put more effort behind blocks and kind of leave PBE behind. And it's like, it feels sort of like some hill climbing was done and that's why blocks won but the i'm trying to avoid using the word topology because we're

already using that to talk about graph programming versus block programming but um there's like if you went back to pbe and started exploring there you'd probably find oh actually the overlap between that and blocks is is only very limited and and there's lots of potential other things you can do with PVE other than just solve the syntactic things, sort of the most basic level of support that they both offer. I think blocks won because they're just the worst is better solution. Yeah. Programming, by example, is much more of the right thing,

and you have to like kind of solve these much harder problems of figuring out what did people mean etc whereas blocks you can just take any programming language and make a block version of it in a mechanical way it has a grammar but you can take that grammar and say those are the block shapes shapes. You can now start doing types by putting little things. It's just trivial to do. And I think that's why this won out. Any programming language can be translated into a blocks thing. Well, any textual programming language that has a...

Any sentential text-based programming language. I'm fine with... I think my qualifier was fine you could say some system couldn't be but any programming language could be converted to a blocks-based programming language could you white space in a blocks-based programming language yeah sure i think it would lose something because the whole point of white space is that you you don't have those affordances we'll do a short episode he. We'll do a short episode, he said. We'll do a short episode. White blocks that you can't see where they are.

And they're all the same shape. Yeah. You still can do it. Don't make me do this. I don't think it would be useful, but it's just the editor, right? That's the thing. Blocks are just an editor. Wait a second.

They are not a language really themselves. In Jimmymy's terms is hest a programming language i don't know because it doesn't exist doesn't exist can a language exactly can there be a language if it doesn't straightforwardly translate a non-existent programming language into a blocks language a non-existent one maybe um yeah this section's good uh jimmy what did you want to talk about in this section the whole entire four yeah i i have it all marked out i said that was the only thing i want to say is it's all just a thing of saying these are i mean really it goes through all the affordances right and says these don't do these affordances or not i set him up so well he had such a good opportunity there be like nothing section five here we go yeah yeah so

section five section five is shifting focus to semantics and pragmatic obstacles i i do have a beef no no this is the good part beyond A beyond beef. Beyond meat. Beef, thank you. A beyond beef. Beef bath and beyond. Thing here, right? What is it? I, okay. So let me give what the point here is.

Well, okay, okay. We've done this whole blocks programming thing, and guess what? It's worked really well. Blocks make it so that you don't have these syntactic errors that you would have in a text-based programming thing, which really helps make programming more accessible. But it's not all the way there. Just because we've solved one problem doesn't mean we've solved the whole entire thing. And we get this kind of analogy.

It's like saying, oh, well, what about spellcheck? You know, spellcheck helps us make sure we get spellcheck and grammar checking help overcome these syntactic obstacles. And so haven't we solved writing? Doesn't it mean now anyone can go write anything that would be the analogy of if you think blocks programming solves all the problems and alexander wants to say no we should focus on building more tools that focus on the semantics and the pragmatics which we'll get into what pragmatics means in this case it do you guys agree that let me start there you agree that that's kind of the thrust here have i properly represented the the idea i yes i agree i would only add that just to be too clear about this what he's what what alex is saying is some would say that the syntactic assistance offered by block programming and other

similar tools is sufficient and he does not think it is sufficient he thinks that that's good it's good that we got that but don't stop there and don't conflate the ways that blocks work with that syntactic level assistance that there's more two blocks than just the aid that they give with syntax yeah so he lays out this and he kind of gives a more like concluding statement of like the point and i'll quote here in other words uh sorry this is about talking about how spell check is not enough, right? And he tries to, just like blocks programming, solving the syntactic issues are not enough. So he says, in other words, if I would instruct a user to go ahead and write a best-selling novel now that you have spellcheck, most people would agree that spellcheck, as a syntactic affordance, provides essentially no support towards this ambitious goal. The same holds true for block programming. With the syntactic challenges essentially being resolved,

it is becoming urgent to dramatically shift research agendas to focus on the much harder semantic and pragmatic levels of programming languages. So what could we do instead? What could we do that's better? This is my point. I think that is the most non-secular I've ever heard in my life. Think about the analogy here. You have spellcheck. Great.

You can't write the great novel. What do we do? We make tools so that anyone can write a great novel. No, that's not at all what we do. And that's the argument here we've solved a syntactic problem so therefore we should make tools so that everyone can make a great program i i that it doesn't make any sense to me what's the analogy here what is the tool that helps you write a great novel right i mean i can think of some. There is an extent to which it's a bad example, a bad analogy,

because, yeah, there's no technical tools that are meant to help you be a better writer, but there are tools that are meant to help you be a better writer. Those things exist. They're not technical tools. They're not tools that I can put in the little cup of pens on my desk but they they do exist i think we're hang on hang on there are there are rules of thumb there are guidelines there are things that help you there are workshops community groups libraries there are of course you know but that's not the kind of tools we're talking about here we're

talking about constitutive right that's why it's a bad analogy that make it the case that you will do something just like blocks make it the case that you do syntactic really correct things yeah or spell check right there's no spell check in the real world either and i would say it's it's very likely that ai tools one of the valuable applications that they will have is to well if they if they fulfill their promise which it's a entirely different question as to whether or not they will let me hope not but one of the things that they could potentially do is serve as a what was the term you were using jimmy constitutive tool yeah uh which i love that term i've never heard that term before but uh i love it probably incorrectly um but we can do a whole thing on rules and constitutive rules which is not this great philosophy stuff we can totally do this

cool i i want to disagree with your point in a different way yeah yeah let's all disagree with jim i accept i accept the fact that there is no tool there is there is no tool uh for yeah writing a novel right writing a great novel but i don't think that's the point that he's making he's not making that the point that it's it's equivalent in that way he's just making uh the point that we are wrong to expect that having this syntax help from blocks is going to help us beyond that and to be fair i think i do sometimes see that and i i think this is like a fab criticism of loads of projects in the like the future of coding space in visual programming languages in general they focus so much on syntax and there is like an assumption that that will improve programming on the whole and i agree with him that it's not and like i think it is an open question right like

is there a potential real tool can't remember what that long word was real tool that helps us with semantics and pragmatics maybe there's not you know like it's never gonna happen but like i think he's putting forwards his idea of one that does that you know well i think that that's the problem is that to me like my criticism here is that there are these tools they do exist and what they do like okay so let's separate two the semantic and the pragmatic right because i i don't know about that term and how he's using it we can talk about it because he repeats it a lot that's why i know what he means right i'm not sure that i agree with it being super important sure the semantic question is just baked into the system right like yes you can give tool tips of like how, what it means, and you can help people

understand the semantics. But what ultimately we're doing and what is recommended here is to make it so that there is a built-in semantics that is the right semantics, right? It is the one that will help kids. And by right, I don't mean there's only one right answer, but it's one that will help kids do the kinds of things the system is supposed to do. I think that this is why I'm saying, I understand that it's an analogy, but I think the analogy is so bad that it's so misleading to me. Because what you don't want to say is, and now we're going to make sure that all kids' novels mean the same thing. They are good semantically

because we somehow made a tool that makes sure there's good meaning to those novels. And I think this is the problem. This is not just a nitpick about a metaphor. This is the problem I have with these systems is what they, and I think we can find some agreement that this is what they do

in the next section after this, or I think it's the next section, but next major section, is they limit the semantic range of expressiveness. No, I'm going to strongly disagree with that. I mean, I don't think Alexander Reppening does, because we'll find some quotes that I know you disagree with about general purpose programming language but not what this paper says i i and the exact implementation of these uh you know um semantic and pragmatic support tools is you know that's one thing but like what uh semantic and especially pragmatic support means and and other examples that we can point to in the world of like how those things are are realized i think it is not the way that you're characterizing it where it's like oh let's make all programs mean the same thing that's not what it's advocating for in the same way that like spell checking doesn't work by saying let's just make sure all words are spelled the same i.e

they're the same word buffalo buffalo buffalo buffalo buffalo buffalo yeah of course i didn't mean it in that silly way i meant come on i meant that you can't for example like the way these systems work you you're you're working in parallel with these agents and there is no way to break out of that system i can't say oh i don't want parallel semantics here i don't want to have agents i want a sequential steps of thing yeah i want sequential steps like that yes maybe it would be possible to try to hack the system to do that but if i I could, I doubt it, that's not what I'm being offered, right?

I'm being offered one semantic, which is all parallel semantics, which are told to me to be better. Well, yeah, once again, I don't know that the exact implementation in agent sheets is the thing that's interesting here. I'm still... Yeah, I don't, I'm not saying that either.

I'm saying all of these systems choose a semantic and enforce it so that kids don't make mistakes no i don't i disagree with that because there are other ways of getting semantic assistance than just something where it's like we're going to put you in a particular paradigm and the paradigm is the thing that's giving you the semantic assistance okay i don't think any of these kid-based programming languages do that uh well so here's what i want to point to which is one place where we see syntactic support run rampant is in static type checking and especially the more extreme versions of that where you have that culture and the corresponding backlash which i'm aware of but i'll get there in a second where it's like uh it took me you know forever to get my program to even compile but once it compiled it ran perfectly no bugs and the counter argument to that is yeah you spent so long getting this thing to be

built that what you actually built doesn't solve the problem that you intended for it to build like you went through such a protracted experience just to get software to run and that kept you at arm's length from understanding is the thing you're building actually addressing the real need you have in the world as opposed to the creators need an immediate connection with their creators view of the world which is you want to be running the thing constantly you want to be live you want to be in the moment with the thing you're making so that you can respond to it not at the level of i want a you know sequential sequence of instructions versus i want a grid of agents level which is very much like incidental complexity but rather i'm reacting to this

thing in an artistic way i'm reacting to this thing in an artistic way i'm reacting to this thing in a you know focused on business case or focused on like what's the what's the hole that i want to put in the wall not which drill bit am i choosing kind of way and i think that that thrust of inquiry about having an immediate connection is pragmatic support i'm not sure i see that at all from this text. I think you're going, like, I'm just saying, like, I don't think that's what these words mean in this text. I'm not disagreeing with any of the things you just said.

It just seems like we've totally changed topics from what this paper is talking about. Well, shall we have a look at what he says? Like, I think we need to see what uh alexander's like recommendations are for improving semantic and pragmatic support but have we do we actually need to like talk about like what what is it what does he really mean i think i think we probably have an understanding of what he means by semantic support have we talked about pragmatic support we danced around it a little bit we've danced around i we should talk

about this yeah pragmatic i'll quote because this quote gets brought up like 12 times for the rest of this paper um it just keeps getting repeated i wanted to almost considered starting this podcast being like what is the definition of pragmatics miriam webster according and it's webster which is not webster's dictionary i don't think oh i did not actually go look to see if that's the reference but maybe it is because it doesn't actually cite it maybe it is webster's dictionary so yeah it is webster's dictionary yes okay that's just it's just like okay the study of what words mean in particular situations that's what pragmatics is. Right, right, right.

But, you know, you've got to, and I know this, you've got to take the quote in context, right? Like, and I quote it with context. My ultimate goal for Blocks programming is to reach the level of pragmatics described by Webster as the study of what words mean in particular situations which is ironic because you need to look at that those words in that particular situation of that sentence right meta right that's very meta so like it he's not saying that's what pragmatics uh means but

like i think he he wants he wants pragmatics to mean that in his system sorry his language i want to read this whole this not this whole paragraph but like several more sentences because i had them all what you want to read in more context yeah yeah i definitely do because i think this is that's very pragmatic and and because i want to uh refer to this in the context of other things that i'm going to bring up um oh my god my ultimate goal for blocks programming is to in the context of other things that i'm going to bring up um oh my god my ultimate goal for blocks programming is to reach the level of pragmatics described by webster as blah blah blah blah blah blocks are just like words in natural languages pragmatic support suggests not only the notion of blocks executed in the context of other blocks but also blocks executed

in specific situations defined by the aggregation of agents or objects when comprising complex game and simulation world. So it's not like we just care about this, you know, addition block next to the subtraction block, but we care about this addition block in terms of the overall goal that the program is trying to achieve the overall game or simulation, whatever it is. And he gives this great example. When I program a Frogger-like game, what will my frog do when it is in this situation or that situation in the game? Ribbit. The game worlds need to be considered part of the programming environment to enable these kinds of explorations by the user supported by the computer. And I love this. this is a huge thing that i'm like when i'm at ink and

switch when i'm doing my worky work work worky work this is this is one of the things that we are constantly talking about and trying to do which is um when you're building some program when you're building some construction some augmentation something that, any little part of it, you really don't want to be looking at that just in terms of what is this doing with respect to, you know, the syntactic constructions around it? What is it doing with respect to, you know, the language primitives, but you want to be looking at it and thinking about it in terms of what is this thing doing within the overall work product that the user's employing it to produce yeah another example i love is the difference between saying if this then that versus saying this because that which is something that um alex worth my one of my teammates um is constantly hammering on us to

to do in our in our design thinking is not to say if this than that but to say i have this thing and this thing is the way it is because of that other thing and setting up that cause and effect rather than starting with you know the condition and then saying the consequence, start with a thing that you already have that you can put your finger on and hold on to and say, like, now that I've got this thing concretely, let me establish why this thing is concretely what it is. Can I just read this definition, but within the context of the entire section? No, I'm just joking. I'm joking. I'm joking. No, but that would be good to do if there was a there there. No, we can't keep reading this again and again with more context. So my qualms aside, what this continues on to do

is talk about how we can use syntax, semantics, and pragmatics to help out users. So the first part is this contextual explanations. So the Frogger example I think is great. We can now explain things. So when we have syntactic things, we already have used blocks to help with things like, okay, well, you can only put these two things together

because they're the right shape and you can't put the wrong things together. But then what about semantics? Well, here we could give the meaning of the block, right? We could have a way of being able to see in general, what does this block mean? What does it do? That's, you know, that makes perfect sense. It's really just like documentation, but maybe kind of a good affordance of the documentation kind of shown in the moment at the place. But then we go one step further to pragmatics, which says like,

hey, given my program's current state, what effect would this thing actually have on my real program? And we can show people this, you know, what it would do to your program, not just what it does generically. He has a really good example here that I want to use just to ground this distinction. So the example he has is from Scratch, there's this block that you can use to do some kind of effect. And the way that the block works is it says set, and then the effect name like fish eye. So it's a set fish eye effect to four so it's basically saying hey there's some kind of effect you get to pick what effect it is from a little

pull down menu color fish eye whirl pixelate etc and then a little slot where a number can go in to say like you know the intensity of the effect or something like that and he uses this as an example where the documentation that does exist in scratch for this talks about like that there's the little pull down that you can use to choose the effect and that you can type numbers from negative to positive 100 but what it doesn't do is it doesn't say well what do each of these effect choices mean like what's the difference between fisheye and whirl the documentation doesn't say because it's only offering syntactic support like saying you can pick an effect here it goes in that spot but it's not actually adding semantic information it's not giving you semantic explanation like saying here's what fisheye

actually does here's you know the effect that it's going to have when you use it and especially it's not adding pragmatic explanation by saying if you use the fisheye effect on this current graphic that you have selected like here's a visual preview of what that would look like or here's a textual explanation of how this exact graphic you're using it on and this exact effect would work together. Yeah, just one nitpick. It does say that this is semantic, not pragmatic.

The block itself is syntactic, and then the meaning, it says this in the paragraph, the meaning, set the graphic effect of a sprite to a specific number is the semantic of this syntactic little block. It says here, I'll quote, for instance, when engaging block help and scratch to explain the set fish eye effect to four, figure nine, the user gets a semantic response in the form of a generic help panel. Yeah, it says importantly, the description is not about the specific form,

i.e. the particular situation of about the specific form i.e the particular situation of the actual command in question it does not explain what the fisheye effect is or the effect number four means in the context of the actual situation e.g by applying it to an example shape created by the user so it's semantic but not pragmatic it also doesn't explain what those effects mean in abstract like it doesn't say, here's what fisheye even does. Here's what four even means. Like, when you say fisheye four, independently of the specific situation, it doesn't explain that. I think this is a semantic distinction you are making, not...

Right. It could go further. It literally says that this is a semantic explanation in the text. Parts of it are and parts of it aren't. Okay. They're not syntactic. Only the block's syntactic. I'm disagreeing with that framing that Ripening did

in the construction of this section. Okay, that's fine. I'm explaining what the text is saying. Yes, and I'm disagreeing with the text. That's fine. Okay, even though you said it was a great example. It is a great example. It's just poorly used by the text. That's fine. Even though you said it was a great example. It is a great example. It's just poorly used by the paper. Continuing on. At the level of

pragmatics, explanations need to be constructed for the user from a specific context created by the user. That is, pragmatic explanations will have to interpret all the parameters of a block to dynamically generate an explanation about the settings used by the user

right the pragmatic explanation is not about that type of block in general but about the specific block that was edited by the user and it doesn't say this here but it should because it goes on to make this point elsewhere that it is also not just about the specific configuration of this specific block by the user but the specific configuration of this specific block as it pertains to a particular thing on the canvas, and that you need not just the full context of the block as it is used in your source, but the full context of the block in terms of the simulation world being built. Yeah, we'll get to there help predict the future proactively yes yeah i want to make a you know i there's some

examples here of like a truck and there's this little c icon thing yeah and it gives a a pragmatic explanation that's s e e like i see it with my eyes not a c icon like the icon of the ocean or the icon of the third letter and it's this little truck and a block and then it says the explanation is underneath which says true if i see to my left which is all in red an agent that looks like this and there the actual block has a little arrow pointing with a little s e e so it's giving us the explanation of this thing which is true if i see to my left an agent that looks like this and i think this is fascinating because those words made zero sense to me yeah this is bananas like literally i had no idea what they meant and then we get told that

there's this thing called syntonic the projection of oneself into something or someone else syntonic explanations can help users to assume the perspective of the object to be programmed can we go deep on this this is this blew my mind that anyone would ever want to do this right oh my god really oh my god i and i knew that that would be this would be the reaction and like i i say this as like a knowing that people probably do this i do this i only do this this is there's a quote in the context of logo turtle programming pappert surmised that when students can project themselves into the turtle they would experience fewer problems with programming it never once i have done plenty of turtle programming never once did i think of myself as the turtle and i realize i'm in the minority almost certainly here right that's interesting i've never thought about myself as a program not once in my whole 20 plus years of

programming we came across this when we were making sancho studio right because when we were making these blocks that let you like control what a little particle does um we did not start with this what's it called syntonic we didn't we did not start with syntonic and instead we had like uh more like abstract language that was like you know the the thing to the right of the thing you know like or like um whatever is at the location of this atom you know in fewer words that was the sort of like the the concept used and people got really confused about it and then we changed it we changed the entire language of this this block-based system to be in first person right like you were imagining that

you are a tiny atom of sand and it was like when when there is space below me right when there is space below me, right? When there is something to my right, when I have so-and-so data inside me. And the stupid thing, the slightly annoying thing for me as the person making this language is that it wasn't actually right. Like it wasn't actually how the language was working or anything, but it seemed to help people just get it more when they picked it up for the first time. So I fully agree with this like i've seen this happen that especially when people are programming for the first time it can help to imagine that you are but you don't do this lou i mean i i don't know right because i don't actually know because like i like, I didn't think I did.

But then it kind of, oh, it's annoying. It's so annoying because it's not right, you know? But it's helpful. It's one of these things, like, in programming, like, we tell ourselves these little lies because it's just easier for our brain, our stupid, stupid brains to deal with, right? Even if it's wrong, it can be helpful. Why do you say it's wrong i mean i don't know how to say this to you but you are not a turtle i've been over here thinking but i was the turtle the whole time so uh okay but in in the case of um in the case that i'm talking about right that's not how it

worked and um it was more to do with like the position of you right like in in in it would be more accurate to say i am the location where the thing currently is yeah right and um but it just made more sense that to say that no you are the agent you are the you are the thing you are the object you are the turtle you are the atom of sand so this this this is delightful for me because i like learning this word syntonic i feel sort of like somebody's just told me i'm gonna make a i'm gonna make a like a two genders joke or whatever oh it's like somebody has just told me for the first time there's this thing you can be oh you can be this thing yeah and i've lived my whole life being this thing and not knowing that i can be this thing and and what's more like too real man

i i have this yeah i shouldn't have made the connection because i'm going to talk about shame here uh and that's you know let's let it all out there's different strata of shame i write comments as i'm going through code and i'm commenting things to figure out what things are doing i write comments saying uh-huh like uh you know at this point we're gonna do this or i'm gonna do this and i write it in the first person from the perspective of whatever is happening whether it's like a network request or a button handler or a you know a recursive algorithm or whatever i am always thinking of it first person what and i write comments about what it is doing in the first person and then go back and rewrite them to not be in the first person because I feel like if somebody saw me doing that, they would make fun of me for doing it. Yeah, like it's funny that you say, oh, it's wrong because you're not actually the agent.

You would be the position or whatever. And it's like, yeah, I'm both of those depending on which line of code i'm looking at like i i project into every statement in the program that's how i think about what code is doing is i like put myself into it and imagine that i'm doing whatever the thing is doing regardless of how abstract it is or how you know how bizarre that that is as a contortion it's like for me coding is a it's like an embodied first person you know experiential activity that i go through and reading the code is like here are all of the things that are doing especially if it's code that is thorny or foreign or like new or difficult if it's something that's thorny or foreign or new or difficult. If it's something that's rote that I've done a thousand times, I don't do that because there's a conversion step that is slow.

But if I'm actually trying to figure out what something does, yeah, it's 100% first person all the time. So button is you. I mean, this is so fascinating. Button is you. Yeah, yeah, yeah. And I love that there's a word for this i mean this is always so fascinating yeah because like i feel like so much of the time when we're and it's only after like two and a half hours in right like where we all realize that our brains just work

so differently like like it was last time i i i just don't have words in there you know yeah i just don't have them you know and jimmy doesn't have images and ivan you are the chosen one because you have both right i i can perfectly remember all sounds i including things that aren't my own voice really and i can only program by inserting myself into the into the code as the as the uh the thing under transformation or as the transformer depending but does it like do you ever just think that like what are we doing like like we all think so differently and we argue about these things about programming it's just because we're so different you know i mean this is why i think

i brought up from the beginning this kind of point about the things that i did find exciting in programming and the things that made me want to do it yeah are all the things that are being removed in this system oh that's a good point i i would have i would have hated this system as a kid. It would have made me feel a lack of control. It would have made me feel like I, all the magic interesting things were happening where I couldn't see them. Right, whereas for me, it was like the exact opposite. Like, you know, Mr. No Words in Brain Over Here,

you know, like I can see it all right because i can't when it's just words i can't see it in my head but when it's pictures and when it's rewrite rules and when it's like blocks i can see it you know what i mean yeah and me projecting myself into it is a is a mental visualization exercise where it's like i can't see it if it's just the words but if i can put myself into it and imagine what is happening then i can you know visualize what it's doing and understand it and hold more and i think it's also a way of holding more context at a time than i could otherwise right yeah i mean i find this is this is fascinating to me like i don't know what it means you know this like acknowledgement that

we're all so different. I mean, I think part of this is that, you know, I think this is one of the problems I know Ivan has with the name, the future of coding, right? Is it implies this kind of like singularity. Right, right. Yes, thank you. I was going to say. One of the problems, right? Not all of them, but like one of them. It implies this kind of singularity.

And I think there is always this movement towards everything should standardize yeah that there is a one right answer here you know this is the you know to bring back up the the type debate right this is kind of that idea it's like well we know that types are better because they do these things and therefore everyone should use them right now not nobody who's sophisticated would make that argument but that's kind of the the like simplistic argument that take that wadler take that peyton jones i'm i'm fine with it i i well they're not sophisticated i think i could get both of them to admit those kinds of things right and you can tell i yeah and you can tell and yeah of course there is a difference and some people are more suited

for languages like that some people like it some people are doing a different kind of activity than what wadler and simon peyton jones are doing right like i think this is a very important fact i yeah i enjoy types i mean i've sat and done proofs and interests right like i think this is a very important fact i yeah i enjoy types i mean i've sat and done proofs and interests right like i think they're fascinating like they're wonderful i do rust as like my main language for fun and yet i'm building a dynamically typed programming language like i i think that there's there's not only all of us thinking differently there are ways in which in our daily lives we like to think in different ways. And programming languages ought to help us be in these different modes of thinking.

And so, yeah, I've never once thought of myself as the turtle. And I find that if I tried to think of myself as the turtle, I would really struggle. Right? Like, I would make so many mistakes because I'm really bad at imagining first person perspective and being like, oh, I'm turning and where am I going? I'm much better at imagining the turtle on the screen, even though I can't picture it, it's easier for me. And I think it's because it's less rich visually. And so it's easier for me to deal with. Whereas if I had to start picturing myself in that

position well what am i seeing i okay now i have to project out what i'm seeing and that's really hard for me to do for me i'm i'm still seeing the turtle on the screen like it doesn't look any different it's not like i'm i myself physically like am the turtle but it's like how you feel when you play a third-person top-down video game or something like that. It's like I am that thing, but I'm not imagining that thing having the same experience that I have in my own body.

Yeah, I don't imagine myself as the character in third-person games, right? I just think of them as that's the character this is so trippy man continuing on from this we get stuff i don't have a whole lot in this section of me neither conversational programming help predict the future proactively i have a i i have some i have a something about debugging right this what i like about this next session section is that it takes a look at debugging i was really pleased that i read this

again because i read this before and i kind of skipped over this but over the past six months i've been looking at a little bit more debugging and like what's good about it what's bad about it so this is fun because it calls for a and and I quote, a proactive approach, end quote. It was a short one, right? Normally when we're debugging, we do it after we identify that the program is not doing what we intend it to do. But this calls for a proactive approach where debugging information is made visible to us, is shown to us all the time, right? Like it's there, it's ready waiting for us whenever we want it. And I don't know, I just think this is a good distinction to make. And it's like a good

identification of some of the challenges with debugging. The reason it's done in this case is because there were debugging tools already available in agent sheets and in some of these programs, but no one was using it. No one was reaching out to it. So it had to be made obvious to them. And anyway, that's just like something that I guess I'm taking away from this.

And I want to think about when I look at debugging, it's like, how do I make it just there, just ready? Yeah, I do agree. I think this is fascinating that, you know, I have seen that like, debugging tools are not used by people who are beginners, because I think it's for good reason, because like, now you have even more cognitive overhead of having to learn the new tool and having to be in that context. And it is one of those things where I do think proactive is good, but it's also something where the best way to learn this is to have someone show it to you. Have someone walk you through it, and you learn it by doing it with them. And I think that's one of the things that's really important. And, I mean, I'm sure it's recognized, but it's not talked about in this paper.

It's kind of the social environment around these tools. And I think that becomes a really valuable part of the programming experience. So when I'm debugging, right, like, I do sometimes find it just really annoying. Like, just, hey, this is a tricky problem. I'm going to have to have a closer look at my program or there's an error. Oh, where's it coming from? The stack trace isn't very good.

Let me whip up the step debugger. Or like, let me switch tabs to the right thing. Let me go and have a look. Like there is such a shift, right? Like, okay, i'm entering debugging mode i'm either in normal developing mode or step debugging mode or like debugging mode and i really don't like that and and if maybe maybe that's just the best it can be but like um i i hope not i also like the the way it talks about like debugging right right like it it says

that for debugging to be successful like you know what what debugging is supposed to be it's supposed to be a way of letting you experience the experience a, like experience the consequences of a bug in your code or something unintended happening. So if we can just make people experience a bug more clearly, more completely, then debugging can be better. And then we got live palettes make programming more serendipitous. This one is doing something very specific,

and I will spoil a little bit more of what I've been working on at Ink and Switch because we did this in the thing that we're making. And it's basically, let's say you have some environment, some canvas, and you can select stuff on that canvas. In the case of agent sheets, it's the grid simulation window, and the agents are on it. In the case of what sheets it's the you know the grid simulation window and the agents are on it in the case of what we're doing it's something else you can select something when or even before you can select something let's say you can like bring in some some programming blocks right you could bring in an if statement or you could bring in a like oh hey

change the color of a thing right i have like a recolor block that's like take this thing and hue shifted 180 degrees or whatever right i could grab that block and bring it in and put it somewhere and then say okay hue shift the thing by 20 degrees or whatever where i put it there's a way of constructing that workflow when you're designing one of these environments where you say first grab the thing then put it where you want it to go then set the parameters and then done it has its effect and that forces you to start from something abstract which is grab the thing that's going to have the effect grab the block on its own and all you can see about it is like maybe some documentation or something like that there's a alternative way of constructing

that workflow that starts concrete so you select the thing that you want to affect you know the object on the canvas or whatever then you go and get the transformation that you want to apply to that thing and when you go to grab that transformation you can already see in whatever ui element you have for like picking all the different blocks or whatever you can already see in whatever UI element you have for like picking all the different blocks or whatever, you can already see live previews of what effect those blocks will have on the thing that you selected. So you can see when you're grabbing the little hue rotating thing, a hue rotated version of the thing you selected. So it lets you start from a concrete example of a thing and go and pick an operation that you want to perform on

that thing and the ui presents you previews of the thing you're going to be transforming and so it's just a way of shortening the gap between wanting to make a change to something and seeing what the effect of that change is going to be and it it's it's a sort of a brett victory kind of thing where it's like you get that immediate connection but it is also a brett victory kind of thing in that like you're doing this in a ui that's presenting you a whole bunch of different choices of transformations and so you can see like ah here's all the different transformations as applied to that thing i've selected so you can kind of like scrub around and say like, ooh, I really like the way that transformation looks.

I came here to get one kind of thing, but I'm actually going to get something different because you can see the effect it's going to have. It's a really cool way of constructing a programming UI. And so that's what this section talks about is it's like have a palette for choosing commands actually show a live preview of the command as applied to the thing you want to apply it to i think this section does take it one step further than that

and that it does it all at runtime as well not just when you're at edit time trying to construct something um so like as your program is running they show you the values of all your conditions firing and all of the values changing over time um yeah and they talk about a study that shows like like people can perceive causality just by looking at colors changing and numbers moving and things like that on the screen even though there's not you know a direct connection there they can see like oh that turns green when this thing happens and that does this yeah and so you can like kind of watch your program run live so yeah i agree with you it just takes it one step further to even at runtime you can see those previews in an environment

where you have there's the program that you're building in one place and it's you know represented as blocks or whatever and that is separate from the stuff that's actually on the canvas and you can see both at the same time yeah and then we get to the real beyond meat of this sponsored beyond me uh the uh that's our new sponsor that's why i've mentioned them multiple times now uh i wish that would be fun gross i like gross dream sponsor well you don't like the odd meat i i'm a vegetarian because i don't like meat not because i want to eat meat and just choose not to i love meat no i shouldn't say this no you yeah there's lots of vegetarians who love the experience of eating meat and want a you know i do it as a personal sacrifice you know yeah no i just don't like meat i just want to eat vegetables that's it's pretty simple weirdo all right so computational

thinking tools this is really this is the part that i wish had been moved up to the front i have no notes on this section so it's all you really yeah this section did nothing for me wait wait wait do i have notes not really there's a bit of a yeah yeah yeah more examples yeah yeah yeah more examples yeah yeah yeah yeah no it's this it's this whole section where you have no notes so we are told um that programming is not important. That's not the goal of computer science education, I'll quote. The goal of computer science education is not to write programs, but to become computational thinkers. That this whole time that I'm reading the paper, I'm thinking, this is about programming. This is about a programming environment.

And I'm told, nope. This is not about a programming environment and i'm told nope this is not about a programming environment at all this is not meant to help people write programs it's meant to help them be computational thinkers and you might be saying to yourself like oh well but isn't programming like the best way to do computational thinking. And there's a quote in here that says, oh, well, isn't walking all the way from New York to LA the best way to get to LA? No. Could you get there? Yes. That's the same example as what programming is to computational thinking.

Programming is bad for computational thinking. Yes, you could do it, but it's not the most effective way. I have the quote here. Of course, computational thinking can be, you could do it, but it's not the most effective way. I have the quote here. Of course, computational thinking can be stimulated by programming, but a trip from Chicago to Los Angeles can also be achieved by walking. Yeah, yeah, yeah.

Yeah, I see, I see. Yeah, and so this whole thing was not meant as a programming environment, despite the beginning saying it was. A programming language and it talks about programs and helping kids learn to program that's not the point of this environment if that was what was led with it would help me so much wait a second so wait wait wait wait is this not a programming environment is that what he's saying well it's not a programming language

i mean a programming thing right is this not programming so there's there's two steps here and we gotta we gotta keep both steps in mind in order for this to make sense i'm doing my charitable interpretation patent pending oh i think this is super charitable just to be clear i'm not saying anything negative here yeah i think this is super charitable, just to be clear. I'm not saying anything negative here. I think this is fascinating. Fascinating. Delicious. First, we have to remember that a motivation that is presently recognized by Alex, whether or not this was the original intention or whether this is something he eventually came around to at the time of writing a motivation that he recognizes is that cognitive slash affective challenge and wanting to address that failing in a way that computer science is taught and so it's looking at computer science education and the goals of computer science education and saying you know

according to a reference that is cited uh there's a a goal of computer science education to produce computational thinkers so that i take that as a goal not like the goal it says the goal but i'm being charitable it's not charitable you're changing the word that's the goal yeah that's okay no that's you can't change the what they say to be charitable no of course i can i mean lou did it last episode before last episode and it was fine so yeah wait no i was that was i was being uncharitable no no no because you you were saying you was like oh i'm gonna quote brett victor and then you made some stuff up uh so yeah no no i did not but it was we're not supposed to talk about it this episode no this episode is a reset we are not talking about an elephant how words

were put in mouths no but genuinely i would say that i thought in that episode, and I quote, It's facetious. This is a facetious interpretation, right, of Brett Fichter, right? It was, like, definitely not charitable. The goal of computer science education. So your facetious interpretation, right? The goal of computer science education, according to Wing, reference 104, is not to write programs but to become computational thinkers and that that is um related to that is this cognitive effective challenge and so this use of agent sheets as and this perhaps reformulation as it

evolved into being a computational thinking tool is is pertaining to those things so yeah no like i just to be clear like i do think this is like i'm not saying anything negative here i'm saying i wish i had known this from the beginning because i was interpreting so much in this paper negatively because it kept getting further and further away from programming and i i that's not my words. It says, to adapt to the needs of computer science education almost as a side effect, agent sheets and agent cubes have gradually shifted from being programming tools to becoming computational thinking tools. Right. And they contrast here what you need for programming tools and what you need for computational thinking tools.

We get programming tools are general purpose programming environments that can be used by a large variety of projects, but most interesting programs quickly become elaborate because of accidental complexity, versus computational thinking tools, with their pronounced goal to support computational thinking, have a more narrow range of projects, but they manage coding overhead in ways so that simple computational thinking can be expressed with little code.

This isn't me projecting onto here saying there are limitations. This is an intentional choice to make these limitations. And so when I'm talking, when I was talking about these semantics, like limiting you, this is considered a feature, feature not a not a bug because these aren't trying to be programming environments these are trying to be computational thinking tools now i still have problems with computational thinking but like that's beside the point here it's that like this all start making sense this movement away from general purpose programming towards something domain specific of trying to support computational thinking and what is computational thinking i'll continue to quote computational thinking is the process involved in formulating a problem and expressing its solutions in such a way

that a computer human or, can effectively carry out. Okay, it's funny because I actually disagree with the paper here, and I think it's actually the opposite. I think if you look back to what it was at the start, which was more of this cellular automata simulation-focused tool, to me that seems more like a like a pure like computational thinking tool and it's moved more towards this block-based more generic scratch like programming environment whether you think it's a system or a language i don't care but like so for me um that surprises me because it feels like it's gone the other way but i would say that i think in all cases it has been a programming tool but i understand that the the like the focus might be placed more on developing computational thinking yeah the way i see it is like if you

have to make a tough decision between a design choice that you feel helps the programmability versus helps right but it makes it more complex and it makes it so it's hard to do these computational thinking exercises. You know, if you have to make this trade-off, you're going to choose the one that does it. And there's another quote I'll read here that's talking about this problem of why programming doesn't take hold in schools. And they say, when computing skeptical STEM teachers see simple applications such as two-species ecosystem simulations turn into 200 lines of code, then one should not be too surprised that the adoption of programming in STEM courses is still abysmal. And this all makes perfect sense to me. Like, if you're wanting to – I see this – we can talk about computational thinking in a second.

But, like, if you're wanting to do simulation environments of agents, which is you can do a lot with. You can make agents that do a bunch of stuff and people can look at dynamic processes and understand how they would unfold, and you want to set that up, a general purpose programming language usually does not foster that quickly.

And so an example here is given of visualizing a mudslide. Ascend. And to make a mudslide, you only need one rule. If the space below you is empty, then move down. That's it. And like I said, as a kid, I would have found that so deflating. But that's it and like i said as a kid i would have found that so deflating but that's fine that like to me that doesn't show like what is the computer doing is the thing i'm interested i was interested in not what's the sand doing yeah i mean it is interesting because like there it feels like you

know we're seeing this thing change goals throughout these 20 years right and i think that's like the really interesting part for me is like understanding the history of it starting is a thing for scientists like hey let's try it out with kids because the scientists all hate it they say it's like nothing they've ever seen before right like and then starting it out with this rewrite rule that we're going to make this new kind of programming language right and it is a programming language and then it's slowly becoming more of this computational thinking thing. Yeah, I think this is fascinating. But like, again, I see this pattern again of someone saying, no, don't worry, it's not really a programming language. It's something

else. It's a system. It's a computational thinking computational thinking tool like i think there's people are so cautious about calling their weird visual systems whatever they are calling it programming whether it's right or wrong i just think it's this interesting pattern that goes on that people are so like defensive about their visual programming computations like do you see that too or is it just me like am i just am i just seeing what i want to see no i do think this is something people do and i think a lot of people do it for different reasons right and yeah and here the reason that i think is is given is that what they don't what they want the students to learn. So they talk about, you know, like the main focus here is the classroom. What they want the students to learn is not how to program.

That is not the goal at all. Why they want to say it's not programming is because that's not what they're teaching. The programming elements are a means to an end. There's a quote here that captures this really nicely that i want to read if you want students to use programming to learn something else then limit how much programming you use that really resonates for me because i'm somebody who used to work at an education company where programming was a big part of the thing we were teaching, but we were teaching it to people who did not want to think of themselves as programmers. And programming was a big part of the way that we built our teaching aids. And the

people who were building those teaching aids were artists who did not feel that they were competent programmers. And I was also using programming tools, you know, to build little environments that I could use to learn about how other things worked. Like I built most recently before I left, I built myself a simulation of a magnetic field and built a little electric motor with a rotating magnetic field in it and three phase power and solenoids and all those sorts of things just so that i could learn how magnets work like how do they even and that tension between like needing to attend to the computer and its needs in order to get the program to run in a way that you know produces the effect you want versus this computational thinking like using the simulation as an opportunity to explore an idea that is unrelated to programming is something i feel

very acutely and it's something that yeah like i've i've been all over that spectrum and so i like seeing how it's recognized here i really like the figure 25 agent cubes flabby bird 3d game i assume that's because like flappy bird is like a trademark or something so all right they just want to be they want to be cutesy so this is flabby bird it's like the flappy bird but they're just they're just a little bit flabbier yeah that was actually my only note from this whole section oh i i gotta comment on this pac-man because it's all right all right it's the worst example you could possibly give and i will justify that i know what you're saying all right okay so in order to implement pac-man it is just 10 rules and this is kind of showing this like how they've gotten it to the point where

you can do this in a classroom right where it can be not 200 lines of code and so i'll start with pac-man the character right so remember we have these agents and they do different things and so pac-man's not too bad um we want to see if the um we have, if test agents of type pellet equals zero, then show the message you won. So it is a little weird for me that this is a Pac-Man rule, but okay, that's fine. Stop simulation. So it's saying if there's no pellets on the map, then you've won. If stack dash A, don't know what that means, but it's fine. Above or below, stacked, I don't know what that means, but it's fine. Above or below stacked.

I don't know why the dash is there. Stacked a anyways, above or below a ghost, then show the message you lost. Okay. So if you hit a ghost, you lost, uh, then it's very bad, but it's you, isn't it? Uh, yeah. Yeah. Then there's some rules about movement, right? Like, you know uh yeah if there's not a wall

above you and you press the up key then you should rotate and move that way and you know the four directions for these rules okay that's fine pac-man there's some nitpicky things but like there's things you could probably teach it's fine all right then what about the ghosts if every once 0.5 one half seconds 0.5 seconds then he'll climb p in four directions von neumann neighborhood animation constant times slider parentheses sec and there's also a rule above which is the background which is if blank then set p to 0.25 times p square brackets left plus p right plus p up plus p down and the p's are different cases because it's case insensitive so it doesn't matter and this is a collaborative diffusion that you know implements pac-man ai and only 10 rules yeah so that one of one of those rules being hill climb is kind of absurd because it's like well wait what if a kid wants to know what how hill climb works what if little jimmy little

jimmy little jimmy wants to know how hill climb works i still don't understand this example at all i have no idea what it's supposed to do with these yeah like i understand hillclimb well but like 0.25 times people and then like it's collaborative diffusion animation constant like and like yeah i don't want to defend this but i am going to explain it so the 0.25 thing and this is this is this is nicely this is a nice framing of the rules of pac-man articulated in a terrible ui for doing programming at this level where it's it would be so much better suited by like actually overlaying stuff on the canvas showing visual aids like what does this p diffusion rule doing and you see those kind of visual aids and that kind of on canvas representation in amit

patel's red blob games website where he you know demonstrates a bunch of this style of uh algorithm um with an aim to teach you how to write these algorithms yourself if you know using low level code um but it explains these concepts and and it shows like here are the interfaces you would want if you were going to be programming at the super high level and this this little rule you know if then um with all these abstract references and all that kind of stuff that that the ui is terrible for this it's a bit gobbledygook yeah you have to already know what all these things mean in order to be able to understand this and i could imagine teaching this like one-on-one very slowly building up these rules bit by bit with the aid of a whiteboard but at that point i think you're no better off than

just writing it in like like writing hill climb writing the diffusion i i yeah like all you're gonna do here is go hey and we have a built-in thing to magically make ghost ai work no i i mean you shouldn't do that it's not very satisfying yeah but the the the cool thing here is that it does reduce pac-man down to something that can be expressed in a declarative way of course because you cheated just built in half of pac-man even if you didn't have hill climb built in also have you played this one no but it would suck yeah oh it's you die like almost instantly because the hill climb they're like oh it's better ai yeah it is better ai because it makes it almost impossible for you to do anything right you could augment it with a couple more rules to make it good but the use of hill climbing as a declarative way to express ghost ai like to express the the

way that they will lock on to you and follow you is kind of cool um also i'll shout out sean lebron has a very very cool cool, interactive, visual demonstration of the actual AI of Pac-Man. I'll link that in the show notes. It is probably like what this could have been. And I think it's getting at what this is trying to get at, but does so in a better way. Okay, I'm just going to read,

because they say it uses collaborative diffusion, which you can Google, and you'll find a bunch of stuff that's not related, but you'll find this Wikipedia article, which is which is very very short that i swear they wrote um in fact i know that they wrote i know it's it's the only citation is alexander collaborative diffusion programming anti-objects so like this is just showing off prior research rather than anyways it's a pathfinding algorithm which uses the concept of anti-objects so like this is just showing off prior research rather than anyways it's a path finding algorithm which uses the concept of anti-objects objects within a computer program

that function opposite of what they would be conventionally expected uh so in pac-man the one example the background tiles serve as anti-objects carrying out necessary calculations for creating a path and having the foreground objects react accordingly whereas having foreground objects be responsible for their own pathing would be conventionally expected so that's what's happening is these these tiles are computing something yeah there's some there there like it's not it's not the worst thing i've ever heard. It's pretty bad, but I do see what they're saying. Oh, yeah, I forgot the pellet. The pellet also sets pee.

Oh, yeah. Yeah. Yeah, all I'm thinking is, like, I'm just, like... Okay, I love this paper because it just makes me want to make stuff, you know? Like, there are so many things down it. Like, the references are so dense. I just highlighted one where it was, like, six references in a row. And it's, okay, right.

And now I'm just, like, looking at this and I'm like, I just want to make a better version, you know? Like, I want to take this and I want to take Pygmalion and I want to take Markov Jr. and I want to take Cell markov jr and i'll take cell pond and i want them to all have a baby and and then i'm gonna make that like this this paper we like it's like a really good prompt that's what i think all right i i finally i i'll just say i finally understood this pac-man thing because pac-Man is set to P of 1,000 and then basically that propagates out

through the background and through the pellets and then the ghosts try to walk up the hill to try to find the bigger values. Yeah, that's the 0.25 times the four directions is so that it... Yeah, I don't think there's... You could have done this maybe without a hill climb variable

and maybe explained something here oh totally but like yeah then it wouldn't be 10 rules yeah the hill climbing is just yeah yeah it's yeah it's for concision it's it's too clever i think it's it shows a lack of restraint yeah this is the kind of stuff that bothers me though like i don't want to just pick on this because it was confusing like it honestly does i do think it actually matters because this is the kind of like thing that people go oh look at my system it can express so much and so little as if that's the criteria for helping somebody in this case not program but think computationally right and i just don't think that that's if the way that computational thinking here is being phrased and the way in which they're approaching it and saying

that programming doesn't help you with computational thinking if that's true i'm not sure i care about computational thinking i i just i don't see what it's if if being able to program does not help with computational thinking then what is computational thinking good for yeah i i think programming and computational thinking are very closely linked i don't see the gap that is being put forwards in this paper and i think it's just further confused by this very bad example i think the example is picked out yeah because it's like look how few it can be and please don't read any closer than that please don't zoom in right i i think i think there are plenty of other good examples in this paper that make me think that that's more of an outlier and and i think the way that it has done certain parts in this example like

um hint towards an actual good form of of like block-based coding that is very similar to what we know with scratch i can clearly see the the links to scratch here with this example and like i have seen some extremely cursed scratch projects made by by by kids right that like have been like you know shared and showcased by scratch team and i think this example here is maybe like showing look yeah you can do some you can do some freaky shit too you know right like but but it's not it's not framed in that way so like you know i i'm gonna interpret this in a facetious way, as always, and say this does not help at all. And it actually highlights how complicated this kind of programming can be.

It can actually confuse you. And I think that is such a huge downside with this kind of tool. It robs people from the opportunity to do actual computational thinking and i'll go back to my example of the the time about a year ago where i built a magnetic field simulation to learn about how magnets work like part of that learning process was having things happen like um uh when i implemented divergence and curl properly all of my simulation disappeared because i had been formulating the way that a magnet worked as being a result of curl or sorry as a result of divergence and magnetic fields have no divergence that's one of maxwell's

equations and so i like fell ass backwards into discovering one of maxwell's equations as a result of like fixing bugs in my simulation and then having to think about that and go okay why is that happening oh it's because i was misunderstanding what magnets are and how poles work and so you know that's that learning process and if i was using an environment where there was a built-in primitive called magnetic field and it's like it's a simulation building environment right here's an environment where you can build simulations to learn how things work it's like i would have been robbed of the opportunity to learn how magnetic fields truly work i may have been enabled to learn other

things like what happens if within a magnetic field you do these things with these wires right yeah and there's a there's a bunch of interactive simulations from what are they called they're fets or something like that p-h-e-t um they're from uh the university of colorado they have this huge collection of interactive simulations for learning about science and you know math and that sort of thing but they are they have that problem where they are that kind of high level thing like you get a simulation with a couple of coils of wire and a magnet and a light bulb, and you can move the magnet around and see the light bulb light up and see the field around the magnet a little bit. But there's this way of building tools to aid computational thinking that like are constraining rather than freeing

and i think a lot of people accidentally build the constraining ones when they're trying to build the freeing one but the freeing one doesn't it's like the problem with tutorials in video games right where it's like you want to encourage people to have this feeling of like running downhill where it's like you're helping them get familiar with something that's that's foreign as opposed to the thing where when you don't have a tutorial it feels like an uphill climb and it's you know you might be disincentivized and not do it versus the thing where it's like okay sit down and don't go anywhere until we say, okay, now you can take some steps. And it's such a hard balance to strike. And I feel like that's what this computational thinking stuff should be about, is it should be about getting better and better at creating these

environments where people can explore these ideas in a way that is freeing and empowering, but it's just very, very hard to do. And we're not there yet. We've got a long way to go before we can, you know, come up with some good ways of doing this that don't fall into the pit of making you have to program or the pit of giving you too much out of the box so you don't get to explore anything yourself. I think your magnetic, you know, simulation is a great example that I think I could take one step further. So of course you could imagine a system that just provided you with magnetic fields, but you could also imagine a system

that really understood pragmatics to a great extent. And as soon as your magnetic field disappeared, it just gave you a simple little helpful thing that said, I can't remember the exact word you said divergence yeah divergence is not you know magnetic fields don't have divergence and that's why your magnetic field disappeared and i think that would have been just as bad it would have been telling you the thing that you needed to discover and yes you would have learned something but it wouldn't have stuck with you in the way that this example did.

Because I guarantee when you didn't come across this immediately, you were like, why is my program, why is everything gone? And you had to think about it. Well, I didn't arrive at the knowledge that magnetic fields have no divergence just by sitting there and closing my eyes and thinking really hard. I had to go and read. Yeah, yeah. I'm saying I had to go and read. Yeah, yeah. I'm saying you had to go do the work. And in that reading, I found, ah, magnetic fields have no divergence. And if the tool had told me, hey, just so you know, magnetic fields have no divergence

at the right time, that would have been equivalent to me going out and doing a bunch of reading. It just would have been quicker. And so I actually do think that would have been a helpful thing. I don't think you would have remembered. Okay, let me change my scenario slightly, and as soon as you go to type that code, it stops you from typing it.

Depends what the goals are in that situation. Regardless, my point here, even if you don't agree with the example, my point here is I think these systems, I want to bring this back to my closing statement on this, don't agree with the the example my point here is i think these systems i want to bring this back to my closing statement on this like goes back to the beginning where this like goal of making programming not boring and not hard whatever the opposite of those things are so i'm not saying accessible versus easy or whatever can often get in the way of making them teach you something.

I think we often learn by doing the hard things in order to get to the place that we need to be. Now, we have to help people feel like they can accomplish those things. We have to help them realize that, yes, this is hard, but you can do it. We're here to help you do it. That you're not alone in this. I think these are all important things. And I think they have to be motivated to want to do these things and not just find it boring.

I think all of these things are great. But that holy grail in that graph, that set me up in this paper to already have, like, I ended up liking this paper. I'm not saying I don't. But that, to me, like, just immediately put me in this bad to already have like i ended up liking this paper i'm not saying i don't but that to me like just immediately put me in this bad state of mind i think about playing the violin or the cello or the viola or the stand-up bass or whatever right these are all hard things that some kids are really motivated to do and we can help them by putting tape on the the fretboard not the right term the neck that. That's what I want to look for, so that they can know approximately where these notes are. And eventually they don't

need that. And there's all sorts of things that we help them. That's a good concrete tool that we use to help them get to that point. But it is through doing those hard things that they gain the proficiency that a great violinist can have. And what I'm not saying this interface does, but what I think is the danger here, if we set our goal to be make programming easy and exciting, as the graph said, rather than accessible and exciting, is that we get rid of some of those most motivating, most meaningful parts of programming that at least i loved and why i continue to come back to programming time and time again is because it is hard it is frustrating i do hate it all the time and that's what i want out of it it's funny my my ending thoughts

and i've been you could choose who, you know, whether you cut any of these off at this point. If we don't finish in five minutes, this will be another three-hour episode and I'll hate all of us. All right, then my closing thoughts is... But yes, you have five minutes, Lou. This is... I only need one. This paper covers the history of block-based programming and in education

and in beginner use cases for adults and children block-based programming has won full stop everyone loves to hate on scratch but it is the winner that's what all kids learn and i think by reading this paper you can understand the different reasons for that some of them are historical and some of them are because it does things well right like it provides syntactic help it provides semantic help though we did identify ways that even you know scratch could do this better and and there is like there is this glimpse of some pragmatic help that you know maybe maybe we maybe there's even more untapped potential in block-based coding and that's what this says to me there is like a whole mixture of examples from the good the bad to the ugly from start to finish and it's not

necessarily saying that this is the thing to do it's saying that like this is our context and i love this paper because that's what you need as someone working in this space. It's like you need to know, am I wasting my time or not? You need to know, like, what's come before. So if you are building visual programming languages or systems or whatever, then, like, I think you should read this. I think there's going to be at least one reference, at least one reference that's going to be helpful to your work.

And I think there's some surprises here. All right, that was maybe five minutes. I don't know. That was a minute and 49, 50. All right, I was 50 over. Yeah, I'm good. I completely disagree with everything jimmy said in his summary and and want to just unpack it but um i don't hate myself that much wait bonus episode no no no no why not i think that's a great topic for a bonus content because we've talked about it

before we've we've been over this a lot of times um i don't think we've been over should programming be easy or not yeah oh totally i think i think the most interesting thing out of this is like the fact that this like not the one true answer right the future of code the futures of coding the futures of coding the futures of coding the futures of coding the futures of scoding just add an s towards you didn't say at the end so i'm just adding them somewhere i i feel like that that's this that's this building storyline you know that's this building storyline it has to be i i would whether we do the bonus content or not i would love to hear your disagreements you don't have to give them now but i i don't think i don't see how what i said is and yeah i don't see how what i said is

disagreeable because i put a lot of weasel in all of those things yeah no it's like the difference between what you want for yourself personally and what was good for your experience versus what the goals of people making these systems are and what those are there are many of them and trying to recognize that some of the things that you said are good or bad are good or bad locally for a particular subset of those and the inverse is true for others and so there's like cases here where some of the things you said where it's like ah you know this thing is good or this thing is bad i know you were talking about like for your own experience but that's um uh some of the things that were i think this is the danger that these systems yeah

right is that they get rid of the parts i liked yeah right yeah i'm not saying they all do i didn't i said this one doesn't that's the weasel yeah but i think this is the the problem that people have to come up against and i think it's yeah of course it's i'm not saying we that some people won't love this and that this won't inspire some people to do programming. Of course it will, and it has. That's the point. The point I'm making is it's not all about getting people to be programmers. It goes back to that earlier thing

about computational thinking. Yeah, which is completely pointless and useless. I do not understand it at all. I'm trying to be nice. Do we want to stop recording or do we want to keep this as content for you? Yes, we should stop recording. Okay, okay.

Stop recording.