summaryrefslogtreecommitdiffstats
path: root/2022/captions
diff options
context:
space:
mode:
Diffstat (limited to '2022/captions')
-rw-r--r--2022/captions/emacsconf-2022-asmblox--asmblox-a-game-based-on-webassembly-that-no-one-asked-for--zachary-romero--main--chapters.vtt52
-rw-r--r--2022/captions/emacsconf-2022-asmblox--asmblox-a-game-based-on-webassembly-that-no-one-asked-for--zachary-romero--main.vtt874
2 files changed, 926 insertions, 0 deletions
diff --git a/2022/captions/emacsconf-2022-asmblox--asmblox-a-game-based-on-webassembly-that-no-one-asked-for--zachary-romero--main--chapters.vtt b/2022/captions/emacsconf-2022-asmblox--asmblox-a-game-based-on-webassembly-that-no-one-asked-for--zachary-romero--main--chapters.vtt
new file mode 100644
index 00000000..6124054e
--- /dev/null
+++ b/2022/captions/emacsconf-2022-asmblox--asmblox-a-game-based-on-webassembly-that-no-one-asked-for--zachary-romero--main--chapters.vtt
@@ -0,0 +1,52 @@
+WEBVTT
+
+00:00:00.000 --> 00:00:30.680
+Introduction
+
+00:00:30.680 --> 00:00:44.960
+TIS-100
+
+00:00:44.960 --> 00:01:08.040
+WebAssembly
+
+00:01:08.040 --> 00:02:07.640
+Basic stack operations
+
+00:02:07.640 --> 00:02:44.680
+Numeric commands
+
+00:02:44.680 --> 00:03:21.400
+Boolean operations
+
+00:03:21.400 --> 00:04:00.240
+Port operations
+
+00:04:00.240 --> 00:05:15.720
+Control flow
+
+00:05:15.720 --> 00:06:14.480
+Modules
+
+00:06:14.480 --> 00:08:33.040
+Puzzle
+
+00:08:33.040 --> 00:09:35.200
+The game loop
+
+00:09:35.200 --> 00:11:25.880
+Tic-tac-toe
+
+00:11:25.880 --> 00:12:07.800
+Text properties
+
+00:12:07.800 --> 00:14:00.920
+Code cells
+
+00:14:00.920 --> 00:14:37.560
+Undo
+
+00:14:37.560 --> 00:14:52.360
+Parentheses
+
+00:14:52.360 --> 00:16:07.440
+Assembly text to executable code
diff --git a/2022/captions/emacsconf-2022-asmblox--asmblox-a-game-based-on-webassembly-that-no-one-asked-for--zachary-romero--main.vtt b/2022/captions/emacsconf-2022-asmblox--asmblox-a-game-based-on-webassembly-that-no-one-asked-for--zachary-romero--main.vtt
new file mode 100644
index 00000000..ef640bf3
--- /dev/null
+++ b/2022/captions/emacsconf-2022-asmblox--asmblox-a-game-based-on-webassembly-that-no-one-asked-for--zachary-romero--main.vtt
@@ -0,0 +1,874 @@
+WEBVTT captioned by sachac
+
+00:00:00.000 --> 00:00:03.800
+Hi, I'm Zach and today I'll be giving
+
+00:00:03.800 --> 00:00:05.320
+a presentation on asm-blox,
+
+00:00:05.320 --> 00:00:08.960
+a programming game inspired by WebAssembly.
+
+00:00:08.960 --> 00:00:10.840
+So programming games came into prominence
+
+00:00:10.840 --> 00:00:13.160
+about a decade ago and are loved for providing
+
+00:00:13.160 --> 00:00:14.760
+interesting programming challenges
+
+00:00:14.760 --> 00:00:17.160
+without all the messiness of real world programming.
+
+00:00:17.160 --> 00:00:19.960
+I wanted to make a programming game
+
+00:00:19.960 --> 00:00:24.880
+and I decided to base it off of TIS-100,
+
+00:00:24.880 --> 00:00:28.240
+having a pretty basic UI.
+
+00:00:28.240 --> 00:00:30.680
+It seemed pretty doable in Emacs.
+
+00:00:30.680 --> 00:00:33.160
+TIS 100 is a programming game
+
+00:00:33.160 --> 00:00:35.760
+where you write a fictional assembly language
+
+00:00:35.760 --> 00:00:37.280
+into a grid of cells which can each
+
+00:00:37.280 --> 00:00:39.480
+communicate with one another,
+
+00:00:39.480 --> 00:00:41.200
+you're tasked with solving
+
+00:00:41.200 --> 00:00:44.960
+fairly simple CS 101 like problems.
+
+00:00:44.960 --> 00:00:48.440
+To mix things up a bit I decided to base
+
+00:00:48.440 --> 00:00:49.800
+the language of asm-blox off of
+
+00:00:49.800 --> 00:00:52.520
+WebAssembly, which is stack based,
+
+00:00:52.520 --> 00:00:55.360
+as opposed to TIS-100 which is registered based.
+
+00:00:55.360 --> 00:00:59.200
+Here you can see the same program
+
+00:00:59.200 --> 00:01:01.680
+written in the game TIS-100,
+
+00:01:01.680 --> 00:01:03.960
+what it looks like in asm-blox,
+
+00:01:03.960 --> 00:01:08.040
+and the original WebAssembly that it's based off of.
+
+00:01:08.040 --> 00:01:10.640
+With that said, let's get into a demo.
+
+00:01:10.640 --> 00:01:12.240
+This is the game board.
+
+00:01:12.240 --> 00:01:14.120
+It's a 4 by 3 grid.
+
+00:01:14.120 --> 00:01:16.840
+Each cell has a stack of size 4.
+
+00:01:16.840 --> 00:01:20.280
+First off, I'll show some of the stack editing commands.
+
+00:01:20.280 --> 00:01:23.760
+We can add a value with the const function.
+
+00:01:23.760 --> 00:01:27.480
+Here we're adding two values to this stack
+
+00:01:27.480 --> 00:01:33.400
+to get added, and eventually the stack gets overflowed.
+
+00:01:33.400 --> 00:01:37.360
+We can fix that as follows with the clear command,
+
+00:01:37.360 --> 00:01:40.720
+so that clears the stack.
+
+00:01:40.720 --> 00:01:43.200
+We can duplicate values on the stack.
+
+00:01:43.200 --> 00:01:45.600
+This duplicates the item at the bottom of the stack.
+
+00:01:45.600 --> 00:01:48.880
+10 gets put on, 20 gets put on,
+
+00:01:48.880 --> 00:01:50.200
+then 10 will get duplicated
+
+00:01:50.200 --> 00:01:52.680
+and put on the top of the stack.
+
+00:01:52.680 --> 00:01:55.920
+We can increment. For example, this increments
+
+00:01:55.920 --> 00:01:58.760
+the second to bottom, the second to bottom
+
+00:01:58.760 --> 00:01:59.920
+from the stack.
+
+00:01:59.920 --> 00:02:04.400
+So 10, 20, increment that, clear.
+
+00:02:04.400 --> 00:02:07.640
+That's basic stack operations.
+
+00:02:07.640 --> 00:02:11.000
+Next up, we have numeric commands.
+
+00:02:11.000 --> 00:02:12.560
+For example, here, if we add "add",
+
+00:02:12.560 --> 00:02:14.680
+it pops two values off the stack,
+
+00:02:14.680 --> 00:02:17.080
+adds them, and pushes the result on.
+
+00:02:17.080 --> 00:02:20.680
+Another way we can write this is as follows.
+
+00:02:20.680 --> 00:02:22.480
+We can have the add here
+
+00:02:22.480 --> 00:02:26.400
+and then nest the two constants,
+
+00:02:26.400 --> 00:02:28.520
+and then this does the same thing.
+
+00:02:28.520 --> 00:02:31.720
+First, the inner constant operations run,
+
+00:02:31.720 --> 00:02:35.520
+and then the outer add operation runs.
+
+00:02:35.520 --> 00:02:40.280
+We can nest as deeply as we want.
+
+00:02:40.280 --> 00:02:44.680
+There's also subtraction, multiplication, and whatnot.
+
+00:02:44.680 --> 00:02:46.480
+Next up are Boolean operations.
+
+00:02:46.480 --> 00:02:49.080
+Zero counts as true.
+
+00:02:49.080 --> 00:02:51.720
+Anything else--sorry, zero counts as false.
+
+00:02:51.720 --> 00:02:52.760
+Anything else is true.
+
+00:02:52.760 --> 00:03:01.840
+For example, this would give us false and true,
+
+00:03:01.840 --> 00:03:04.040
+so that result should be false.
+
+00:03:04.040 --> 00:03:06.120
+Zero gets put on the stack,
+
+00:03:06.120 --> 00:03:08.160
+one gets put on, and then the "and" operation.
+
+00:03:08.160 --> 00:03:12.840
+So there's also or, not,
+
+00:03:12.840 --> 00:03:17.760
+and various numerical comparison operations
+
+00:03:17.760 --> 00:03:21.400
+like greater than and less than.
+
+00:03:21.400 --> 00:03:22.880
+Next up are the port operations.
+
+00:03:22.880 --> 00:03:27.320
+We can send values to other cells as follows.
+
+00:03:27.320 --> 00:03:29.600
+Here we create a value
+
+00:03:29.600 --> 00:03:33.640
+and then send it right.
+
+00:03:33.640 --> 00:03:35.040
+Let's run this.
+
+00:03:35.040 --> 00:03:37.480
+The 10 goes on the stack,
+
+00:03:37.480 --> 00:03:38.480
+and then it gets sent to the right.
+
+00:03:38.480 --> 00:03:41.360
+Here it's waiting for this cell to pick it up.
+
+00:03:41.360 --> 00:03:44.360
+It can pick it up just as follows.
+
+00:03:44.360 --> 00:03:47.480
+So left... and then why don't we have it
+
+00:03:47.480 --> 00:03:49.520
+drop that value after it gets it.
+
+00:03:49.520 --> 00:03:53.920
+So the 10 gets sent to the right.
+
+00:03:53.920 --> 00:04:00.240
+This one picks it up and drops it.
+
+00:04:00.240 --> 00:04:03.200
+Lastly, we have control flow,
+
+00:04:03.200 --> 00:04:04.280
+which is a bit tricky,
+
+00:04:04.280 --> 00:04:06.880
+but with this visual,
+
+00:04:06.880 --> 00:04:08.440
+it helps explain it.
+
+00:04:08.440 --> 00:04:12.280
+There are two block constructs, "block" and "loop",
+
+00:04:12.280 --> 00:04:16.880
+and there's two jumping constructs, "br" and "brif".
+
+00:04:16.880 --> 00:04:23.120
+So if "loop" is jumped to,
+
+00:04:23.120 --> 00:04:25.360
+the control flow goes to the beginning,
+
+00:04:25.360 --> 00:04:26.520
+the top of the loop.
+
+00:04:26.520 --> 00:04:28.640
+If a block is jumped to,
+
+00:04:28.640 --> 00:04:31.520
+it goes to the end of the block,
+
+00:04:31.520 --> 00:04:33.640
+and these various blocks
+
+00:04:33.640 --> 00:04:36.520
+are identified by their level of nestedness.
+
+00:04:36.520 --> 00:04:40.640
+From the point of view of this jump statement,
+
+00:04:40.640 --> 00:04:45.160
+this "br" statement, this is block level 0,
+
+00:04:45.160 --> 00:04:46.440
+this is 1, this is 2.
+
+00:04:46.440 --> 00:04:49.560
+So here, "br 1" would be referring to this loop.
+
+00:04:49.560 --> 00:04:51.080
+What this [br 1] would do is,
+
+00:04:51.080 --> 00:04:54.000
+it would jump to this loop right here.
+
+00:04:54.000 --> 00:04:57.360
+If we were to do this [br 2], what this would do is,
+
+00:04:57.360 --> 00:05:02.680
+this would jump past this block right here.
+
+00:05:02.680 --> 00:05:09.880
+So as another example, this right here,
+
+00:05:09.880 --> 00:05:15.720
+this is a loop that generates increasing numbers.
+
+00:05:15.720 --> 00:05:22.640
+Let's see. Next up, we have modules.
+
+00:05:22.640 --> 00:05:26.280
+This is an example of a stack module.
+
+00:05:26.280 --> 00:05:28.760
+In addition to stack, there's also heaps.
+
+00:05:28.760 --> 00:05:34.560
+What this does is it allows us to create
+
+00:05:34.560 --> 00:05:38.080
+an extra stack that we can push and pop items onto.
+
+00:05:38.080 --> 00:05:41.240
+This one can have as large size as we need.
+
+00:05:41.240 --> 00:05:43.800
+Here it has a size of 20.
+
+00:05:43.800 --> 00:05:46.400
+It's taking values from up
+
+00:05:46.400 --> 00:05:51.080
+and exposing those values on the left.
+
+00:05:51.080 --> 00:05:57.080
+This loop right here, it generates numbers,
+
+00:05:57.080 --> 00:05:59.160
+and it's putting them onto the stack.
+
+00:05:59.160 --> 00:06:00.920
+We can see here that those numbers
+
+00:06:00.920 --> 00:06:03.200
+are being exposed to this cell right here.
+
+00:06:03.200 --> 00:06:07.040
+It's just taking values, and eventually,
+
+00:06:07.040 --> 00:06:11.200
+it's going to overflow and cause an error.
+
+00:06:11.200 --> 00:06:14.480
+That finishes the basic commands.
+
+00:06:14.480 --> 00:06:16.480
+Why don't we try solving this puzzle.
+
+00:06:16.480 --> 00:06:21.320
+The puzzle description is right here.
+
+00:06:21.320 --> 00:06:23.280
+We want to read a value from I.
+
+00:06:23.280 --> 00:06:28.480
+Send 1 to G if I is greater than 0.
+
+00:06:28.480 --> 00:06:30.800
+Send 1 to E if it's equal to 0.
+
+00:06:30.800 --> 00:06:32.440
+Send 1 to L if it's less than 0.
+
+00:06:32.440 --> 00:06:35.360
+And then all the other ones, we send 0 to.
+
+00:06:35.360 --> 00:06:40.920
+First things first, let's send the value we get
+
+00:06:40.920 --> 00:06:44.400
+from the input down as follows.
+
+00:06:44.400 --> 00:06:49.680
+Let's send that value right.
+
+00:06:49.680 --> 00:06:51.240
+You get from up.
+
+00:06:51.240 --> 00:06:54.320
+Okay. So next, we're getting a value on the left.
+
+00:06:54.320 --> 00:06:58.040
+Now we want to compare if this number is greater than 0.
+
+00:06:58.040 --> 00:06:59.800
+If it's greater than 0, we send 1 to G.
+
+00:06:59.800 --> 00:07:03.280
+Let's perform the greater than operation
+
+00:07:03.280 --> 00:07:08.080
+on that item we just got, and we're comparing it to 0.
+
+00:07:08.080 --> 00:07:11.680
+Now that result, we're going to send down,
+
+00:07:11.680 --> 00:07:13.880
+and we're going to send this original value
+
+00:07:13.880 --> 00:07:16.880
+we got from here to the right.
+
+00:07:16.880 --> 00:07:19.000
+Here, we do a similar step.
+
+00:07:19.000 --> 00:07:20.240
+We get the value from the left,
+
+00:07:20.240 --> 00:07:22.920
+but this time, we have to do an equal operation.
+
+00:07:22.920 --> 00:07:25.760
+Is that number we got equal to 0?
+
+00:07:25.760 --> 00:07:28.960
+We send that result down,
+
+00:07:28.960 --> 00:07:32.880
+and then send this number to the right.
+
+00:07:32.880 --> 00:07:38.040
+Lastly, we get this number from the left.
+
+00:07:38.040 --> 00:07:42.400
+Here, we need to compare if it's less than 0.
+
+00:07:42.400 --> 00:07:45.640
+We send that result down,
+
+00:07:45.640 --> 00:07:50.280
+and now lastly, we drop that remaining value.
+
+00:07:50.280 --> 00:07:53.080
+Okay, let's--oh, and then lastly,
+
+00:07:53.080 --> 00:07:56.040
+we need to send down the value we get up.
+
+00:07:56.040 --> 00:08:02.560
+Send down, up, send down, up.
+
+00:08:02.560 --> 00:08:04.760
+Okay, so let's try running this.
+
+00:08:04.760 --> 00:08:08.920
+Let's see. We notice that
+
+00:08:08.920 --> 00:08:10.360
+the numbers are coming in from I.
+
+00:08:10.360 --> 00:08:14.200
+They're going through our various conditions
+
+00:08:14.200 --> 00:08:18.160
+and should be sending all the correct values.
+
+00:08:18.160 --> 00:08:23.560
+It looks like we're not getting any errors so far.
+
+00:08:23.560 --> 00:08:26.680
+Let's speed this up.
+
+00:08:26.680 --> 00:08:33.040
+That completes the puzzle.
+
+00:08:33.040 --> 00:08:42.000
+Now let's get into some of the implementation details.
+
+00:08:42.000 --> 00:08:46.320
+The first thing is the game loop.
+
+00:08:46.320 --> 00:08:50.560
+The game loop is... So this is actually extremely simple.
+
+00:08:50.560 --> 00:08:52.320
+All the state for the entire game
+
+00:08:52.320 --> 00:08:54.400
+is stored in just a few variables.
+
+00:08:54.400 --> 00:08:56.480
+There's one variable storing
+
+00:08:56.480 --> 00:09:01.400
+the text of each cell as a vector of strings.
+
+00:09:01.400 --> 00:09:06.280
+There's a single function
+
+00:09:06.280 --> 00:09:09.080
+that renders the entire game, the entire board.
+
+00:09:09.080 --> 00:09:11.120
+There's a single function that would render
+
+00:09:11.120 --> 00:09:13.920
+this entire screen based off of the state,
+
+00:09:13.920 --> 00:09:19.240
+and then the game waits for you to press a key.
+
+00:09:19.240 --> 00:09:24.120
+The key usually, depending on what action you perform,
+
+00:09:24.120 --> 00:09:27.040
+updates the state and causes a re-render.
+
+00:09:27.040 --> 00:09:29.360
+It's an extremely simple game loop,
+
+00:09:29.360 --> 00:09:32.800
+but it makes implementing it pretty easy.
+
+00:09:32.800 --> 00:09:35.200
+To demonstrate how this game loop works,
+
+00:09:35.200 --> 00:09:38.400
+I have a simple demo prepared.
+
+00:09:38.400 --> 00:09:41.880
+This is a game of tic-tac-toe.
+
+00:09:41.880 --> 00:09:44.800
+Let me show this real fast.
+
+00:09:44.800 --> 00:09:49.200
+It's an extremely simple implementation,
+
+00:09:49.200 --> 00:09:51.465
+but it follows the same principles
+
+00:09:51.466 --> 00:09:53.600
+that I used in asm-blox.
+
+00:09:53.600 --> 00:09:57.680
+First, we have the state defined in variables.
+
+00:09:57.680 --> 00:09:59.560
+Here we have two pieces of state.
+
+00:09:59.560 --> 00:10:01.600
+We have which player's turn it is
+
+00:10:01.600 --> 00:10:03.120
+and the state of the game board.
+
+00:10:03.120 --> 00:10:06.640
+The player turn can be nil if it's empty,
+
+00:10:06.640 --> 00:10:08.760
+the string "x" or the string "o".
+
+00:10:08.760 --> 00:10:14.240
+Then the game board is a list of nine board elements.
+
+00:10:14.240 --> 00:10:16.960
+So that's the state.
+
+00:10:16.960 --> 00:10:18.120
+Then we have a helper function.
+
+00:10:18.120 --> 00:10:19.440
+You can go into the details,
+
+00:10:19.440 --> 00:10:21.000
+but it just returns true
+
+00:10:21.000 --> 00:10:25.600
+if the board has a winning player.
+
+00:10:25.600 --> 00:10:30.040
+Part two is the rendering function.
+
+00:10:30.040 --> 00:10:32.800
+Only based off of the game state,
+
+00:10:32.800 --> 00:10:36.720
+we have a function that erases the buffer
+
+00:10:36.720 --> 00:10:40.280
+and draws this from scratch.
+
+00:10:40.280 --> 00:10:45.320
+That's this part right here.
+
+00:10:45.320 --> 00:10:46.720
+Lastly, we have the action.
+
+00:10:46.720 --> 00:10:51.920
+We have one action which is bound to RET,
+
+00:10:51.920 --> 00:10:55.840
+and it places a player token.
+
+00:10:55.840 --> 00:10:59.920
+Once it places a player token,
+
+00:10:59.920 --> 00:11:03.120
+it rerenders the board,
+
+00:11:03.120 --> 00:11:06.880
+and all the rerendering is handled by this function.
+
+00:11:06.880 --> 00:11:12.480
+Then we have just creating of the mode
+
+00:11:12.480 --> 00:11:14.680
+and initialization function.
+
+00:11:14.680 --> 00:11:16.680
+With these three steps
+
+00:11:16.680 --> 00:11:20.640
+it clearly separates out all of the state,
+
+00:11:20.640 --> 00:11:22.960
+the rendering, and the actions,
+
+00:11:22.960 --> 00:11:25.880
+and it makes implementing it very simple.
+
+00:11:25.880 --> 00:11:29.640
+One trick that's used here and that I use
+
+00:11:29.640 --> 00:11:32.382
+in my asm-blox game is that
+
+00:11:32.383 --> 00:11:33.316
+when I render the board,
+
+00:11:33.317 --> 00:11:40.800
+I propertize the text to contain extra information.
+
+00:11:40.800 --> 00:11:45.080
+For example, here, each cell has
+
+00:11:45.080 --> 00:11:49.400
+a tic-tac-toe index to indicate which number cell it is.
+
+00:11:49.400 --> 00:11:53.640
+This has index 0, 1, 2, all the way up to 8.
+
+00:11:53.640 --> 00:11:58.640
+That way, for placing, the only thing it has to do
+
+00:11:58.640 --> 00:12:01.200
+is just look at its position
+
+00:12:01.200 --> 00:12:04.960
+based off of the text property.
+
+00:12:04.960 --> 00:12:07.800
+It makes implementation extremely simple.
+
+00:12:07.800 --> 00:12:14.360
+Next up, we have the implementation of the code cells.
+
+00:12:14.360 --> 00:12:16.960
+If you notice, here it's kind of weird
+
+00:12:16.960 --> 00:12:21.000
+how it's like a buffer, but each cell kind of acts
+
+00:12:21.000 --> 00:12:25.760
+like its own buffer, and it has its own limits.
+
+00:12:25.760 --> 00:12:27.600
+All of the Emacs editing--
+
+00:12:27.600 --> 00:12:30.760
+well, some of the Emacs editing commands kind of work,
+
+00:12:30.760 --> 00:12:35.360
+like beginning-of-line, end-of-line, end-of-buffer.
+
+00:12:35.360 --> 00:12:38.240
+How is that done?
+
+00:12:38.240 --> 00:12:41.760
+Well, it's all just a trick, actually.
+
+00:12:41.760 --> 00:12:47.280
+Each cell has text properties of which line it's at
+
+00:12:47.280 --> 00:12:48.800
+and its cell coordinates.
+
+00:12:48.800 --> 00:12:54.360
+Whenever a key is pressed for editing, moving lines--
+
+00:12:54.360 --> 00:12:58.360
+there's even kind of more complicated things
+
+00:12:58.360 --> 00:13:00.600
+like switching cells around--
+
+00:13:00.600 --> 00:13:03.360
+so all of that,
+
+00:13:03.360 --> 00:13:05.200
+it knows which position it's in,
+
+00:13:05.200 --> 00:13:08.080
+it knows what cell it's in,
+
+00:13:08.080 --> 00:13:12.880
+and then it copies the text of the cell,
+
+00:13:12.880 --> 00:13:16.320
+because remember, the contents of the cell
+
+00:13:16.320 --> 00:13:18.360
+are stored in internal state.
+
+00:13:18.360 --> 00:13:23.000
+It copies that cell contents into a temporary buffer.
+
+00:13:23.000 --> 00:13:27.960
+It then moves the point to whichever line it was
+
+00:13:27.960 --> 00:13:31.160
+in the game board.
+
+00:13:31.160 --> 00:13:33.000
+It performs the action.
+
+00:13:33.000 --> 00:13:36.200
+It makes sure that the resulting text isn't
+
+00:13:36.200 --> 00:13:40.160
+longer than the cell width or the cell height.
+
+00:13:40.160 --> 00:13:42.040
+If everything checks out,
+
+00:13:42.040 --> 00:13:45.120
+it updates the state and calls a re-render.
+
+00:13:45.120 --> 00:13:48.440
+So there's nothing going on in here
+
+00:13:48.440 --> 00:13:51.080
+that's, like, actually inserting a letter A.
+
+00:13:51.080 --> 00:14:00.920
+It's all updating the state and causing a re-render.
+
+00:14:00.920 --> 00:14:03.640
+So this makes things like certain
+
+00:14:03.640 --> 00:14:06.480
+internal Emacs editing constructs
+
+00:14:06.480 --> 00:14:09.120
+pretty hard to use, like undoing.
+
+00:14:09.120 --> 00:14:12.200
+Normally the undoing construct
+
+00:14:12.200 --> 00:14:15.120
+works off the contents of the buffer.
+
+00:14:15.120 --> 00:14:17.840
+But if your buffer is actually just
+
+00:14:17.840 --> 00:14:20.080
+a reflection of the internal state,
+
+00:14:20.080 --> 00:14:21.440
+then how does undoing work?
+
+00:14:21.440 --> 00:14:24.880
+Well, it pretty much is kind of a hack.
+
+00:14:24.880 --> 00:14:27.040
+I mean, undoing is here,
+
+00:14:27.040 --> 00:14:32.680
+but it's pretty much redone
+
+00:14:32.680 --> 00:14:37.560
+in a not so configurable, not so modifiable way.
+
+00:14:37.560 --> 00:14:40.080
+Pretty much everything is like that,
+
+00:14:40.080 --> 00:14:42.440
+from these parentheses highlighting...
+
+00:14:42.440 --> 00:14:46.320
+Normally, parentheses highlighting
+
+00:14:46.320 --> 00:14:47.243
+would be kind of weird,
+
+00:14:47.244 --> 00:14:49.840
+with cross-line parentheses and everything.
+
+00:14:49.840 --> 00:14:52.360
+All of that had to be redone.
+
+00:14:52.360 --> 00:14:58.160
+Another point about how this is implemented
+
+00:14:58.160 --> 00:15:02.360
+is the assembly text to executable code.
+
+00:15:02.360 --> 00:15:05.800
+If you're familiar with WebAssembly
+
+00:15:05.800 --> 00:15:10.720
+you might have encountered a tool wat-wasm.
+
+00:15:10.720 --> 00:15:16.440
+It basically converts the WebAssembly text format
+
+00:15:16.440 --> 00:15:18.280
+to byte code.
+
+00:15:18.280 --> 00:15:22.440
+And what I do here... It goes through a similar process.
+
+00:15:22.440 --> 00:15:28.000
+Normally, when you're writing this text format,
+
+00:15:28.000 --> 00:15:30.360
+you can nest things as deeply as you want.
+
+00:15:30.360 --> 00:15:33.800
+Basically, what happens is it flattens out everything.
+
+00:15:33.800 --> 00:15:35.920
+It kind of knows the order
+
+00:15:35.920 --> 00:15:38.160
+that all these things are going to get executed,
+
+00:15:38.160 --> 00:15:40.680
+and then it puts it into one single line
+
+00:15:40.680 --> 00:15:44.120
+that it can just run through and execute.
+
+00:15:44.120 --> 00:15:48.360
+The same thing for the loops and blocks.
+
+00:15:48.360 --> 00:15:52.240
+It internally generates labels and jump statements.
+
+00:15:52.240 --> 00:15:58.640
+So that concludes this presentation.
+
+00:15:58.640 --> 00:15:59.666
+Thank you for listening,
+
+00:15:59.667 --> 00:16:07.440
+and I hope you enjoy the rest of the conference.