 Hey folks, it's T Tuesday 31 26 we are at T minus 9 updates before we get to our artificial life creation coming up in January 2023. Take a look at this for that it just bounces around for a little while. Here we are on the spreadsheet leading all the way up to grandchildren for the ancestor. We're going to write a program that's going to run on the T2 tile grid. That is going to copy itself and its program to produce kids and those kids are going to copy themselves to produce grandkids. We'll see if we actually get there. So these were the goals for this time chain loops grow beyond four links. What the heck is that? Well, that's what we just saw and that's what I'm going to talk about mostly today. Build the cell wall. I did not do that. In fact, I went the other direction and I took away the cell wall that I have been messing around with. So in the demo that we just saw in the video clip that we just saw, there was no cell wall. So once again, there's only one diamond matrix in the whole grid. OBS workflow refresh. I did some of that. It still needs more work, but at least we've got some new buttons set up for some more clips and so on. Have some fun. I did mixed bag. The getting this chain loop stuff going was frustrating, but well, it felt better when I finally got there. So why do we need chain loops at all? Well, the idea is the big picture, right? We're going to start with some diamond matrix that represents the mother. It's going to grow. It's going to move around. It's going to move its stuff eventually split and end up with two and that copying step in there is going to be copying the code that is governing the reproduction itself code guided reproduction, including reproducing the code. And that code, that digital DNA, I'm calling it, is what we're going to use this chain loop for what we were just seeing. So here's the title card for today, engineering digital DNA, you know, and there it is. So we've got this loop going around and, you know, this is not meant to be a model of real DNA at all. You know, there's no helixes, no backbones, no GADC, nothing. It's all very abstract and essentially what we want to take away from DNA is that it's essentially one-dimensional. It's essentially a line, even though, yes, it has the double helix and so on. But from step back, it's copied linearly in a line. It's transcribed, turned into other stuff in a line and so forth. And we're going to do the same thing here. So okay. And speaking of which, you know, so we had all these little lines, which was very handy to help us to see how the loop was growing in the opening video. I want to talk about where those lines came from because, well, I mean, for one thing, you know, none of the stuff that we're going to see today is running on the T2Tile grid itself or, I mean, it is running on the T2Tile grid itself, but it just started like today or last night. So there's nothing yet to see and I want to make some changes to it anyway. So all the stuff we're going to see today is in the MFMS simulator, which has the virtue that it's easier to play with and we can see it. But, you know, this is the exact same picture if there weren't those lines. So it's like good luck trying to figure out who's connected to who that way. So the lines really helped. So I wanted to just show a little bit about that. So here is the MFMS simulator. I've got this thing set up. If we let it, let's see, let's let it spread out if we can. Okay, beautiful. So there it is. So it popped its first little loop and it looks a lot like what we saw in the opening video. Now it's gone up to four. Now it's at six. But look at this, you know, the MFMS simulator. So where did those lines come from? Well, they came from this custom graphics button. We can click it and they go away. So basically you can write code to say that when it's time to draw a picture of an atom on the screen, you can get in and add your own stuff. And that's what I wrote for this thing to draw a long line, heading one direction out of the one, so heading in the, oops, where are we going here? The long side is the logical downstream. The short side is logical upstream. So if you work at it, you always have a short one next to a long one, a short one next to a long one. So in this case, if we go clockwise, we're going upstream. If we go counterclockwise, we're going downstream. But that just happened to be because of this particular one. And so let's see. So we can reconfigure this. So if we, let's see. So we're going to make the, oops, I went all the way around. So we'll make the back dark so that we can see what's going on. All right, dark, there it is. And we turn the middle display. That's the circle part. We turn it off completely, change the side paint none, and we change front. That's a little bitty square that we put in the center of things there like that. And now look at this. Now we have essentially just the representation of the custom graphics that we wrote. The long line meaning downstream, the short line meaning upstream. The little dot in the middle meaning whatever particular type it is. And it's actually a lot easier to see what's going on with this. So this is a nice thing. And in fact, I mean, all this stuff will work on the tile as well. It's just, you know, we don't have the virtue of all these buttons that we can change and configure it on the fly. Because the whole point of the grid is that it works by itself. All right, and this thing is going fine. So that was the demo. And yes, and here's a sample of what it looks like coming out of this. And you know, the life lesson for this is that this work beats debug work. And this is just in the kind of programming I do, the sort of open-ended research programming. Time invested, improving visualizations always pays back multiple in improved debugging, easier debugging, seeing bugs quicker. So that's what happened here. So that was nice. All right, moving on. So the basic problem, how are we actually going to grow one of these loops? Now, you know, DNA in actual life is, you know, some of it is arranged in a circle in a loop. But a lot of it isn't. I'm designing the chains that we're using here to be stored in a loop and to be generally used in a loop, although we'll be able to pop them apart and do other things with them as well. So the basic idea is, you know, if we have a thing going along, we want to take a single segment and replace it with the other three sides of the box. So here it is. Here we have the minimum case of a demo atom connected to a new grow atom. I hate calling things new because, of course, in 10 minutes it's not new anymore and then you have to make super new and post new and post new post and so forth and so, but in this case, I had already built like three full implementations of this stuff and nothing was working the way I was like it. And I was getting really cranky about it. So I let myself call it new just to express my crankiness. So the grow atom pops out a new corner. The new corner tries to pop out a new side. The new side realizes it can hook up to the original base and it can make the square and that's how it works. But there is another problem. So here's a similar case. The grow pops out a corner and the corner wants to pop a side going down. But there's something already there. What are we supposed to do about it? Well, you know, we're supposed to be best effort. We should do something so, you know, we can wait. Now in this case, that SE, that's a seed that in fact is going to go away in another dozen or so events. We could just wait it out and then continue and get the job done. So I worked around trying to figure out what to do. You can make a counter, but then that takes a bit and then you have to decide how big a counter you want. So how long should you wait? What I ended up doing was saying, let's, you know, let's wait a good long time because we're trying to do this. We've already built a bunch of stuff. So I said, you know, 2% of the time if one in 50 hits, then we'll just give up because it's blocked. Otherwise, we'll just bounce around, hope things get better and so forth. And that was the clip that we saw in the opening. Here, I've got another clip that we can see using the new display. Let's take a look at that. It's nice, huh? You know, so this, this is one big box in a single tile that's basically the same size as the Diamond Matrix, so it can only go back and forth. And anyway, we see it growing out. We've got these yellow and these blue, green things. Those are two different kinds of temps. At the moment, we're growing this loop, but we're not filling it with anything. So those are all basically just temps available that are cycling around to do it. And eventually, it mostly fills up the matrix, which, you know, the loops that we're going to use for our code will never really do that because we have plenty of other things that we need to have inside the matrix as well. But for this demo and so on. So that looked pretty good. Okay. As I was debugging it, I was starting to realize, you know, this is taking forever to find that last available spot because it has to work a new grow all the way around the ring. It has to try here, try here, move on, try here, try here until eventually it gets next to the one spot where it could actually grow again and takes forever. And eventually, I realized that thinking about my best effort. Maybe I was thinking about it wrong and I ought to be thinking, don't worry, be crappy. The expression from Guy Kawasaki is sort of tech evangelist and a Mac guy and early days of Apple and so forth. Don't worry. An innovator doesn't worry about shipping with elements of crappiness if it's truly innovative. Well, you know, the movies machine, the teacher tile has plenty of crappiness in it, but yeah, it's truly innovative. So all right. So I said, you know, eventually I said, you know, let's change these odds. You know, why are we beating our heads against this wall? If most of the time it is not a seed that's going to disappear in a few events, most of the time it's another part of the loop, which isn't going anywhere. So eventually I said, you know, 75% of the time, try again just in case, but 25% of the time, let's move on. And here's a result actually comparing the one that we just saw with this new approach. So the one in the upper left is the stuff that we just saw. And then here is the newer one. And it's it's like a day and night. The. This guy has got a quarter full. This thing has barely got started. These are being displayed at the same time compression rate. This is displayed in cubic time, so that as, you know, five seconds goes by something proportional to five cubes, how much time is best in the simulated world. There it's essentially done. And in fact, I started it over to have another. And so, you know, now we'll see it in a second. There that was actually a failure, but the failure was not due, I believe, to the the change in the probabilities. The probabilities just made it easier for it to turn up. So there's still more work to be done. All right. Yeah, you know, this is a screen grab from the T minus 10 update from last time, you know, and it doesn't look really great. These things that are hanging over on several different segments and and yarn, I'm not going to try to say your last name, you know, who has been following the project and contributing for a long, long time. Thank you, you know, had this comment, you know, it was possible to try to make it. And it's a little easier to see what's going on. And I had been thinking that too. So I did a little test. So here's here's what it is. I just took it into the image program and I took the LCD images and scaled them up a little bit and plopped them right down back in the same place. I got something like this, which actually taught me stuff that I didn't know before, that if you take the size of the pixels, the sites on the LCD as defining the X and Y length scale, then the T2 tiles are a little bit too tall for the number of sites they have in the rows. We shall see. I did some early tests on this, so writing some scripts to try to get this to happen using FFMpeg. We'll see if it's going to work out. In other news, the new computing up just came out yesterday. Another thing to get done was a fun conversation. If you have room for podcasts in your daily schedule, you might give it a try. This was a particularly fun conversation. In addition, Andrew Davidson, who's a hero of mine, he developed SLAM, so simultaneous location mapping, did a bunch of computer science stuff. He posted a thing and we had a little interaction on Twitter and he loved my stuff. So that was really great. And I'm going to hope to get in touch with him and who knows, we'll see maybe he could be on computing up one day. And that's it. The next update will be in two weeks on August 16th. The goals for then are actual loop operations, not just growing until there's no more room to grow, but actually moving things around, maybe even cutting and putting stuff together and stuff like that. The things that we'll need to do to do the master plan to reorganize code, copy it, that sort of thing. It's time to get back to the cell borders and try to make them better. If we're lucky, we'll have a debesalification demo so that we can see stuff running on the actual T2 grid and maybe it'll look a little easier to see. And that is it. And we'll try to have some fun and I will continue here as usual in the live stream. After this is over, I just want to get this rendering. Thanks for coming by. I hope everybody's doing OK. Hope to see you next time.