 The T2tile project is building an indefinitely scalable computational stack. Follow our progress here on T Tuesday updates. Our top stories this week, like every week in November, still doing NaNoRemo, the national novel writing month. It is now day 19. How do we know that? It's because November 19th. I committed to try to write a 50,000 word novel from scratch in the month of November. I'm not going to make 50,000 words almost surely. But I'm writing the best effort, titled Science Fiction Novels, best effort and it's, you know, every day. It's every day. So here's my current progress. The dotted line is what I would need to do if I was going to be hitting 50,000 words by the end of the month. I'm running about 10,000 words behind. But lately, I'm actually kind of, my slope is improving a little bit. There is a distressing horizontal line here. And in fact, let me see it down here, yeah. So I had been putting my, upload your word count to the NaNoRemo website and it keeps track of your statistics for you. I had much more detailed statistics on my own, but just at the end of each day, I was uploading my number to tell them about it. And so on the 14th day, I was actually kind of getting into it. I was actually kind of getting in a flow rather than just worrying about how many words I had as the day ran out at midnight. And I missed midnight by, you know, a half a minute. I don't know. The clock still said, clock said midnight, not 11.59. So the thing here is I have a tremendous number of words on the 16th and it gave me zero words on the 15th. So what, well, what it means is I have broken my streak. I would have been in line to get the 14 day in a row update badge instead, and I'm back at one day in a row. And so the 21 day in a row badge for NaNoRemo 2019 is now off the plate for Dave. I could still get the 14 by starting a new streak that lasts to the other one. And the way it always works, you know, if you're gaming the system, of course you game it properly. But if you're actually getting serious about stuff, you know, oh, I couldn't be bothered to hand it in on time. So that happened. But this is what my own internal graph looked like last week, curling off at around 12,000. This is what it looks like now. We're pushing 20,000 words someplace close to that. I've also added a linear regression that it turns out the new plot, the new plot can compute for me at least in later versions. I didn't know that. It was pretty nice. And that's actually the thing that's really driving me now, you know, am I above my regression line or below it? And so the thing to focus on is this period right here, you know, these two periods of, you know, pretty fast, you know, it was the flow, it was a scene that actually came out relatively easily again and then and then moan and groan and moan and groan and then kind of another scene that was working on today. And so forth. So we'll see again, the whole thing is taking so long that oh yeah, and so I'm at a thousand words a day, it's going up a little bit every time I have more time with the thing above the line, we'll see how it goes. If thousand words a day means 30,000 words in a month in November, that's a lot of words. The goal is to get to something that could somehow finish even if it ends just ends up just being like volume one or something like that, but to pull off an ending, we shall see. So right. And last week it was telling me I was going to be done on December 25th at this rate. This week it's telling me I'll be done on December 16th. That's progress. All right, so that's Nano Remo. What I thought I would do today since I don't have any real other work to talk about is follow up on something from the Gitter, the chat room. Last week I mentioned that Anton Mikhailov was was doing back on hacking the GPU, the graphics processing unit stuff to do this more modern version of the thing to get around the bug that he ran into and so forth. And he posted some pictures of his progress on that. So this was a picture of the initial state of a single cell seed that pops out to, well, I don't know if he's got a seed or not, but this thing has got one content in the middle, a ring about inner membrane, a ring about a membrane around that, which was then growing into this like brain or cauliflower thing because he'd only implemented some of the rules that the total C211 proto cell consists of a bunch of rules. I don't know how many 30, 40 I never actually counted that each do various little bits. And since each event just takes place in a tiny little event window on one of these things, each pattern is concerned with doing something reasonable to make this particular pattern better, make it more like we think it ought to be and so forth, which makes it really difficult to figure out how they're all going to interact once you have them there and they all start up. Now, you know, that could be a criticism of this kind of programming of this kind of spatial programming. But on the other hand, you know, the dirty secret of computer systems, information technology systems is, of course, they actually all their pieces that are supposedly modular, supposedly separate software, they all interact too. But they only interact through the system once you put it all together and that everybody's just pointing fingers at each other that, well, you didn't implement the interface correctly. Well, you didn't interface it, implement the spirit of the interface correctly. In the meantime, you know, the plane crashes or the thing doesn't run whatever it is. So with this approach, the explicitly spatial approach, you know, we're seeing the interactions immediately because we're engineering the interactions. We're asking how do we want to make it go to turn out the way that we're going to like it? And so having the ability, I mean, this was just sort of happening as a matter of experience. Here's a giant picture of the set of rules that Anton had gotten when he was first getting this stuff working. And Luke was coming in and saying, you know, this is really great. And in particular, thanks for showing these work in progress stages, you know, just the growing stuff without the shrinking stuff and so on. And, you know, so there was discussion back and forth and Anton was pointing out, you know, that it isn't really stages. It doesn't work in stages. You know, here's the particular file and so forth. Anton says, maybe once Dave is back, he can give us a tour of what makes it tick. Luke, don't tempt him and so forth. And so, okay, thank you guys. Yes, I thank you. Why am I not writing? Well, I'm not writing for another 10 minutes or eight minutes here because I'm talking to you guys. So, but this gave me an idea. And the idea was wouldn't it be good, just as a debugging thing, as an understanding thing and so forth, if in any SPLAT program, and now I haven't implemented this yet, but to just be able to turn on and off individual rules. So for like any rule in the whole thing, you could say, I want this rule to be enabled, I want this rule to be disabled, which would mean it's just as if that rule failed, even if it didn't, because we won't even do the match, or third case, have the whole thing fail at this point. So go ahead and do this rule as usual, succeed or fail, call this rule of failure and go on to the next one, call the whole event failure, stop here. Like that. And so I could kind of simulate it by writing actual code. So that's what I did. And so this is Q mem brain dot SPLAT, which is the single file that has the most rules related to the C 211 digital proto cell, which we, you know, goes all the way back to 2017 now, I guess, in its earliest stages and so forth. That is, you know, sort of saying this is what a two dimensional digital cell, something, it's just a framework for holding stuff. Okay. And so each of these rules, I can't go through and explain each one because you actually have to read the code. I mean, these look like they're deceptively simple. So you think you ought to be able to read them off, but in fact, they're code and they're, they're code of a different style. So actually did I have, I had some, yeah, here we are. So here's a few thoughts about how to interpret the C 211 proto cell, what it's doing and how to think about it. So the first one to think about is we're not thinking about stages in time that first do this, then do this, then do this, which again, is much more typical of traditional programming where you have serial determinism step by step through time. Instead, we think in terms of forces, how do we want to push this thing? How do we want to let ourself be pushed on and let the system itself resolve the forces, however it will, and then we'll observe whether they do what we like. So once we say that we're focusing on the forces, then we're going to have to admit that the interactions between the forces matter. That's what I was talking about before. And the key to the C 211 is you look at it, you see the cell membrane, you say, oh, that's a bag containing some stuff. And that's probably not the best way to think about it. The way to think about it is you have some content that has this fence around it, it's not a wall, it's a fence in the sense of good fences making good neighbors. The membrane around it serves to tie up some space between this content and anything on the outer side that allows us to keep score, that this thing is inside, that thing is outside, and so forth. It is not actually in charge of holding the stuff in. In fact, it's the content that decides should we go left, should we go right, it's not the membrane around it that does anything. And the way the content, the way the membrane knows what to do is by estimating the density of the content inside. And so that's all right. So those are those are the general points. And so here are the rules that end up doing it. There's so, for example, here, a given a vote E is an empty means every time we see an E in a rule, we'll count one vote for E. And we can say if is the number of empties greater than, what is that, three halves, is it more than three, one and a half empties, something like that, the total number of sites, E will be true if the number of empties times three is greater than or equal to the number of sites times two. Yeah, okay. So we don't have to be all empty, but we need to have a preponderance of empty. So that check rule is a proxy for saying I think there's low density among the E's. So when we have a rule down here, whereas here's one right here, this is a really important one that says here's a bunch of E's on this side. There's a bunch of F's on the other side, which do a similar thing about measuring fullness. So if it's kind of low density on one side, kind of high density on the other side, that means we should move the membrane further away from the high density. And there's similar rules to say if there's low density on the inside, we should move it in. So what I did was I created a bunch of model parameters. Where are they? Here they are. Like P growth, okay, and so forth. So now we can turn on and off individual rules. So let's take a quick look at it before we run out of time here. So I'll make a seed. We'll get it going. And here are my parameters. Okay. So this is a typical thing. Everything is turned on and so forth. But now we can, like, suppose we turn off the grow rules, the rules that have the outer membrane get further away to make more room. Now, in fact, the density starts rising higher and higher and higher, and the thing gets all jammed up. Well, that actually makes sense. So we'll turn that off. What if we turn off the shrink rules that are controlling when the density is low and it wants to move in? Now, unfortunately, the way I implemented the Q membrane, it's got some rules in there which aren't sort of obviously shrink rules. In particular, there's rules that say, you know, every inner membrane should have an outer membrane next to it somewhere. That's part of the beauty of having a two layer membrane is that you get all of these local redundancies. Every outer membrane should have an inner membrane next to it somewhere and vice versa. And that allows us to thin out and simplify things just based on our local views of stuff. So the general shrink rules are actually needed to get those extra inner membrane to go away. So they go away and now the thing loosens up. There's another one. So here it is, enable, and this was the rule I was just talking about. This is the rule that says every inner membrane needs an outer membrane next to it, and if an inner membrane finds itself without an outer membrane next to it, it'll actually go away. And we get the same kind of behavior where it starts crowding up. It happens more slowly, but it happens in the same way because all these guys in here, these inner membranes that do not see any outer membranes around them, we're just sitting there clogging it up. And this is an example of the way the forces interact with each other. Just because they don't clean themselves up, that means there isn't enough room for the content to move around. So the thing jams up and so forth. Once again, we turn the invariant rule back on and there we go. So that's not an actual explanation of the whole thing. We would have to actually go through blow by blow code review kind of stuff to make more sense out of it. But it's a little bit of the flavor that you're going to pick the forces that make sense that you can. And then you're going to add enough structured redundancy. I mean, you could have a membrane that was just one layer thick, but by having it two layers thick, you can tell which is inside and which is outside and do all of these invariant checking and testing locally. Okay. For what that's worth. The next update, there's still two more updates. No, one more update during nano-remo, but back in a week. Thanks for coming. Hope to see you next week.