 The T2 Tile project is building an indefinitely scalable computational stack. Follow our progress here on T Tuesday updates. So, I'll change the music one of these days. That is displayed in cubic time, so for x amount of seconds that we actually watched, it corresponds to x cubed amount of actual simulation time, so it really makes everything all happen at the end. I should probably, I think, go back to quadratic time, but it's difficult to figure out a good way to see the dynamics, but that was not what I wanted to show you. That is growth and development. What I was hoping to show you was programmable code decoding. Let's find out why we didn't see that and what we saw instead. All right, so almost two weeks ago, I got started on this to code representations and operations. I've been thinking about this for years, one way or another, and I keep assumed that what was going to happen was I was going to go back and eventually I'm going to get to the point where I'm going to implement a regular processing unit with registers and add instructions and ALU, arithmetic logic unit, operations and so on. And now is the time. But then every time I actually sat down to try to do it, something blocked me. I didn't like it. It just didn't make sense. One of the things I was saying, one of the things that's weird when you do artificial life at the artificial chemistry level, you need an initial replicator that you hand code in whatever your underlying physics is that moves things around and to be able to make a copy. And that has to come from nowhere. It comes from the mind of God because whatever billions of years of evolution would take to come up with that thing, we're skipping for purposes of the simulation for purposes of the research. But with the rules that I've adopted for the T2Tile project, where all you do is you click one button and it creates one instance of one atom called S, where is the replicator? The replicator has to be stored in the code space somehow. So I set out trying to say, can I make an array of atoms so that an element is the specific type of something that has properties and can do behavior and so forth, but then atom is just a generic object that can hold any element, one any element. So can I make an array of atoms that would just be preloaded with the sequence that the replicator was going to use? Well, it turned out, no, couldn't quite do it. Ulam wouldn't let you do it. But hey, one of the really nice things about having the lead compiler developer in the same house is that you get responsive stuff going, and it is actually in the developed branch, there is now a constant atoms and constant array of atoms. So you can make constant classes for your specific whatever it happens to be. Here's a dreg. Here's a res. Here's a constructor. Here's a who knows what it is. Processing unit. And then you can make an array of atoms, and then we'd be able to have the seed that would sort of work its way through them and provide them to the outside world. That would be a way to get the replicator into the system. Didn't get that far, but the Ulam marches on. And we still haven't announced, we still haven't released Ulam 5. All of this stuff is becoming Ulam 5. Ulam 5 is a nice release. But at the moment, most everybody who I'm aware of that's actually doing Ulam stuff is doing it from GitHub on the develop branch, and that's where all the action is. All right. So the first thing I was trying to do was let's make a single quote. That's the way I'm taking an arbitrary atom and hiding it inside two atoms so that it can't act. It's quoted. It's data. And then I wanted to move those around, so I make a single quote forwarder that would take a chain of locations and it would move this thing along. And this led again from last time and the time before, I think, now. The idea of having these plates and you can reserve space in them in a corner, usually in the upper left hand corner, the way the layout is working, for an operator, an arbitrary type of atom. Well, it's not completely arbitrary. Inherit from the appropriate operator type, but that it's the one that actually controls what the plate does. And the plate has abilities to move and grow and die and take its subplates with it and so forth, but it doesn't actually do them. And by decoupling that and plopping an operator in there, we get a lot of flexibility in a reasonably natural way. So that's the 01 operator concept, right up in the upper left hand corner. And we could make our SQ forwarders more general. And it's always this fight back and forth. It seems right. And one of the problems with building out an arm, which is then going to carry things behind it, is that the front of the thing is always at nowhere. And this is the standard problem that if you want to have a transporter booth or a teleporter or something in a science fiction book, you need to have a receiver at the other end. It's the same thing here. When you're building out the stuff, you haven't got the receiver at the other end, so you have to keep doing it. So the deployment decisions, what to do next, is all ahead of what's been deployed so far. That's kind of the nature of it. And I went back and forth. Do I want to take you Adam apart? It's like you're shipping a package. You open the package. You say, do you want to go to the next stop and then close it up and move it on? I got in all kinds of trouble trying to make sense of this. I really don't know what I want. And it's this struggle between the generality of traditional central processing unit style programming and what this thing seems to be trying to tell me if I was just clueful enough to listen. And I started wondering, this is a very strange thing, right? So if I'm saying an Adam, an instance of an Adam is a sort of fundamental operator, a fundamental action in this programming language, well then, is the program supposed to be bigger than the code that the program represents? Putting them in single quotes makes the code twice as big as what's being coded for. So actually, I had to go look at DNA and the mass of amino acids and so forth. Actually, that seems like the, as far as I can tell, the triple DNA code on is actually pretty hefty compared to most of the amino acids that end up getting made. So I kept trying, you know, if I had a plate chemistry, then maybe I could have the things like the size of the plate and the position that this guy was supposed to be on the plate, the position that this being was supposed to be on the plate could be registers in this thing. And you load up the registers and do arithmetic on them and then say instantiate, you know, reify, become. And it would make one, you know, couldn't get it to work. Finally, I said, I'm going to just back off. And what I need to do, instead of thinking in terms of loops and accumulators and all of that essential assembler stuff of traditional programming, I need to think in terms of what are the processes of the system that you can build more complex processes, more useful processes on top of simpler processes. That's the bottom up way. And one of the things that I've been thinking about for a while is now that we have plates and plate tectonics and subplates and we can move them around, it would be really nice to have some kind of mechanism to position subplates within plates so that you didn't have to say, go to location 16 comma three and be with five and height two and so on but express it in some more functional way. And that was the subplate layout idea. So I went for to be able to, instead of specifying exact numbers of sites to be able to specify fractions, how big I would like to be relative to my container and that would allow the container, at least in principle, to grow and have all the pieces inside it grow with it. And that seemed like a nice thing to have. If we're gonna be building lifelike systems then rather than saying the deck is 16 columns by six rows, say it's 25% of the parent's width and 10% of the height or whatever it is. And so I went for that and I got it kind of going and it all felt so reminiscent of, for me, Tickle TK which was a really early language for doing visual computations. It's still used all kinds of ways today. I know the guy that was his work and it had layout managers. You have a whole bunch of windows and you wanna put a window in a window and put this one up against the left and put this one at the bottom, put this one in the middle, tell us when to take up all the extra space. That's exactly what I wanted to do with plates and subplates. I wanted to lay them out, pack them, say this one should stick to the left, this one should go in the middle and so forth. Tickle TK is where I first learned about it. Of course Java took over eventually and they went completely crazy with all sorts of layout managers and everybody's doing it. Even what we're looking at right here is one of these layout managers is one that I made it myself. But you see these windows really, this guy really wants to stick where it is at the moment. That's the layout that's at work. And so there's a deep, deep analogy here, that the reason that windows have to be laid out in two-dimensional space is so we can look at them, so putting them in relative spatial locations and worrying about their size and worrying about how they fit relative to their parents in some recursively nested way is exactly the same kind of thing we want to do with the plates, but not so that the eyes can lay upon them, but so that the widgets, the plates themselves can lay upon the execution hardware, the two-dimensional hardware underneath that's performing events. So this meant a lot of sense and it would be a next generation plate operator we still do. We're using the plate operator essentially on change, which makes me very happy to do the moving and the growing with the tectons and all of that sort of stuff, the border patrol. That stuff is just riding right on through and we're getting to the point where for more complex cases, we're using two operators, a plate operator in the upper one-one in the upper left-hand corner to do all that stuff, and then at one-two right underneath it a more specific like in the case of the Adam Deck operator in the last episode. So we ended up with sub plate operator that was job was to take relative coordinates and say I want to be 15% of the parent's width and 20% of the parent's height. It's not actually in percent because you want to save on bits, so it actually ends up being divided up into 14ths, 14ths in width, 14ths in height. That's what ended up working out. And it was a strange thing because so now the operator is inside the plate and so it's not enough for the operator just to look at its surrounding plate. It has to look all the way outside the plate that it's in. It has to look at its containers container to figure out what that size is to know what size it wants to be. So it worked out, it got it going. We have a plausible sub plate operator and that's what we were looking at. That's the demo for this update. Why were so we had to make little faces because why not, this is a plate that this is a new thing called color plate. It's just random colors, but it's doing all the same stuff. You saw that it was doing the border patrols and it was growing and moving and all of that. The yellow thing in their right eye, that is the master controller that's sequencing the process of popping out the plate which is gonna be the right eye, the plate that's gonna be the left eye and the plate that's gonna be the mouth in that order because there's not enough room to make all of those plates at once and that was a fundamental challenge. We can't put two plate roots in one event window unless the plates are tiny and doing three of them is pretty much out of the question. So that was the thing to fall back on time, things moving through time and we could have them say, well, so right now orient this way so that the first plate that was popped out goes up to get out of the way to free the space down here and then we can put out the next one and then they go to their final positions. It's pretty nice, it worked out pretty well. Now the problem was was that in order to make it fun, I wanted the whole thing to make more than one face but now the thing that was in control of everything was buried in the right eye. So what was I gonna do? So I made this thing I called a jump seeder or something like that that releases from the right eye but it picks a random direction and just goes shooting out until it finds a complete empty spot and then it seeds a new one. So once again, we don't have real program data distinction programs being copied yet. That's what I failed at for this episode but you can see it here that because we have these jumps seeders shooting out all over the place, this is the original grandparent, grand being of all of them and he shot out his own right eye. Well, he shot out the plate operator, right? So in this case, like this thing here, that blue one is the plate operator and the thing underneath it is the color plate face generator that's doing this, but it all keeps on going and so what happens is now this eye is not dead because the thing still gets events, it still does what it was but it no longer changes size or position because that's what the plate was doing for it and in fact, there are several of them here that have been messed up one way or another. I guess I'm not gonna take positions. This is a where's Waldo. Can you find people that have had their plates shot out and well, we'll leave it be. Yeah, I'm not exactly sure when I took this particular screenshot from anyway. So, all right, the thing that the sub plate operator drove home for me is that it's looking outside its container, it's looking out in the big nasty world and the thing about plate tectonics which really makes a whole lot of sense but one is that when you're working inside in plates and sub plates, it's like you are in control because you put the stuff there and recursively on down but sooner or later because plates can only be so big and the way that I'm typically doing it they can't be more than 100 by 100 or so and even when you get to 100 by 100 they're gonna be incredibly dog slow anyway. So eventually you're gonna have to have plate communications interactions between separate plates, siblings on a larger plate or just loose out in the grid and that becomes much more challenging. You need to be able to deal with the fact that one plate may shift with respect to the other one without telling anybody and we have to accept the possibility of broken paths and this is the thing that I've been seeing this coming for a decade or more but now we've actually built up enough of the stack, enough of the computational stack, the bottom up robust first indefinitely scalable approach that it's affecting how we're gonna make the code. All right, I fell back on site numbers, relative spatial position but then maybe do we need some kind of tag? The thing is if one moves with respect to the other and wasn't notified, now how do you know it's still the same one? How do you know the one that you're talking to? And every time I start thinking about tags I know it's trouble, I shouldn't do it but I started going for it and yes, this all seems so tiring but given the need to interact between siblings, that's where message passing, that's where peer to peer is that's what it means spatially that neither contains the other and yet you need to interact beyond just a geeing back and forth so that is being polite enough to not bump into each other. And then finally again, the pin dropped, I had all of these things, I was trying to make wires that would connect one plate to another and it would be all flexible and stuff like that and then what about an interconnecting plate? If we want two plates, two sibling plates to communicate and because I've got the upper left, the Northwest is being where the roots are and I have not implemented the general symmetries for all of this plate stuff, I'm not sure I'm gonna because it's a tremendous amount of complexity and I sort of think it would be better off to just nail this down and deal with the consequences because there's gonna be consequences no matter what even if you can rotate plates with respect to each other, I don't know, down the road, I feel like we need to understand it all much better first. So if you want two plates to communicate west to west like a mother and a daughter, well then build a connecting plate, stack the two plates, the mother and the daughter up above and below and stack a connecting plate that would go between them and it's like the von Neumann constructor arm which takes us all the way back to the earliest days of computer science and the earliest days of cellular automata which is what this sort of thing is, the von Neumann universal constructor. This is an example of it that was made up that was actually implemented. This whole big blue thing is a machine for constructing copies of whatever is on this tape, the thing that's sticking off it and here's a second generation copy that was produced by the first one and the second one is in the middle of producing a third generation copy and the way it works is it has this constructor arm that essentially rasters over the system and that's kind of what this constructor plate, this transport plate felt like and so this is an example of some circuitry from an implementation of the von Neumann machine but again, so what, this was all done 50 years ago? Well, yes and no as is so much of computer science and so much of robust first and spatial computing. People have dabbled in it but they dabbled in it with determinism and stuff that was inherently brittle and indeed, this is the Wikipedia page, you don't get much dynamics because the machines are too fragile. Yes, that's what we're talking about and so here we are. Gotta save a little time, gonna zip ahead here, right? But instead, and I can't zip ahead, computer science is all about being universal, being super general, don't solve the problem you've got, solve the entire family of problems of which it's an instance of and man, I've got that too, I always wanna do that but maybe I'm wrong again, maybe I shouldn't be looking for general arbitrary communication schemes, I should be looking for something that actually fits together like a jigsaw puzzle with the stuff I wanna do and let the spatial constraints inform the solution and so yes and this idea of using a plate to transport stuff between two other plates started to seem like maybe it was gonna work. I called it transport plate, I've been working on it a lot. Here's an example of it. Let's do a quick demo if we can instead of looking at these pictures. All right, here we are. So what have I got here? I've got S3, right? So plump one of these guys down and we let him go and what happens? Let's turn the event tracking on so we can run time backwards. This is a very useful feature that the simulator has that the T2 tiles themselves do not have. All right, so there it is. We've got the seed S3, that's the seed transport plate V then the TVs are transport plate Vs, transport plate vertical and the idea is that it's a one wide plate. It avoids the whole border stuff because this is too small. It's meant to be fragile. It's meant to be a construction line, a scaffold that's just strong enough to do what the scaffolding needs to do. In this case, it supervises that the transport plate is every third site and in between it are single quoted atoms and so this is the case. These are empty, the green ones are empty, this pair down here is actually got something in it and there it is. So what happened here was the original S3, whatever it was, sent a command to the other end saying deploy a plate deployer. It's so meta and the plate deployer has a bunch of information about it. Like I want to deploy a plate of type whatever, I want to deploy it into site number four which is to my east, I want its size to be this, I want its position to be that and so forth and it got there and it did it and it put out an atom deck plate for us and this is pretty nice. It needs a lot more work, it's got bugs, that's why I wasn't able to have it be our actual demo for today but we got far enough that we actually have a little bit of, whoops, there. Okay, we have a horizontal transport plate as well and the single quote atoms, they don't shift, they're nailed down to be vertical so these are the stations, THTHTH and so forth. Whoops, I overwrote it. All right, so that's just a little quick thing of what I want for the next episode is all of this scaffolding actually being used so that we can take a sequence of atoms that we declare as a program that makes a difference somehow and make a copy of them in a loop in another atom deck using transport plate technology that works better for the process. All right, so that's what this stuff was about. Oh yeah, this was nice. This was during debugging. The first thing, just to have an atom descent it just sent itself. It went up to the end of the transport plate and the transport plate is designed that when it gets to the end, if there's no operator there and the thing that they're transporting is an operator it goes ahead and plops it down, that's it. So that just started up again and it just sort of making a chain of these things until it got through. There's the horizontal one and so on. All right, so, oh yeah, and again, this was another sort of, oh my God, it's so obvious that I gotta do a redesign for this at this point which is why I gave up on showing it this week for real is that the idea would be that the way you use one of these transport plates is you have two instances of the same operator, one at each end. So what you're really doing is you're making a single coupled processor that's sending messages back and forth between copies of itself so that it can accomplish stuff over a bigger area than any single atom could. Makes a lot of sense. Didn't get to it until Monday, June 21. That was yesterday. All right, that's it. All right, I showed, no, actually I didn't. This is going too long. Last time we had the trouble with the T2 tile array. Since then, I did get in and got the trace files that were associated with that particular event and the 439, 5353 from the three tiles that were originally involved in it and I actually sucked them out of each tile from the middle of the grid where you can't get Ethernet in there using the serial port and Z modem. I felt like welcome to the 90s. I also wrote a quick replacement, the cash update traffic maximizer to try to provoke the problem so that what this does, it's like a fork bomb that reproduces as fast as possible but in addition it makes each copy of the fork bomb locally unique so that when it rewrites all of those sites they all have to be transmitted as cash updates which is supposed to be the worst case and I did manage to get it to fail but it took a long time and the failures there, I got it to fail are really rare so I still feel like I don't have a clear understanding of exactly what's going on there collecting more information in the background. In the foundation business we were running out of disk space for backing up all of this video stuff so using some money that I had from before I got one of these new network attached storage things a bigger one than the one that I've been using so the box itself, there it is installed of a Synology the box was bought from money from other stuff but the disks that are inside it are bought by Living Computation Foundation funds thanks folks there it's our dollars, your dollars all of us at work and now the thing is a third fold just copying the stuff from the old thing which is now no longer going to be used for that stuff so there we are the Living Computation Foundation website has been updated but now it has a news button that it didn't have before and it's got a first just a quick summary bam, bam, bam of the stuff that we've been doing T2Tile stuff, videos, talks, foundation, business and so on and that's it so the next update will be in two weeks my goal is to have something that's functionally like a programmed construction arm which is kind of like what I was hoping for this episode didn't make it but I think the prospect is better for making it next time thanks folks for stopping in I hope everybody's doing all right you know we're still not really emerging from our pandemic nature just cause you know you learn the new ways of doing stuff you keep on doing it we'll see how it goes hope everything's good with you hope to see you next time