[Amin]: All right. Hey, everyone. Thanks, Zach, for the great talk. Here is a live Q&A.
People can start putting the questions onto the pad, and Zach will answer them.
Zach, take it away. Thanks, Zach. Here is a live Q&A.
[Zach]: Okay. So, first question. Let's see.
Okay. So, the first question is why did you choose an internal state
versus many state buffers? So, the main reason was more control
from the game perspective. I mean, if this was to be a tool,
if this was to be a tool that perhaps was used for more, like,
real-world applications where maybe you'd want users to be able to, like,
use any of their preexisting
— like, if you wanted to really make a grid of cells that would —
so, then I think maybe using real buffers in that case
would probably be the better thing since you wouldn't have to, like,
redo everything. But I found that just, like, centralizing the state
into one place for the game at least made it the easiest to implement.
Next one. Do you have plans to port Shenzhen I.O. to Emacs?
Well, I was actually thinking about exopunks, perhaps,
but Shenzhen I.O. would be pretty cool to add as well.
So, this doesn't use any Wasm at all.
So, the next question is, did this use Wasm?
So, it's asking about, like, using Wasm Emacs. So, this actually —
this doesn't use any Wasm under the hood.
It's pretty much analogous to the game TIS 100 is to real assembly
as this game is to web assembly. Slight resemblance, but, yeah, just a game.
So, okay, so the next question is why Wasm
rather than a more traditional assembly dialect?
It wouldn't be harder to implement, right?
So, it would actually probably have been easier, in all honesty, just because,
you know, more traditional — like, TIS 100, for example.
You have each of the — you have each instruction on a line,
and it's pretty easy to, you know, syntax hiding just one line.
So, this with the weird S expressions across the line, deeply nested,
and then, like, the step debugger thing and these weird cell things.
They made things really complicated, but I definitely wanted to, like —
the main reason is I didn't — I wanted it to not — to look as least as —
to look — to resemble TIS 100 as little as possible,
even though it's still pretty much the same game.
[Amin]: Thanks, Zach. I think we still have about, like, eight minutes or so.
Or eight and a half minutes of Q&A time.
So, folks, if you do have any other questions,
please do keep them coming in the pad, and, yeah,
Zach will continue answering them.
[Zach]: Sounds good. Thank you.
So, next question. Any next projects on your mind?
Yeah, actually, I have a couple ideas for projects,
and these would all be, hopefully, maybe more useful.
I think TreeSitter is pretty
cool. I think there's a lot of directions that I could go, like,
there's a plugin in NeoVim called NeoGen, which generates documentation.
That would be cool. I've been playing with this. What else?
Yeah, I mean, hopefully, next year, at next the Emacs conference,
I could be presenting something more useful.
Next question. Does this work with any other paren-based editing packages?
Not at all. Not at all. In fact, just because of the way the buffer was set up,
how it's just, like, the illusion of a buffer, like, not even, like,
the syntax parsing works correctly, because just because everything's, like,
the way the grids are set up, like, you have, like,
the other cells kind of interfering with the way that parse is.
But the way it was architected, it's actually a really simple macro.
There's a little macro called, like, run in buffer.
You have, like, run in buffer, and then you put your elist code,
and then it tries to create the illusion that it's actually running
in a real buffer. So this macro kind of does all the configuration setup.
So, I mean, maybe with, like, more configuration settings,
maybe something like that could have been done.
So next question. What kind of tool could you use this idea?
Oh, going back to the next project on your mind.
This actually came up to my mind as, like, a graphical.
So, in terms of, like, there's a lot of graphing tools, like ASCII.
So, like, you type in some text representation, it generates an ASCII document.
I think it would be really cool to have, like,
an Emacs package that sort of works, like,
those online really slick graph drawing tools.
So, like, you can just press tab, and it draws a new box with an ASCII arrow,
and then, like, it can create these diagrams really easy.
I think that would be a really cool project.
And so, something like that, obviously, like, you have different cells.
And so, that's actually another thing I think would be cool to work on.
So, designing puzzles. So, it's funny.
If you listen to Zach Barth's talk about TS100,
he goes into, like, you pretty just, like, you pretty just,
it's just like you make up a puzzle you think could work,
and chances are it does end up working.
And that's how I roll, at least my custom puzzles in the game, just, like,
come up with some random idea, think it probably should work,
and then try to go implementing it. And usually, it's implementable.
I mean, four by three boxes, you can do quite a bit.
And I don't put any restrictions on the cells, like, TS100.
What are your favorite changes in the upcoming Emacs 29?
So, definitely TreeSitter is pretty cool.
Just because, like, you have syntax, you have access to that.
You can build syntax-aware extensions.
So, like, I was just I was playing around with it, and it's pretty cool.
You can just, like, get the syntax tree and search for syntax patterns.
So, it's exciting to see what might be done with that.
Are there tools to add more puzzles? So, there's not tools,
but in the code itself, there's a file called azimbox puzzles.
And it's pretty much just, like, you have a generator function.
You configure it's just, like, you're pretty much defining a struct.
So, I mean, if you're familiar with the Emax list,
you can kind of define puzzles pretty easily.
Define where your inputs are, generate a function to generate these inputs,
and then a generator function to generate which outputs you want.
So, it's pretty, I mean, code-wise, it's pretty self-contained.
But yeah, maybe I could have done, like, a more streamlined job with that.
Like, a binding to graph is? Oh, yeah, with the graph thing I was mentioning.
So, that would also actually be pretty cool, too. But I was thinking more just,
like, plain ASCII graphs. Just, like, you already have just, like, so,
a tool I've seen recently is called Diagon.
So, you basically type in, like, some really, like,
a textual representation of the graph, like, A arrow B, B arrow C,
and it generates, like, an ASCII diagram.
So, something like that would be cool, like, so, like, you have, like,
a grid of, like, little nodes, and control F maybe brings you to the next one,
and maybe tab, maybe would create a new node with a new ASCII
arrow to it. That would be a cool, that would be a really cool extension.
But, yeah, I mean, obviously, graph is an amazing tool.
So, a lot could be done with that as well.
[Amin]: I think we have about, like, a minute or a minute and a half of live questions.
We are opening the Q&A, this BB room for people to join.
So, folks who want to do that are welcome to do so.
And, yeah, after that, the stream will move on.
But you can still come in this BB room or keep asking questions on the web.
Okay. I think that's about all the time that we have on the stream.
Thanks again, Zach, so much, and both for the Q&A and for your great talk,
and see you all around. Thank you.
Cheers.
[Zach]: Thank you.
You are currently the only person in this conference.