Episode 130: Uiua 0.19 with Kai Schmidt

WEBVTT
00:00:08.880 --> 00:00:12.960
Welcome to episode 130 of Arraycast.
00:00:13.039 --> 00:00:14.720
I am your host, Connor.
00:00:14.880 --> 00:00:19.039
We're back from a unscheduled or quasi-scheduled.
00:00:19.120 --> 00:00:21.120
I guess I could have anticipated that this was coming.
00:00:21.359 --> 00:00:22.239
Two-month break.
00:00:22.399 --> 00:00:25.519
Last time we recorded was at the beginning of August.
00:00:25.600 --> 00:00:31.760
It's 2026, for those of you that are listening to this live on YouTube or recently on the podcast platforms.
00:00:32.079 --> 00:00:37.520
And it's now October, and we have back with us a very exciting guest.
00:00:37.600 --> 00:00:44.960
The last time she was on was, I think, episode 77 of a Raycast, but was on Tacit Talk two times in between.
00:00:45.039 --> 00:00:49.280
Those links aren't in the description or the show notes yet, but they will be after the fact.
00:00:49.679 --> 00:00:55.920
And I guess we'll have her introduce herself at the tail end, because we're doing this live now, so we do the introductions a bit different.
00:00:56.079 --> 00:00:57.600
We'll do uh brief introductions.
00:00:57.679 --> 00:01:05.439
We'll start with Adam, then go to Max, and then I guess we'll we'll finish with uh Kai, who's back to talk about uh a new release of Weewa, Weewa 0.19.
00:01:05.519 --> 00:01:07.280
But first we'll go to Adam and then to Max.
00:01:07.680 --> 00:01:07.920
Right.
00:01:08.079 --> 00:01:10.239
So I'm Adam Brzevsky.
00:01:10.480 --> 00:01:14.239
I have been doing APL all my life, most of my life.
00:01:14.560 --> 00:01:19.680
And I am currently head of language design at Dialogue Limited.
00:01:21.519 --> 00:01:21.840
Okay.
00:01:22.239 --> 00:01:26.000
So yeah, uh next year is uh my array test uh debut.
00:01:26.239 --> 00:01:39.040
And uh yeah, I was previously on Tested Talk, and uh I'm interested in uh notation that uh help us think in general, whether it's a tooling or uh written or uh computerized.
00:01:39.359 --> 00:01:41.760
I'm also a proud sponsor of what we want.
00:01:42.159 --> 00:01:42.560
There we go.
00:01:42.640 --> 00:01:43.120
We didn't know that.
00:01:43.200 --> 00:01:45.040
And I'm doing I'm doing a bad job of moderating.
00:01:45.120 --> 00:01:58.640
I should have mentioned, and uh the uh astute listenerslash viewer will know that uh last episode, I believe it was episode 129, we had our first guest panelist, which we kind of started from a couple episodes before that.
00:01:58.799 --> 00:02:08.639
We had said, you know, long term we're looking to grow the panel, and in the short term, we were uh we had some uh a request for uh people that were interested in being guest panelists.
00:02:08.800 --> 00:02:14.960
And I believe Madeline, famously of Tiny Apple, was our first guest panelist, and Max is now our our second guest panelist.
00:02:15.120 --> 00:02:18.400
We've got our our guest Kai to talk about Wewa, and Max is here as well.
00:02:18.560 --> 00:02:19.360
We'll have lots of questions.
00:02:19.439 --> 00:02:21.919
So now that my moderator job is done, we'll throw it back over to Kai.
00:02:22.240 --> 00:02:27.919
Uh I I'm sure everyone knows who you are, but uh just briefly introduce yourself and then I think we'll have a couple announcements and we'll start talking about Wea.
00:02:28.080 --> 00:02:30.560
Um yeah, I'm Kai, and I'm the creator of Weewa.
00:02:30.879 --> 00:02:31.439
That's it.
00:02:31.759 --> 00:02:32.159
That's it.
00:02:32.319 --> 00:02:32.639
Poof.
00:02:32.800 --> 00:02:34.319
Like showing us how it should all be done.
00:02:34.639 --> 00:02:37.360
I guess we're not all creators of things though, so it can't be that emphatic.
00:02:37.439 --> 00:02:38.800
Uh, you know, I don't I'm not able to say that.
00:02:38.879 --> 00:02:39.840
I can just say I host some.
00:02:40.159 --> 00:02:40.639
Uh perfect.
00:02:40.800 --> 00:02:43.199
So uh I honestly I forget who has all the announcements.
00:02:43.280 --> 00:02:55.680
I I know Max has at least one, and uh Adam has zero or one, but uh so we'll go with Max and then over to Adam if he has Okay, so uh my announcement is for uh people local to Toronto.
00:02:55.840 --> 00:03:06.879
Uh that's uh based in Toronto, and uh there's uh a real programming language event, I suppose, uh hosted by uh Data Intellect.
00:03:07.360 --> 00:03:12.479
Uh it's about uh the Q programming language, which uh was derived on APL.
00:03:12.719 --> 00:03:18.159
It's uh happening uh this uh uh first day, uh 2 to 5 p.m.
00:03:18.400 --> 00:03:20.080
uh near downtown Toronto.
00:03:20.560 --> 00:03:21.759
Link will be in the show notes.
00:03:21.840 --> 00:03:27.360
I think you have to register in advance, and this is definitely the kind of thing pre-parenthood I would go to.
00:03:27.520 --> 00:03:31.280
Now I will not have the time to make it, but uh I will be there in spirit.
00:03:31.360 --> 00:03:34.240
So yeah, link in the show notes if you're local to Toronto this Thursday.
00:03:34.319 --> 00:03:37.840
So I guess you will have had to listen to this either Monday, Tuesday, or Wednesday.
00:03:38.000 --> 00:03:38.719
Link will be in the show notes.
00:03:38.800 --> 00:03:39.599
And Adam, I can't recall.
00:03:39.680 --> 00:03:41.120
Did you have zero or one announcements?
00:03:41.280 --> 00:03:42.080
I know at one point you had.
00:03:42.400 --> 00:03:44.080
Yeah, or or maybe two or three.
00:03:44.560 --> 00:03:45.039
All right, we go.
00:03:45.199 --> 00:03:54.560
Um we're gonna start off with uh April Germany's uh autumn or fall uh meetup, uh which is going to be in Solingen, Germany.
00:03:54.719 --> 00:03:58.000
Uh, and that is happening on the 5th and 6th of November.
00:03:58.240 --> 00:04:02.639
There isn't any program up yet on the website, but uh should be coming very soon.
00:04:02.800 --> 00:04:05.039
Um you can register there as well.
00:04:05.199 --> 00:04:09.120
There's probably going to be some mixed German and English content.
00:04:09.360 --> 00:04:21.279
Um and then we I think we touched on it briefly when we in the last episode, but now it has been properly announced, the winners of the APL Forge, which includes Connor.
00:04:21.360 --> 00:04:23.040
So congratulations to Connor.
00:04:23.199 --> 00:04:27.040
Which leads me to the third announcement, which is congratulations to Connor.
00:04:27.199 --> 00:04:34.319
Because you just sort of hinted at it, Connor, but you haven't said why this whole break was there, but Connor became a father.
00:04:34.800 --> 00:04:41.040
I can never tell uh in the cinematic universe that is all the podcasts that I host, uh where I've announced it or not.
00:04:41.120 --> 00:04:49.439
But yes, there's the for the congratulations and uh the kid was on the way, uh, is what I announced on the previous podcasts.
00:04:49.600 --> 00:04:53.680
Um and now the baby's which is uh partially why we're delayed.
00:04:53.920 --> 00:04:56.319
A raycast is still here, it hasn't disappeared.
00:04:56.560 --> 00:05:06.000
The podcast well, we plan to still do every two weeks, but there might be a missed episode because as Adam knows, take time a priority all and is also my view.
00:05:06.079 --> 00:05:07.120
I should I should air.
00:05:07.279 --> 00:05:10.639
Um anyways, was that the final thing or was there one more?
00:05:10.879 --> 00:05:12.079
Yeah, that's I think that's that's it.
00:05:12.160 --> 00:05:12.399
Yeah.
00:05:12.720 --> 00:05:16.160
Alright, so that is the announcements and the introductions out of the way.
00:05:16.240 --> 00:05:43.519
So I have on the side, I mean I'm not sharing it, but so on episode 77, that was uh Kai, your first interview on a ray cast, and then it doesn't say it in the title, but if I recall, it we did this exercise on the second Tacit Talk episode where we tried to figure out what edition of Weewa was out, but we'll say it was like dot oh nine or dot 10 back then, and then I I made the uh the fix of an episode 19 of Tacit Talk.
00:05:43.600 --> 00:05:52.399
We were talking about dot 15, and now I think it was at the tail end of August.19 officially released, and now dot 20 is in beta.
00:05:52.480 --> 00:05:54.079
Uh so I'll throw it over to you.
00:05:54.240 --> 00:06:08.800
Um, tell us what's new ever since I guess uh dot 15 if you want, but maybe focus on the dot 19 stuff and then we'll go from there because I'm sure that there's a I've seen I've seen the the change laws and I know that there's uh new primitives, there's deprecated primitives, there's new features.
00:06:08.879 --> 00:06:09.839
Uh so lots to talk about.
00:06:10.079 --> 00:06:15.759
I mean, if you're going back all the way to what 0.15 you said, it would be that was over a year ago.
00:06:15.839 --> 00:06:17.600
So it was over a year ago, yes.
00:06:17.759 --> 00:06:21.439
February 21st was uh of 2025 was the last time.
00:06:21.519 --> 00:06:26.160
So it's about a a year and a half since the last time you've been on a podcast, or at least a raycast or Tassatalk.
00:06:26.240 --> 00:06:30.399
I don't know if you've been uh hitting the other podcast uh what do you call it, Markets.
00:06:30.560 --> 00:06:34.720
Um I I think because we this is like titled 0.19 right.
00:06:34.959 --> 00:06:36.560
I'll start with that and we'll see where we go from there.
00:06:36.879 --> 00:06:37.279
Perfect.
00:06:37.439 --> 00:06:43.600
Um, so most of the big features in 0.19 are remain experimental.
00:06:44.079 --> 00:06:49.920
Um, I can go over them in order of how likely they are to be not experimental in the future.
00:06:50.240 --> 00:06:50.560
Okay.
00:06:50.959 --> 00:06:52.959
Um, so let me share here.
00:06:53.439 --> 00:06:54.240
And this is the beauty.
00:06:54.319 --> 00:06:58.480
If you're listening to this on the podcast platforms, I'll talk about it.
00:06:59.040 --> 00:07:00.240
This is live on uh YouTube.
00:07:00.480 --> 00:07:04.079
I mean, it's great to hear it in the podcast, but also too, the visuals are fantastic.
00:07:04.160 --> 00:07:06.480
We got syntax highlighting, we got WeWAPAD here.
00:07:06.560 --> 00:07:08.480
Yes, feel free to check out the YouTube maps.
00:07:08.639 --> 00:07:09.199
I can see it great.
00:07:09.519 --> 00:07:10.160
Yeah, cool.
00:07:10.480 --> 00:07:16.480
All right, so uh increasingly, and if we go further back in the change logs, we'll see this.
00:07:16.560 --> 00:07:24.879
Um, we will have more and more into um sub the subscript syntax, which is where you attach a little number to something.
00:07:25.040 --> 00:07:27.600
Um, not just numbers, but other symbols too.
00:07:27.839 --> 00:07:39.439
In my mind, this is kind of analogous to um AP or APL's um like bracket syntax, in that what it does for each primitive is kind of ad hoc.
00:07:39.759 --> 00:07:44.160
Um it's it usually makes sense, but like you can't necessarily know exactly what it's gonna do.
00:07:44.240 --> 00:07:48.639
It's not it's not a uniform um transformation of that primitive.
00:07:48.800 --> 00:07:55.839
Um but one thing I want we wanted to add was the ability for you to define your own behavior for these.
00:07:56.000 --> 00:07:58.959
Um, just as an example for those who haven't don't know them.
00:07:59.199 --> 00:08:01.360
Example, like um, what's the example of a subscript?
00:08:01.680 --> 00:08:06.639
If I do something like uh give myself a little array here, um and then if I want like the first item, right?
00:08:06.800 --> 00:08:07.839
That just gives me the first one.
00:08:08.000 --> 00:08:14.720
But maybe I want the first two or the first last, no, maybe that one doesn't work, or like the last three.
00:08:14.959 --> 00:08:17.680
Um, and it changes the behavior of this thing.
00:08:17.839 --> 00:08:19.839
The same thing for like um rows.
00:08:20.000 --> 00:08:26.160
Like if I have a um a big array of a bunch of numbers, uh two, three, four, five.
00:08:26.639 --> 00:08:30.399
Um this is kind of like for this, it's like a rank operator, right?
00:08:30.480 --> 00:08:41.039
Where you do like rows, uh, I don't know, two box, like box every rank, two array, box every rank, uh, one array, box every rank, three array, right?
00:08:41.200 --> 00:08:46.480
Um, so we want it to be we want it to be possible to to find these for your own.
00:08:46.559 --> 00:08:52.159
Because if I combine some function, uh maybe I want to what does F like sub five do or something?
00:08:52.480 --> 00:08:56.320
Um so well, uh this feature is custom subscription.
00:08:57.519 --> 00:09:08.639
Before you continue, I I'd like to draw just the parallel because it might not be obvious to everybody what the what's happening here, but I think it's it's apt to draw the parallel to especially to BQN, actually.
00:09:08.960 --> 00:09:15.840
You said you it's similar to the bracket access in um, or for example, in bracket access in in APL.
00:09:16.159 --> 00:09:30.879
But actually, we noticed that in APL there's there's some pairs of operators, monetic operators and dadic operators that pair up nicely, where we have the the each operator and the depth operator.
00:09:31.200 --> 00:09:36.320
Depth operator is a more general form of uh of the each operator.
00:09:36.399 --> 00:09:38.240
And so too, you can go the other way.
00:09:38.320 --> 00:09:44.240
We have the general rank operator, but then there's an another operator which is unmajor cells operator.
00:09:44.879 --> 00:09:52.559
And you could also say that that first and uh and take are sort of variations of each other.
00:09:52.720 --> 00:10:09.200
So essentially, here is you're you're sort of reinventing that duality between monetic dadic functions like first and take, notably not in dialogue APL by default, but in APL2, the the uh up arrow means first and means take, right?
00:10:09.519 --> 00:10:14.480
I I would say in some ways, so if I go back to that example real quick um with all the numbers, uh there is a difference, right?
00:10:14.559 --> 00:10:19.120
If I do take two here, it gives me one and two, whereas if I do it gives me the array one, two.
00:10:19.360 --> 00:10:24.159
But if I do first two, it gives me two different results out, um, which is different.
00:10:24.559 --> 00:10:25.360
Oh, I see.
00:10:25.679 --> 00:10:27.200
Okay, so there's a difference there, yeah.
00:10:27.279 --> 00:10:34.480
Okay, it's sort of still sort of the same idea of having the same primitive do two related things.
00:10:34.639 --> 00:10:36.240
Um but okay, I get it.
00:10:36.399 --> 00:10:39.759
But and but with the with the operators like you did when the depth one, right?
00:10:39.840 --> 00:10:44.159
On rows, but then you say on subarrays of rank, that is the same idea, right?
00:10:44.720 --> 00:10:46.480
Yes, yes, it is.
00:10:46.639 --> 00:10:58.559
Um and I should point out that like uh a lot of the behaviors we assign to not all of them, a lot of the behaviors we assign to subscripts are numbers that should be known at like compile time.
00:10:58.720 --> 00:11:05.919
Um like for example, you can put any number after the take, basically, and it'll it can be any always produces the same number of arguments.
00:11:06.240 --> 00:11:06.799
Whereas for the same thing.
00:11:06.960 --> 00:11:08.799
But you can't compute the subscripts, right?
00:11:08.960 --> 00:11:10.000
They have to be fixed.
00:11:10.399 --> 00:11:11.120
Yeah, they do.
00:11:11.360 --> 00:11:15.360
Um you can like do macros and stuff, but it'll still run at compile time.
00:11:15.600 --> 00:11:24.720
Um the this first here will always produce two outputs, but it has to know how many outputs a thing is going to produce at compile time.
00:11:24.879 --> 00:11:29.679
So you couldn't make this necessarily a um a normal function.
00:11:29.919 --> 00:11:32.960
It would have to, it has to be uh compile penal.
00:11:33.440 --> 00:11:34.240
That's not true for all of them.
00:11:34.320 --> 00:11:37.440
So I can just take that too, take two, if I can make that a subscript.
00:11:37.519 --> 00:11:44.000
So some things just have a subscript that means bind this more tightly together so I don't have to put a parentheses around it or something.
00:11:44.159 --> 00:11:46.240
Um so take actually does do this.
00:11:46.320 --> 00:11:47.120
So essentially you can do it.
00:11:53.519 --> 00:11:56.799
Same thing as most of like the uh arithmetics, arithmetic things, right?
00:11:56.879 --> 00:11:58.559
Um it's that's what it's gonna do.
00:11:58.639 --> 00:12:06.080
Um it's sort of interesting you're breaking the mold because we is is essentially a fourth, right?
00:12:06.399 --> 00:12:08.240
Um in some ways, yeah.
00:12:08.559 --> 00:12:17.120
But then but now we're introducing well, not quite infix notation because it's still prefix, but it's sort of I mean the difference is you're writing it like this, right?
00:12:17.200 --> 00:12:18.720
It's still yeah, yeah.
00:12:18.960 --> 00:12:29.440
The main the main difference between like plus subscript plus subscript one and plus one is that um whether you need parentheses if you're trying to do it as part of like a larger, like in in a modifier or something.
00:12:29.600 --> 00:12:32.639
Yeah, it never it never ends up on the stack, right?
00:12:32.799 --> 00:12:35.360
The one e well it does.
00:12:35.679 --> 00:12:37.440
Well, it compiles to the same thing, right?
00:12:37.519 --> 00:12:39.679
Um it's it's more of a syntactic thing, right?
00:12:39.759 --> 00:12:44.879
So if I wanted to do say like on plus one, if I separate these, the meaning becomes different.
00:12:45.200 --> 00:12:47.360
I've always loved that about about WiWa.
00:12:47.519 --> 00:12:52.879
That it uh it like unitizes it into a single, it's not actually a single glyph, but you can treat it that way.
00:12:52.960 --> 00:13:16.240
And it's one of the things that irritates me about other array languages, is like I've always thought about like a hypothetical array language where instead of plus slash or slash plus, like I think actually someone in an array cast or tacit talk mentioned it once uh like kanji, like Korean, like where you build up or like Chinese, you build up a symbol out of radicals, like instead of a slash, you like you circle the plus or the binary operator.
00:13:16.320 --> 00:13:17.279
So it's always a unit.
00:13:17.440 --> 00:13:27.519
And because there's so many examples, especially when you start doing tacitly, which I guess is always the case for for Weewa, and you end up having to parenthesize things in order to pass them around with combinators correctly.
00:13:27.679 --> 00:13:29.840
It's it's a very nice like feature.
00:13:30.240 --> 00:13:32.879
When you when you first introduced this, I was like, oh my god, this is beautiful.
00:13:33.120 --> 00:13:35.200
When you want it, it makes so so beautiful.
00:13:35.919 --> 00:13:47.840
I've had the offhand idea to lean into it more with like the um the combine, you know, there's like the combining Unicode characters, uh, but that gets real complicated for like parsing and display real quick.
00:13:48.080 --> 00:13:56.799
Oh, like I got I thought about it too, and I've like you basically would have to build your own kind of like website editor where that's the only place you use it, because like how are you gonna do that in the command line?
00:13:57.120 --> 00:14:01.600
You basically have to usually when you're writing string manipulation stuff, you're not thinking about that.
00:14:01.679 --> 00:14:12.960
And so anytime you're working with like string manipulation manipulation code that works on source code, you would have to like take that into account, and you'd have to parse everything as Unicode graphing and stuff, and it'd be a lot.
00:14:13.360 --> 00:14:15.279
Um so the the whole point of this, right?
00:14:15.519 --> 00:14:16.720
That's there's subscripts.
00:14:16.799 --> 00:14:25.440
Um, these custom subscripts, you essentially write the name of a function, I'll call mine F, and you give it a subscript N, and then you can say that something.
00:14:25.600 --> 00:14:29.360
So I could if I just wanted to use that N in here, I could just do this, right?
00:14:29.440 --> 00:14:31.120
I could you do uh N like this.
00:14:31.360 --> 00:14:38.559
And what this will do is now I can call F with like F sub one or F sub two or three.
00:14:38.720 --> 00:14:40.799
Um and that we'll just put it in there.
00:14:41.039 --> 00:14:52.639
Alternatively, I could do something like this, um where uh I can use it as the subscript for some other modifier.
00:14:52.799 --> 00:15:02.559
Um and so it I can also do it is really just an extra argument in this case, much like say GNU APL allows you to do with the square brackets.
00:15:02.960 --> 00:15:08.879
It is an extra argument, although it can take sorts of things that you couldn't take as normal arguments.
00:15:09.120 --> 00:15:15.360
Like you can't take this N as a normal argument, or you couldn't, if I wanted to do like say uh both sub N right here, right?
00:15:15.679 --> 00:15:18.559
Uh, because it has to happen at the compile time.
00:15:18.639 --> 00:15:24.799
So because you're doing it at the compile time, you're able to put it in in the subscripts that need to be there available at compile time.
00:15:24.960 --> 00:15:25.200
I see.
00:15:25.440 --> 00:15:26.240
Yes, exactly.
00:15:26.399 --> 00:15:28.559
Uh that's the whole feature, basically.
00:15:28.720 --> 00:15:34.799
Um, it's just nice to be able to do that for your own stuff because subscripts have become so ubiquitous in the language.
00:15:34.879 --> 00:15:37.759
Um if you're trying to write your own APIs and stuff, it's cool to be able to use them.
00:15:38.080 --> 00:15:41.440
Can you do computations in subscripts like uh OnePlus One?
00:15:41.840 --> 00:15:44.480
Not currently, although I've thought about it.
00:15:44.559 --> 00:15:45.679
Um, but no, not right now.
00:15:48.399 --> 00:15:50.720
It's uh do you always want it hard-coded?
00:15:50.960 --> 00:15:51.919
Sorry, what'd you say?
00:15:52.240 --> 00:15:58.720
Yeah, I'm wondering, you know, it's uh you can do computations, but uh what uh would be uh the use case for that?
00:15:59.120 --> 00:16:09.120
I mean, if you want something to be offset a rank or by one rank or like up or down a rank, I think that'd be the main use case, or up or down like an parity, like this both symbol is.
00:16:09.440 --> 00:16:10.879
Um that'd be the main one.
00:16:11.039 --> 00:16:14.960
You can still currently do that stuff if you really want to via like macros.
00:16:15.039 --> 00:16:19.360
Um it won't actually be a subscript, but um that would it would be cool to have that, yeah.
00:16:19.679 --> 00:16:22.399
I I'm wondering if it isn't slightly dangerous.
00:16:22.639 --> 00:16:27.360
Yeah, you can use this as a sort of extra argument, but it's compile time.
00:16:27.440 --> 00:16:38.879
But if people start using it for things that actually could be dynamic, that lessens the ability to call those, call that code, because the only way to call it is by with fixed values.
00:16:39.120 --> 00:16:39.360
It does.
00:16:39.600 --> 00:16:40.399
It does, yeah.
00:16:40.639 --> 00:16:42.080
I mean, ideally for something like this.
00:16:42.159 --> 00:16:47.279
So let's say I had um, let's say I go back to my other example where it was um just plus, right?
00:16:47.440 --> 00:16:50.879
Now you probably wouldn't just do plus, you would just write plus your thing, right?
00:16:50.960 --> 00:16:54.399
But um, if I do something like this, right?
00:16:54.639 --> 00:16:58.879
Um, I could make a fallback, which is like something like this.
00:16:59.120 --> 00:17:04.640
Um or I could make my special version that isn't a fallback and it's just the original version, right?
00:17:04.880 --> 00:17:08.319
Um, I can write this one like this.
00:17:08.640 --> 00:17:10.559
They're essentially just parallel names, right?
00:17:10.640 --> 00:17:12.799
Because it's all static, it's all compile time.
00:17:13.200 --> 00:17:17.759
That means F and F sub N aren't really related.
00:17:17.920 --> 00:17:19.440
I mean, no, they're not.
00:17:19.519 --> 00:17:25.599
Um, I did have a system that made them related, but it got like confusing both for the user and for me, the implementer.
00:17:25.839 --> 00:17:27.440
Um so yeah, I separate.
00:17:28.000 --> 00:17:33.119
Yeah, I think the ST of subscripts uh adds uh an extra entity to to functions, right?
00:17:33.359 --> 00:17:39.920
You have uh one more uh space uh to to put in to put to input uh uh I guess the numbers for now.
00:17:40.240 --> 00:17:45.519
Yeah, but I find it really interesting that you that that you have the need for this in in we were.
00:17:45.680 --> 00:18:02.319
I mean, uh yeah, I understand the the syntactic nicety uh shortcut thing, but I thought I I always thought of what this maybe the strongest argument for we were was freeing itself from the Iversonian one or two arguments only.
00:18:02.880 --> 00:18:09.119
And and here we get back to being sort of static with a bound in syntax.
00:18:10.160 --> 00:18:10.880
I suppose.
00:18:11.039 --> 00:18:12.480
Um in a way.
00:18:12.720 --> 00:18:18.240
I mean this these will like if I want if I go back to that example where we do um both, right?
00:18:18.319 --> 00:18:23.279
Um you could notice it does change color.
00:18:23.599 --> 00:18:33.119
Um it does change color depending on what the subscript is because it knows that its area changes as you change what the subscript is, right?
00:18:33.200 --> 00:18:37.279
Um that's because this is do this box on this many arguments.
00:18:37.440 --> 00:18:40.640
Um and so it knows that you're changing that area.
00:18:40.799 --> 00:18:43.680
Um although I guess you're talking about array in a different sense, aren't you?
00:18:44.079 --> 00:19:19.119
Yeah, it's just uh the the number of like distinct inputs that they are there because we can distinguish between an array of n elements and uh copying n things off the stack, whereas the traditional way of solving this problem in in other senior languages is just put things into an array, but you can't really you cannot distinguish, you can't write a function that distinguishes between give being given a list of many arguments and just being given a single argument, which is a list, unless you start requiring the user to add an enclosure, a boxing.
00:19:19.359 --> 00:19:20.319
So sure.
00:19:20.480 --> 00:19:29.680
I mean that there's ways to like take a list, uh take an array and use its rows as arguments um to a function pretty easily.
00:19:29.920 --> 00:19:31.759
But yeah, um cool.
00:19:32.160 --> 00:19:33.200
That's the first one.
00:19:33.359 --> 00:19:39.680
This is probably gonna get stabilized, it's currently experimental, um, but it's it's pretty simple features, so I don't think I think it's pretty good.
00:19:39.759 --> 00:19:42.640
Um anything else you guys want to ask about that before I go to the next one?
00:19:42.960 --> 00:19:47.680
So what happens other uh so you can have gaps, right?
00:19:47.759 --> 00:19:54.720
Because you can you can define F sub n here, you can you can define also with a specific number what it does.
00:19:55.039 --> 00:19:57.119
Yeah, if I wanted to like yeah, you could.
00:19:57.200 --> 00:20:01.200
Um you could do like F2 equals um I don't know, five, sure.
00:20:01.839 --> 00:20:09.519
So then with it it put it prefers the most specific form and then falls back to the general form, or uh I think hold on.
00:20:09.680 --> 00:20:11.599
Ah, if yes, that is true.
00:20:11.759 --> 00:20:13.599
If you define them in the correct order.
00:20:13.920 --> 00:20:16.319
Oh no, actually, just always, just always.
00:20:16.480 --> 00:20:18.720
Yeah, yeah, that's that's worth noting.
00:20:18.880 --> 00:20:22.960
But it's it wait, but I mean that's it's sort of neat, right?
00:20:23.039 --> 00:20:38.880
It it it I think this might grow into some something more, or there might be use cases that we don't even think of today where you can use you you can you can like lean on this and say, Yeah, I want it defined for these cases as you could potentially you could have it even sort of recursive, right?
00:20:39.200 --> 00:20:42.480
Where the general case is defined in terms of the of some specific case.
00:20:42.799 --> 00:20:43.759
Yeah, for sure, for sure.
00:20:43.839 --> 00:20:46.319
I can I can probably come here and hopefully this works.
00:20:46.400 --> 00:20:58.880
If I do like F3, um yeah, and then this is like well, F2 is F32423, and then I'll put like I here, and then F2 is this specific case, whereas F4 still exists here, right?
00:20:59.039 --> 00:21:00.720
So yeah, you can do all these like reflecting.
00:21:01.200 --> 00:21:05.279
You should be able to implement Fibonacci that's at compile time or something.
00:21:05.680 --> 00:21:06.480
I suppose.
00:21:07.279 --> 00:21:09.839
Oh, all of a sudden the compiler becomes too incomplete.
00:21:09.920 --> 00:21:10.400
That's great.
00:21:10.720 --> 00:21:11.599
I mean, it already is.
00:21:11.680 --> 00:21:12.400
There's compile time.
00:21:12.480 --> 00:21:13.599
You can run code at compile time.
00:21:13.839 --> 00:21:15.119
You have been able to for a while now.
00:21:15.440 --> 00:21:15.599
Okay.
00:21:15.759 --> 00:21:19.200
Um sorry, I mean I'm distracting you from the next things.
00:21:19.359 --> 00:21:19.759
It's fine.
00:21:20.000 --> 00:21:20.799
But this is pretty quick.
00:21:21.440 --> 00:21:30.960
I can talk more about the broader features that have been released in the past few versions, but um the next one for 0.19 is the beginnings at least of a type system.
00:21:31.279 --> 00:21:44.000
Um the type system is is and probably will always be best effort um in that normal Wii with code is not strictly, not all the types can strictly be known at compile time.
00:21:44.240 --> 00:21:50.160
Um the simplest example is if I do um reshape random ten five, right?
00:21:50.400 --> 00:21:51.920
This will give me a random number of tens.
00:21:52.160 --> 00:21:54.880
The shape of this thing is not known until runtime.
00:21:55.039 --> 00:21:59.200
Um so you can't now, or if I do like um something like even like this, right?
00:21:59.359 --> 00:22:01.359
Uh Now it's really not known.
00:22:01.519 --> 00:22:02.960
It can be any size, right?
00:22:03.200 --> 00:22:09.519
Um, and so a type any type system for Wewa is always going to be do its best.
00:22:09.680 --> 00:22:12.000
Um, so there's two components of this type system.
00:22:12.240 --> 00:22:18.559
The first one is the first, but validate this modifier we call validate.
00:22:18.640 --> 00:22:27.440
Um and validate takes a an array representing the type, which I call a type spec or type specification, and the thing you are validating.
00:22:27.680 --> 00:22:33.680
And if the type matches, if the value matches the type you specify, um it just returns the value unchanged.
00:22:33.759 --> 00:22:35.599
And if it doesn't, it doesn't error.
00:22:35.759 --> 00:22:39.680
Um so this has both a runtime and a compile time component.
00:22:39.839 --> 00:22:44.079
Um, but just as an example, uh the way you might specify uh a type.
00:22:44.160 --> 00:22:54.880
So if I wanted to say, um, for example, my array must be an array of real numbers, um, I'll say num and this is gonna format to this cliff, and then some numbers here.
00:22:55.039 --> 00:22:57.839
And if I try to put characters there instead, it doesn't work.
00:22:58.079 --> 00:23:03.039
Expected array of real numbers, but found an array of uh, well, in this case it's add two characters.
00:23:03.279 --> 00:23:05.119
Um another thing you can do is shape.
00:23:05.200 --> 00:23:10.720
So if I want to say you must have shape two, three, and then I make a shape two, three object, it works.
00:23:10.880 --> 00:23:15.440
Um but if I make a shape say three, three object, it says no, expected two, three, but it got three, three.
00:23:15.759 --> 00:23:23.039
If I want to specify both, I write um num2 three, and then this it works.
00:23:23.279 --> 00:23:34.720
Um this is specifically, it makes this this uh type tag is a box array, a box list of this type tag, which is itself just a character, um, and then the numbers two and three, which are the shape.
00:23:35.039 --> 00:23:37.279
And if I try to do this, it doesn't work.
00:23:37.440 --> 00:23:43.200
And if I try to like make it um a character thing, it it says it expected the different type.
00:23:43.359 --> 00:23:50.480
Um you can also do like wildcard axes, so um this net can now be any first axis.
00:23:50.799 --> 00:23:56.240
You can also specify that um the shape you have is just a prefix requirement.
00:23:56.559 --> 00:24:00.880
Um so now if I do expect it, oh let me turn this on.
00:24:01.279 --> 00:24:14.480
Um now if I do this, um a five-three array works, a five-three, two array works, a five three, one five array works, but a five-four something, something, something does not, right?
00:24:14.640 --> 00:24:20.640
And it even says, like, we expected this thing to start with wildcard three, but it starts with five, four, right?
00:24:20.799 --> 00:24:22.960
Um, so you can do some cool stuff with this.
00:24:23.279 --> 00:24:30.240
The other piece of this system is so you can you can use this, it would run completely at runtime if you use just this.
00:24:30.640 --> 00:24:35.039
The other thing we have though is um what I call type signature comments.
00:24:35.200 --> 00:24:39.440
Um so if I make a function, let's say I make a function and it's just gonna be plus right now.
00:24:39.839 --> 00:24:52.640
I put a comment and then a question mark, and then the formatter is gonna say, Oh, this takes a real number, array of some shape of real numbers, uh, and another array of some shape of real numbers, and then it'll give me back that.
00:24:52.960 --> 00:25:05.200
Now, if I say no, no, no, it doesn't take that, it takes the first argument to actually be um characters, then it um says, Oh, then this one needs to be characters, this one needs to be integers, and it gives you back characters.
00:25:05.359 --> 00:25:12.880
Or if I say something like, oh, and reshape at the end, it says, Oh, now it's two, at least a two long array of characters.
00:25:13.200 --> 00:25:23.599
Um, this is implemented as an entire essentially interpreter that works on types instead of values, um, with like shapes and scalar types that it's doing, running the functions on.
00:25:23.759 --> 00:25:26.720
Um not everything is implemented, obviously, but a good amount of stuff is.
00:25:26.960 --> 00:25:42.160
Um and so you can also if I if I try to use this in a way that wouldn't make sense, like for example, if um if I say, you know what, both uh validate that it's a character, it says, okay, it takes two characters, it gives you back two characters.
00:25:42.319 --> 00:25:47.279
And then if I say plus here, it tells me at compile time, like you can't do this.
00:25:47.440 --> 00:25:49.519
You can't add characters together, it doesn't work.
00:25:49.680 --> 00:25:54.480
Um so it can catch stuff for you, like type errors for you um at compile time, which is cool.
00:25:54.640 --> 00:25:56.079
Currently, this is just a warning.
00:25:56.160 --> 00:26:00.960
This could could maybe should be an error, but I'm not a hundred percent confident in it quite yet.
00:26:01.039 --> 00:26:02.720
Um so right now it's just a warning.
00:26:02.880 --> 00:26:03.759
Um yeah.
00:26:04.160 --> 00:26:06.319
How did these um this is very, very cool.
00:26:06.480 --> 00:26:14.640
Uh how do you like because right now it kind of looks like you're building like type functions that kind of assert stuff on the uh arguments.
00:26:14.880 --> 00:26:20.319
If you're solving or or you're writing like a function, how do you how do you idiomatically uh use this?
00:26:20.400 --> 00:26:28.400
Like it is there some kind of thing that like checks and then kind of throws away that check if it doesn't raise an error and then you have the rest of the function that's computing something?
00:26:28.559 --> 00:26:43.839
Or um like because I'm I'm thinking of like procedural non-array languages where a lot of these type checks are specified kind of like in the the signature of the function or using some you know Rust or C template y you know trait stuff.
00:26:43.920 --> 00:26:45.519
Like how how is it supposed to be used?
00:26:45.599 --> 00:26:55.920
And so the idea here is that if you really care, because because I think one of the big benefits of not just array languages, but like dynamic languages in general, is that you don't have to care most of the time.
00:26:56.160 --> 00:27:11.759
Um, but I have seen people write Wii code before I implemented this feature where they basically implemented something like this themselves because they wanted to make sure that like you're passing all the correct things to your functions, um, just uh for sanity and stuff, both for the developer and the user.
00:27:12.000 --> 00:27:15.920
Um and so you are meant to interface with this.
00:27:16.160 --> 00:27:17.759
One, this is for you, the reader.
00:27:17.839 --> 00:27:20.640
This you if you change this, changes to it will be overwritten.
00:27:20.720 --> 00:27:22.960
This is for you reading the inputs and the outputs.
00:27:23.119 --> 00:27:34.160
Um, this is something that gets past what certain there's languages like OCaml and stuff, which have a very powerful type system which can fully figure out tons of types without you specifying a single thing.
00:27:34.319 --> 00:27:41.839
Um, but then you get these like type errors that percolate up to someplace that is unrelated, right, through a big called stack.
00:27:42.000 --> 00:27:47.359
Um whereas this, um, it tells you right there, this you don't have to write the signature itself.
00:27:47.519 --> 00:27:51.920
Um, and it just fills it up for you based on what it's been able to infer based on the inputs.
00:27:52.079 --> 00:27:56.160
If you really want to specify your inputs, you are meant to do it by using validate.
00:27:56.559 --> 00:27:59.440
Um, you can get some results even without using the code.
00:27:59.519 --> 00:28:06.960
So if I say F is take two, um, it doesn't know what you're inputting, but it does know whatever you're outputting, it's gonna be two by something, right?
00:28:07.119 --> 00:28:09.440
Um, because take will err if there's not enough items.
00:28:09.519 --> 00:28:12.720
So it has to be two by something by the time this function returns, right?
00:28:12.960 --> 00:28:13.599
That's so neat.
00:28:13.759 --> 00:28:15.279
This is very like Haskell.
00:28:15.359 --> 00:28:27.440
Um, you know, there's some feature, I can't remember what it's called, but like if you leave out the type signature, you hit some button, it'll automatically like populate the the most generic, uh, or is it the most generic or the most uh I haven't used, I'm not the Haskell.
00:28:27.839 --> 00:28:32.720
We need Tiny Apple uh Madeline here, but it'll fill in the type signature, you know, you don't have to do anything.
00:28:32.960 --> 00:28:33.200
Yeah.
00:28:33.440 --> 00:28:40.079
So and there's cool stuff like if I do like um a transposter, um, now the two's at the end.
00:28:40.240 --> 00:28:46.640
And then I can also do like a reshape three, and now it's like three and then some number of axes and then a two, no matter what you put in.
00:28:46.799 --> 00:28:52.880
Um so it's relatively, I mean, there's limitations to this, it's not like a perfect representation of all possible things it could be.
00:28:53.039 --> 00:28:54.720
Um, but I think it's pretty cool.
00:28:55.519 --> 00:28:58.880
Do you have a type for a subscript script of functions?
00:28:59.440 --> 00:29:10.000
Yeah, it doesn't have types for so subscript functions are implemented at custom subscript functions are implemented as macros, and it doesn't have you can't do this on any macros.
00:29:10.240 --> 00:29:19.759
Um just because their entire signature is instantiated at the call call site, not at runtime, but at the call site, uh, rather than the definition.
00:29:20.000 --> 00:29:26.240
And so this could vary wildly depending on what your um even like the number of arguments it puts here could vary wildly.
00:29:26.400 --> 00:29:30.160
And it doesn't know all the things you might be putting into the the macro.
00:29:30.480 --> 00:29:33.119
Uh what about uh combinators like uh both?
00:29:33.519 --> 00:29:37.200
No, any anything that's not a function, it won't work on.
00:29:37.599 --> 00:29:38.160
Oh, okay.
00:29:38.319 --> 00:29:38.880
So yeah.
00:29:39.039 --> 00:29:41.519
So it's always the derived functions.
00:29:41.759 --> 00:29:42.240
Yeah.
00:29:42.799 --> 00:29:45.680
You could unroll combinators, right?
00:29:45.920 --> 00:29:50.079
To render them as normal functions and then do do the analysis.
00:29:50.319 --> 00:29:52.960
At least some um you can't.
00:29:53.039 --> 00:29:55.599
Well, I mean, I can okay, I can use a combinator in here.
00:29:55.680 --> 00:30:01.759
Like if I do uh like um on V shape, and then I do like, I don't know, validate T3.
00:30:02.319 --> 00:30:05.920
Um like it it you can put combinators in the thing.
00:30:06.079 --> 00:30:07.359
They're that they're handled.
00:30:07.440 --> 00:30:16.880
Um, but you can't like if I just make some modifier that's like this and I say on this, um I it doesn't it can't it can't work on that.
00:30:16.960 --> 00:30:17.359
It doesn't know.
00:30:17.440 --> 00:30:19.200
It should honestly it should give you a warning here.
00:30:19.279 --> 00:30:23.440
It's not right now though, um, because it can't process this properly yet.
00:30:23.680 --> 00:30:29.839
Yeah, I think if this gets hairy when you try to address these like uh higher order uh constructs.
00:30:30.160 --> 00:30:31.359
Yeah, for sure.
00:30:31.680 --> 00:30:33.200
Um that's easier though.
00:30:33.279 --> 00:30:40.240
Um and so also it can even if you don't put these, I can I believe I share if I put this up here.
00:30:40.400 --> 00:30:51.519
Um and let's say I do something like my array, it requires a let's say um uh length of at least it takes in a length of five, right?
00:30:51.680 --> 00:30:53.680
Now if I put this here, it says okay, length of five.
00:30:53.839 --> 00:31:00.480
But if I don't even put that there and I just put um say let's say like take ten, it can tell like oh wait, wait, wait, wait.
00:31:00.880 --> 00:31:08.799
So this is doing for every every function in the file, even if you didn't put anything on it, it just says, look, make do my basic sanity checks of like you can't do this.
00:31:08.960 --> 00:31:11.359
Even if I did something so even if I just did this, right?
00:31:11.519 --> 00:31:12.400
It would still do the same thing.
00:31:12.559 --> 00:31:15.680
Take five, like this would fail at runtime, definitely.
00:31:15.920 --> 00:31:17.599
Um, and so you can't, right?
00:31:17.920 --> 00:31:24.559
So do you also get uh domain errors when you try to uh call something that's accidentally negative?
00:31:24.640 --> 00:31:28.559
It's like when you try to uh reset for a negative shape.
00:31:28.960 --> 00:31:29.920
That is a great question.
00:31:30.000 --> 00:31:32.480
Let's well, you can reshape with a negative shape in Wii US.
00:31:33.200 --> 00:31:34.319
Oh okay.
00:31:35.359 --> 00:31:38.240
Um I was trying to think so theoretically, yes.
00:31:38.319 --> 00:31:39.920
I'm sure there are some examples of that.
00:31:40.079 --> 00:31:42.240
Um I can't think of any off the top of my head though.
00:31:42.480 --> 00:31:56.400
Yeah, because some things know that they need to take some things know that they need to take specifically natural numbers, and so it and it has a distinction between numbers, real numbers, integers, uh naturals, booleans.
00:31:56.799 --> 00:32:01.920
Um I guess uh string versus uh numbers is uh easier to synthesize.
00:32:02.240 --> 00:32:02.799
What is?
00:32:03.039 --> 00:32:10.799
Yeah, you know, an example where you're trying to you know re-reshape something into the symbol of a string, which uh doesn't make sense.
00:32:11.039 --> 00:32:11.359
Sure.
00:32:11.519 --> 00:32:13.359
If I if I I mean I'm pretty sure that'll work.
00:32:13.440 --> 00:32:15.599
If I do reshape i, yeah, yeah.
00:32:15.759 --> 00:32:18.960
Expected array of uh integers but found array of characters.
00:32:19.200 --> 00:32:28.000
This at sign means um ASCII, whereas if I put like, I don't know, um it says U for Unicode.
00:32:28.319 --> 00:32:29.279
Ah, nice.
00:32:29.680 --> 00:32:30.559
That's very nice.
00:32:30.880 --> 00:32:33.440
Um yeah, so that's basically that feature.
00:32:33.519 --> 00:32:36.720
It probably needs only somewhere, but I think some people are using it already.
00:32:36.960 --> 00:32:46.880
It's basically good right now for like your sanity checks of like make sure this thing takes this kind of value before you even bother running the rest of the code and having it fail in some weird other place, right?
00:32:47.039 --> 00:32:47.759
Um yeah.
00:32:48.079 --> 00:32:50.160
Yeah, I can really use that uh at work.
00:32:50.559 --> 00:32:53.279
Uh I use API at work, by the way.
00:32:53.359 --> 00:33:02.079
And uh yeah, we run into this like uh uh empty array and uh you know string versus uh character uh versus uh numbers almost all the time.
00:33:02.240 --> 00:33:05.839
You know, if it would be nice if you know we we can know something beforehand.
00:33:06.079 --> 00:33:06.400
Yeah.
00:33:06.559 --> 00:33:23.839
I know that uh how would you how would you write if you uh if you want to check a larger array that's a structure of no as remind me again, we will has we were has type arrays and yeah, we have box arrays, um and it has what we call data depths.
00:33:23.920 --> 00:33:26.240
So I can make a let's say just like a person.
00:33:26.640 --> 00:33:30.079
Person, and I'm just gonna give them I'll just take this simple way.
00:33:30.319 --> 00:33:30.559
Uh uh.
00:33:31.519 --> 00:33:33.440
And let's say they have a name and an age.
00:33:33.599 --> 00:33:42.720
This defines basically um it defines a module called person and then it adds a bunch of helper functions and things um that may have a name and an age.
00:33:42.799 --> 00:33:45.920
I can make one, I don't know, it's Dan, and Dan is 31.
00:33:46.079 --> 00:33:49.920
Um, this essentially just makes a oh that's not supposed to look like that.
00:33:50.079 --> 00:33:55.200
Um this essentially just makes a box array um shape two um with these things in it.
00:33:55.359 --> 00:34:00.079
If I unbox it, it will um uh Max, I think you're going.
00:34:00.559 --> 00:34:02.799
Um it'll give me my values back.
00:34:02.960 --> 00:34:03.759
They're labeled.
00:34:04.000 --> 00:34:06.480
Um but then what just happened?
00:34:06.559 --> 00:34:09.920
What was the result you got back when you unboxed it?
00:34:10.320 --> 00:34:12.880
It's two different values and they both have labels on them.
00:34:13.039 --> 00:34:16.320
Labels are like a piece of metadata attached to Ah, that's what's happening.
00:34:16.400 --> 00:34:17.920
Okay, we can't interact with the labels.
00:34:18.159 --> 00:34:19.280
They're for right, okay.
00:34:19.440 --> 00:34:20.239
Yeah, yeah.
00:34:20.480 --> 00:34:23.199
Um, like if I do this, you'll see multiple lines.
00:34:23.440 --> 00:34:25.280
Um so there's that.
00:34:25.519 --> 00:34:30.719
Now, and then the module, so person, it lets you call it as a function to construct the thing.
00:34:30.880 --> 00:34:34.719
Um, but then if I do name here, um, it'll give me the name back.
00:34:34.880 --> 00:34:40.559
And this is essentially just a function that like um gets the item out, unboxes it, and removes the label.
00:34:40.800 --> 00:34:46.559
And so this is essentially assigned to the name directly if you wanted to update the name after the fact.
00:34:46.800 --> 00:34:47.519
Oh, sure, sure.
00:34:47.599 --> 00:34:54.559
With um with the the inverse system, you just do um set person name uh Alice.
00:34:55.039 --> 00:34:55.440
Boom.
00:34:55.599 --> 00:34:56.480
Now it's updated.
00:34:56.800 --> 00:34:57.119
Oh, yeah.
00:34:57.920 --> 00:34:58.159
Okay.
00:34:58.400 --> 00:35:03.199
I can I could get into why I could get into why unbuy is an update operation.
00:35:03.280 --> 00:35:04.800
I'm not gonna get into that right this moment.
00:35:05.119 --> 00:35:06.719
I guess but okay.
00:35:07.199 --> 00:35:10.400
Uh we can we can do it if you uh we talk about it if you want to.
00:35:10.559 --> 00:35:14.559
Uh maybe that is probably a newer feature since the last time I was here.
00:35:14.800 --> 00:35:21.360
Um it's it's a logical, it's essentially a logical conclusion of the inverse system um that this should be true.
00:35:21.760 --> 00:35:22.800
This is how this should work.
00:35:22.960 --> 00:35:25.679
Um, but it's a lot for a lot more than just this.
00:35:25.920 --> 00:35:28.079
Um but there's that, right?
00:35:28.159 --> 00:35:32.559
Um, so person has a T field currently.
00:35:33.840 --> 00:35:35.360
So let me if I can get rid of this.
00:35:35.599 --> 00:35:38.239
This is the type, and this will work with validate.
00:35:38.320 --> 00:35:43.840
So person is uh an array of any size of any item and an array of any size of any item.
00:35:44.000 --> 00:35:47.440
If I um because these are uh character arrays that are stars.
00:35:47.599 --> 00:35:52.320
Um now if I specify okay, name must be a stir and that'll format for me.
00:35:52.400 --> 00:35:57.039
And age must be a um a uh a scalar number.
00:35:57.199 --> 00:35:58.480
I believe this is how it works.
00:35:58.639 --> 00:36:00.559
Um I put it like this.
00:36:01.360 --> 00:36:02.639
I think so.
00:36:03.119 --> 00:36:06.480
And I should just be able to say, um, is that still gonna work?
00:36:07.199 --> 00:36:09.280
Oh, sorry, I have to type validate here.
00:36:09.519 --> 00:36:10.000
There we go.
00:36:10.239 --> 00:36:11.840
Invalid type specification.
00:36:12.159 --> 00:36:12.800
Interesting.
00:36:12.960 --> 00:36:14.079
Oh, I have to go like this.
00:36:14.480 --> 00:36:15.119
There we go.
00:36:15.360 --> 00:36:20.960
Um, so here is person's type specification, and if I validate it, it works correctly.
00:36:21.280 --> 00:36:23.280
Um and so this can be used.
00:36:23.440 --> 00:36:26.639
Notice here that this type specific, I could have typed this out manually, right?
00:36:26.800 --> 00:36:32.400
This type specification is not about what is the scalar type and what is the shape.
00:36:32.559 --> 00:36:38.079
It is about what are the inner type specifications for each of the fields.
00:36:38.239 --> 00:36:40.400
So if I add another field here, I don't know.
00:36:40.559 --> 00:36:42.159
Um I'll just call it items.
00:36:42.639 --> 00:36:47.599
And it's gonna be a um, I guess just a list, a list of something.
00:36:47.760 --> 00:36:51.360
Um that's a good idea.
00:36:52.320 --> 00:36:53.119
Can we not do that?
00:36:54.480 --> 00:36:55.599
Oh, I have to type it in.
00:36:55.760 --> 00:36:56.800
Uh and cool.
00:36:58.239 --> 00:36:59.599
Oh, it has to be a box array.
00:36:59.760 --> 00:37:00.320
There we go.
00:37:00.559 --> 00:37:02.159
Um, so I can do this.
00:37:02.320 --> 00:37:06.800
Um, and then oh, I might have some things to work out on parts of this.
00:37:07.199 --> 00:37:11.199
But if you could go back back, I'm not sure I was following it tiny here.
00:37:11.280 --> 00:37:14.880
Uh sure I should go back to the previous one here that was that did work.
00:37:15.119 --> 00:37:19.599
So so we're saying uh okay, it's say it's saying the signature of the person.
00:37:19.679 --> 00:37:28.000
This is the value, and this is the sort of signature of the yes, this is the value of this person I made, and this is this down here is the result of person.t.
00:37:28.239 --> 00:37:29.280
Um what is it?
00:37:29.440 --> 00:37:31.440
So I have said two here.
00:37:31.679 --> 00:37:33.760
Uh the at sign is a character.
00:37:33.840 --> 00:37:41.039
So type like um scalar type value specifiers, these are just this right here is a built-in constant that is just itself.
00:37:41.119 --> 00:37:43.280
So if I type char, you can see what it is.
00:37:43.519 --> 00:37:48.559
This is a constant that is the character that it is its identifier.
00:37:48.719 --> 00:37:49.599
Uh okay.
00:37:49.840 --> 00:37:52.639
And it's just a you can just type it like this, right?
00:37:52.800 --> 00:37:53.920
Okay, they're actually the same.
00:37:54.000 --> 00:38:00.800
It's you you've written the syntactic sugar for for at uh double struck R is just R.
00:38:00.960 --> 00:38:01.039
Okay.
00:38:01.360 --> 00:38:02.559
Well, R is a function of returns.
00:38:04.000 --> 00:38:08.320
Yeah, and this is the same like constant system that a bunch of other stuff uses.
00:38:08.480 --> 00:38:09.840
No, no, then now I understand that.
00:38:09.920 --> 00:38:11.519
I was just I didn't understand where that came from.
00:38:11.760 --> 00:38:14.000
Yeah, I should have I should have validated that, yeah.
00:38:14.079 --> 00:38:19.760
Um so this is saying like this is a list of some number of a Unicode characters.
00:38:20.159 --> 00:38:21.679
Yeah, now I understand what I'm saying.
00:38:22.000 --> 00:38:23.679
Yeah, it's just the ad that confuses me.
00:38:24.639 --> 00:38:30.880
So yeah, I so this is um I guess saying, okay, this is the first field and this is the second field.
00:38:31.199 --> 00:38:32.079
These are their types.
00:38:32.239 --> 00:38:33.840
Um validating is part of that.
00:38:34.719 --> 00:38:38.880
You you can make a fixed width field by just putting a any number there.
00:38:39.519 --> 00:38:39.760
Sure.
00:38:39.840 --> 00:38:44.960
Um, if I say your name, your name must be exactly uh three characters, sure, why not?
00:38:45.199 --> 00:38:47.679
And then I don't know, Danny won't work.
00:38:47.840 --> 00:38:48.880
And this could be recursive.
00:38:48.960 --> 00:38:54.320
So you can nest these and it'll just get more and more complicated, but the validation itself is recursive and it'll just check them all.
00:38:54.559 --> 00:39:02.719
Um and if I make a function for this, call I don't know, I'll call F and I'll put my little types back in there, and I'll make um person name.
00:39:03.039 --> 00:39:04.480
Oh, it is not.
00:39:04.800 --> 00:39:07.039
Oh, sorry, it uh it's I need to fix this.
00:39:07.199 --> 00:39:10.800
This is not failing, it is just aliasing when it shouldn't be.
00:39:10.960 --> 00:39:11.840
There we go.
00:39:12.079 --> 00:39:14.639
Um give me a list of boxes.
00:39:14.960 --> 00:39:15.760
Oh, I don't know.
00:39:15.920 --> 00:39:18.320
Validate it takes in a person T.
00:39:18.719 --> 00:39:19.280
There we go.
00:39:19.440 --> 00:39:23.760
Um, so this takes a person in and it gives you three characters.
00:39:23.920 --> 00:39:24.960
I'll go back to this.
00:39:25.119 --> 00:39:25.599
There we go.
00:39:25.920 --> 00:39:28.159
It's it's literally a a character.
00:39:28.400 --> 00:39:28.719
Okay.
00:39:29.119 --> 00:39:29.360
Yeah.
00:39:29.679 --> 00:39:31.760
That's interesting, the the pricing.
00:39:32.159 --> 00:39:32.960
Yeah, yeah.
00:39:33.119 --> 00:39:35.599
Um, so there's all that's basically how it works.
00:39:35.760 --> 00:39:37.760
Um, there's a lot to work out still with this.
00:39:37.840 --> 00:39:40.800
That's why I do want to have this probably in the language.
00:39:40.880 --> 00:39:42.239
I don't know.
00:39:42.400 --> 00:39:44.480
On one hand, it's really cool and it's definitely useful.
00:39:44.639 --> 00:39:48.880
Whether it should be like part of the language, is I'm leaning toward yes.
00:39:48.960 --> 00:39:50.800
Um, but I'm not 100% yet.
00:39:51.199 --> 00:39:53.280
It is very cool whether it ends up in the language.
00:39:53.599 --> 00:39:56.480
I mean, this is and this is a kind of a novel space, right?
00:39:56.559 --> 00:40:00.639
There's not a ton of array languages out there that are experimenting the types of sites.
00:40:00.800 --> 00:40:07.039
Like I know that Ramora, an individual by the name of Justin Slepak, that did a PhD dissertation on a typed J at one point.
00:40:07.199 --> 00:40:16.480
Um and I think there's like a couple other out there, but they're all nothing in like a quote unquote if we can call Wewa a mainstream uh array language.
00:40:16.880 --> 00:40:21.039
Nothing in like the kind of the um the array languages that people are using.
00:40:21.360 --> 00:40:28.800
It's a very, very cool area to um and even like the just the type check at the top, you know, for a beginner that is just trying to experiment with glyphs.
00:40:28.960 --> 00:40:33.760
Not not that they're writing any production code or anything like that, but as a learning tool, I think it's very cool.
00:40:33.840 --> 00:40:48.079
It's it's similar um to the uh what do you call them hints that you give that I I've even like a couple times, and it's you you close them so quickly, I'll I'll I'll ask for like, hey, it would have been great to have a hint for this, and then like literally like three hours later you've merged it in.
00:40:48.159 --> 00:40:48.320
Yeah.
00:40:48.559 --> 00:41:02.159
Where like those that's something that I want in every single array language, where if you make a suboptimal you know composition of four things and there's a single primitive for it and it's just not in your toolbox yet, a lot of times WeWah pad will tell you, hey, you can use this.
00:41:02.239 --> 00:41:03.760
And you're like, oh my god, that's amazing.
00:41:03.840 --> 00:41:08.960
Like uh I just learned something in like less than a second because of the um what do you call it?
00:41:09.039 --> 00:41:12.880
Like compiler-driven um what was the the diagnostics.
00:41:13.119 --> 00:41:13.760
Yeah, yeah, exactly.
00:41:13.840 --> 00:41:24.960
Like that anytime you can get some kind of feedback while you're coding, uh, it's just it's such a a wonderful learning experience, even from someone like I've been doing this for years, and I I still love that kind of stuff.
00:41:25.679 --> 00:41:35.280
But that there we has a strong uh advantage in in the being strict in in valence, right?
00:41:35.840 --> 00:41:40.239
This is incredibly difficult to do in those more dynamic languages.
00:41:41.599 --> 00:41:58.480
You can sort of see an artifact of this uh in in dialogue, which highlights what we call idioms, but actually what actually means is phrases that the interpreter takes as a single instruction rather than being consisting of uh individual parts.
00:41:59.039 --> 00:42:01.039
We went we do have a page out too.
00:42:01.199 --> 00:42:04.719
Um it's actually not this one, it's it's the optimizations, which is like all the stuff.
00:42:05.360 --> 00:42:08.320
That's why that's why I had this caveat with the with the name idioms.
00:42:08.400 --> 00:42:13.199
It's not idioms, it's actually just optimized phrases or recognized phrases or something like that.
00:42:13.440 --> 00:42:18.800
Um so but the interpreter itself does syntax highlighting as well.
00:42:18.880 --> 00:42:21.599
It knows what's going on as much as you can know what's going on.
00:42:21.840 --> 00:42:24.320
Uh nevertheless, it highlights wrong.
00:42:24.480 --> 00:42:29.440
And even setting aside the highlighting, it actually optimizes wrong.
00:42:29.599 --> 00:42:51.599
And occasionally you can get better performance and dialogue by inserting a no-up function inside of an expression to prevent the interpreter from recognizing what it thinks you're doing, because it then tries to prematurely optimize for that thing it thinks you're doing, only to discover at runtime that that's not what you're doing, it has to backtrack and reparse.
00:42:52.400 --> 00:42:55.360
Um so it it is really difficult.
00:42:55.920 --> 00:43:08.559
You don't need the more dynamic the language is, and an APL is here worse than say BQN, because you can't really you can't know the even the the syntactic class of anything until runtime.
00:43:08.719 --> 00:43:16.239
Um you can try to do like a code defense type thing and do analysis analysis, but that it's not always quite possible.
00:43:16.400 --> 00:43:21.199
And certainly when you if you're writing nasty code, you can fool the system in various ways.
00:43:21.280 --> 00:43:24.880
So it would be very difficult to yeah.
00:43:25.039 --> 00:43:30.639
I've had a good amount of optimizations that I've ended up removing because I've realized that they're not actually sound.
00:43:30.880 --> 00:43:36.400
Um a lot of those have to do with like um execution order of things, right?
00:43:36.559 --> 00:43:40.320
This optimization only works if the functions are pure or something like that.
00:43:40.480 --> 00:43:42.000
Um stuff like that.
00:43:42.239 --> 00:43:42.960
Um cool.
00:43:43.119 --> 00:43:44.400
That's types though.
00:43:44.480 --> 00:43:49.760
Um there is a third big so all the three big features, like I said, in 0.19 are experimental.
00:43:49.840 --> 00:43:54.559
There is a third one um that is the least I think it's really cool.
00:43:54.719 --> 00:43:57.199
Um others, some other people think it's really cool.
00:43:57.280 --> 00:43:59.760
Um, I don't know that it's worth like.
00:44:00.159 --> 00:44:03.440
Like putting in a language and not just having as a library.
00:44:04.079 --> 00:44:05.360
But I can show that one too.
00:44:05.519 --> 00:44:07.119
And that one is where is it?
00:44:07.280 --> 00:44:08.559
Geometric algebra.
00:44:09.039 --> 00:44:11.039
Do you guys know anything about geometric algebra?
00:44:11.360 --> 00:44:11.760
Let's assume.
00:44:12.480 --> 00:44:13.440
Yeah, let's assume we don't.
00:44:13.519 --> 00:44:15.679
We know Max does because he's got questions.
00:44:16.159 --> 00:44:19.199
But I mean, and by assume, like I don't.
00:44:19.360 --> 00:44:32.400
So I'm just um so geometric algebra is a it's hard to let's it's a whole system of math that deals with objects called multivectors.
00:44:32.559 --> 00:44:39.519
Um these are vectors, but also things that are very vector-like, um, that have magnitudes and directions in different ways.
00:44:39.679 --> 00:44:49.440
Um, and it kind of unifies um like a bunch of different transformations and a bunch of different operations um into one much easier to use system.
00:44:49.599 --> 00:44:58.639
And this this tutorial I have here on the experimental page on Wea, the WeGo website, um, shows you one of the applications you can use for this.
00:44:58.800 --> 00:45:07.440
Um the main idea though is that the same object that represents like a vector or a point can also represent a rotation or a translation or a bunch of other things.
00:45:07.519 --> 00:45:11.280
And it's not just good for like geometry, it's also has a few other niche applications.
00:45:11.360 --> 00:45:16.960
Um the other one I can show down below is like um auto differentiation, which is kind of cool.
00:45:17.119 --> 00:45:30.800
Um uh the basic idea is that there's a special operation called the geometric product, which when used on two vectors has a useful result that can then be applied again to other vectors to make use of it.
00:45:30.960 --> 00:45:33.679
Um so the example here, I'm not gonna like go through the whole thing.
00:45:33.840 --> 00:45:37.039
The example here is using it to rotate a cube.
00:45:37.280 --> 00:45:41.679
I want to make a um like a like an animation of a rotating cube.
00:45:41.760 --> 00:45:46.719
And to do that, right, you have to do um one, you have to set up all your like your cube geometry.
00:45:46.800 --> 00:45:47.360
That's the easy part.
00:45:47.440 --> 00:45:48.880
That's easy in an array language.
00:45:49.039 --> 00:45:55.280
Um, and then you have to do projections and intersections onto your like camera plane, right?
00:45:55.440 --> 00:46:02.000
Um geometric algebra is very good at projections and translations and rotations and things.
00:46:02.159 --> 00:46:10.960
Um so what this does is we generate all the points of a cube and well, we start with a square actually, because we do this in two dimensions before we do it in three just to show.
00:46:11.119 --> 00:46:14.719
Um, so here we I don't know if you can see it here, but there's little dots on the edge.
00:46:14.800 --> 00:46:18.800
I'm just making my cube a big point, a big cloud of dots that make a square here.
00:46:19.039 --> 00:46:25.840
Um and then um it uh turns them all into these multivector objects, which in this case are just vectors.
00:46:25.920 --> 00:46:29.280
This this E notation is something you'll see a lot in geometric algebra.
00:46:29.440 --> 00:46:32.000
You can think of these as like X and Y essentially.
00:46:32.079 --> 00:46:39.440
Um, but you're gonna have things that are like E1, two, which is gonna be a different kind of uh higher order of vector.
00:46:39.679 --> 00:46:49.360
Um and then I generate a bunch of rotations, and then I apply all those, turn all those rotations into multive vectors, and then apply them all, and eventually I get this rotating square.
00:46:49.519 --> 00:46:52.559
Um, this could have just been done with complex numbers.
00:46:52.639 --> 00:46:56.639
In many ways, multivectors are a superset of complex numbers.
00:46:56.800 --> 00:47:01.760
Um, but then what you can't do with with complex numbers is go up a dimension.
00:47:01.920 --> 00:47:07.519
And the way that I wrote them for Wiwa, they are totally like dimension generic.
00:47:07.840 --> 00:47:21.039
Um so here basically what I do is I make I turn my code that makes a square into a code that makes a cube, and then I do the same rotation just in one more dimension, and then I project it onto a camera plane.
00:47:21.199 --> 00:47:28.159
Um, and this I think I did a pretty good job with this tutorial if anyone's interested in reading like all the steps it takes.
00:47:28.320 --> 00:47:33.920
Um, but eventually we get this nice rotating cube with a uh perspective projection.
00:47:34.079 --> 00:47:39.199
Um and I'll make it a little bigger just to make it easier to see, um, which I think is cool.
00:47:39.440 --> 00:47:50.960
And then I show that, oh, we can actually um we can try it with different rotations, and it all it is is like a rows operation of different um projection axes, right?
00:47:51.119 --> 00:48:00.000
Or we could do it in all the all the axes at once, and then we have this very fast rotating cube rotating along some bigger uh mixed axis.
00:48:00.320 --> 00:48:05.679
What's really cool about this is you can go even further and you can project uh a hyper cube.
00:48:05.760 --> 00:48:10.960
And so here I didn't it doesn't go through it all, but here's the example that like does the classic like Tesseract rotation.
00:48:11.039 --> 00:48:12.800
I can make a little higher S too.
00:48:12.960 --> 00:48:15.440
Um and I just think it's a bigger as well.
00:48:15.519 --> 00:48:16.719
This is looks so crazy.
00:48:16.960 --> 00:48:19.840
Yeah, um I'm I'm sure you've seen like the rotate.
00:48:19.920 --> 00:48:21.199
Here I'll make it a I have not.
00:48:22.159 --> 00:48:23.760
I haven't found this corner of the nerd in the case.
00:48:24.880 --> 00:48:26.239
No, no, this is the first time for me.
00:48:26.800 --> 00:48:33.039
This is the classic, this is the classic visualization of a rotating hyper queue, like a four-dimensional analog of a queue.
00:48:33.280 --> 00:48:35.679
Um and this is a good amount of code, I guess.
00:48:35.760 --> 00:48:38.159
Um, but I think it's cool that um you can do this.
00:48:38.320 --> 00:48:50.000
In many ways, multi-vectors, or at least in this type of application, multivectors are um they're a replacement, but also I think they're kind of isomorphic to um like matrices, like transformation matrices.
00:48:50.159 --> 00:48:55.440
Um, I personally find them easier to reason about, uh, but that's just because I'm not really big into linear algebra.
00:48:55.519 --> 00:48:56.000
Um, yeah.
00:48:56.320 --> 00:48:57.280
What was the motivation?
00:48:57.519 --> 00:48:58.000
This is so cool.
00:48:58.159 --> 00:48:59.039
What was the motivation for this?
00:48:59.119 --> 00:49:05.119
Is it was there a corner of the Weewa community that was you know pounding saying geometric algebra, geometric algebra?
00:49:05.360 --> 00:49:07.280
I forget no, there definitely wasn't.
00:49:07.440 --> 00:49:11.440
Um people definitely want like complex numbers, and that's why I added those a long time ago.
00:49:11.599 --> 00:49:28.159
Um, but I think I just learned about it and I was like, this is actually a really cool system, but it's only good if your language has like like you can have like libraries that support this well, but it'd be really cool to have it like first class and support it, um, because you can do lots of cool math stuff and visualizations with this.
00:49:28.400 --> 00:49:31.039
Um and so I learned about the topic, I thought it was really cool.
00:49:31.119 --> 00:49:33.920
I watched like hours of videos about how it all works.
00:49:34.079 --> 00:49:53.280
Um, and I really like the idea that you can take these same algorithms that because because if you do like um like in normal geometry, your like intersection formulae can look very different depending on like the number of dimensions and things you're in, or the kind of things you're checking for an intersection in, or same thing with like projection algorithms stuff.
00:49:53.360 --> 00:49:58.880
The formulas end up looking very different, whereas in in geometric algebra, they're all unified.
00:49:58.960 --> 00:50:08.400
Like a projection of any object onto any other object looks is the exact same operation in any number of dimensions in geometric algebra, which is really cool.
00:50:08.639 --> 00:50:16.719
Um, you don't have to bother with knowing how many dimensions there are, or even a line onto a plane, it's the same as a plane onto the plane, is the same as a point onto a line.
00:50:16.800 --> 00:50:18.719
It's all the same, um, which is really cool.
00:50:19.039 --> 00:50:22.320
Geometric algebra is uh linear algebra done right.
00:50:22.880 --> 00:50:23.119
Yeah.
00:50:24.000 --> 00:50:37.280
I was uh kind of uh I guess a mad that uh I only learned it uh uh after being told uh no these uh workarounds and lies uh in a standard linear algebra, like uh the cross product that's uh the worst of vendor.
00:50:37.679 --> 00:50:38.320
Yeah, yeah.
00:50:38.480 --> 00:50:40.239
So this has like what the what the wedge product.
00:50:40.320 --> 00:50:45.760
So there are some special glyphs in here that are sp only basically they work on everything, but they're specific to geometric algebra.
00:50:45.920 --> 00:50:49.039
This one is the outer product, um, which is like the wedge product.
00:50:49.679 --> 00:50:55.039
Which is the report.19.
00:50:55.119 --> 00:50:55.679
And you can do that.
00:50:55.920 --> 00:51:03.280
Whether this needs its own glyph is I'm not sure, but because yeah, you have table, which is the beautiful window, you know, four quadrants.
00:51:03.360 --> 00:51:06.400
And then I saw this and it was called outer product, and I was like, whoa, whoa, whoa.
00:51:06.480 --> 00:51:12.800
I thought Wewa's name for the APL outer product was table, but now there's a new one, and I was thinking, what's the difference?
00:51:13.039 --> 00:51:17.119
Yeah, this count should maybe be called the wedge product to make it more um thing.
00:51:17.199 --> 00:51:19.280
It's kind of like the cross product, but way better.
00:51:19.519 --> 00:51:22.960
Um there's another one called uh I believe it's called just inner product.
00:51:23.039 --> 00:51:25.519
Um if I show my experimentals here.
00:51:25.760 --> 00:51:26.559
Yeah, I saw that as well.
00:51:26.880 --> 00:51:30.800
Um this one right here, which is another geometric algebra operation.
00:51:31.039 --> 00:51:36.239
For the for the audio listener, we have outer product, which is a cross, which is like the X.
00:51:36.320 --> 00:51:36.719
I don't know.
00:51:37.039 --> 00:51:38.000
I know that there's like relationships.
00:51:38.320 --> 00:51:38.719
Multiply.
00:51:38.960 --> 00:51:40.559
The multiply, yeah, with a line under it.
00:51:40.800 --> 00:51:44.480
And the inner product was uh the multiply with a line with a dot over it.
00:51:44.719 --> 00:51:45.199
A dot over it.
00:51:45.519 --> 00:51:47.039
Those are not normal notation.
00:51:47.119 --> 00:51:50.079
Um, it's what I could find in Unicode that I thought felt right.
00:51:50.639 --> 00:51:52.320
Um, and they work here.
00:51:52.480 --> 00:51:58.000
Uh one of the other cool applications of uh geometric algebra is auto differentiation.
00:51:58.320 --> 00:52:02.239
Um so it can define the derivative of some function.
00:52:02.400 --> 00:52:06.480
Um already has an experimental derivative operation, but I just thought this was a cool demo.
00:52:06.559 --> 00:52:10.079
Um that uses, I didn't even add any features specifically for this.
00:52:10.239 --> 00:52:13.280
It's just a thing that falls out of geometric algebra that's really cool.
00:52:13.519 --> 00:52:24.000
And so basically I have this function f um that is like a polynomial, and then I hand implement the um the derivative of this polynomial, which is another polynomial.
00:52:24.159 --> 00:52:32.159
Um, and then I show how you can use like a very simple geometric algebra operation to get the exact same thing based on it.
00:52:32.320 --> 00:52:40.639
Basically, if you run the original function on a specific kind of multivector, um, you can get the derivative without having to figure out the derivative yourself, which I think is very cool.
00:52:40.960 --> 00:52:47.920
So is is uh the inner product and outer product are these two glyphs that go hand in hand with geometric algebra?
00:52:48.000 --> 00:52:49.039
Is that how we should think about it?
00:52:49.360 --> 00:52:54.880
They have different geometric algebra operations, but yes, they're only really useful in a geometric algebra context.
00:52:54.960 --> 00:52:58.480
They they do operate on normal numbers, but they're basically just multiply.
00:52:58.639 --> 00:53:03.679
Um, for complexes, they're they're slightly more nuanced, but they're basically still just multiply.
00:53:04.239 --> 00:53:08.559
And I I have a like on my list of books to read is this book on linear algebra.
00:53:08.719 --> 00:53:11.440
Should I be replacing that with some geometric algebra book?
00:53:11.519 --> 00:53:14.000
Apparently, if Max is saying this is linear algebra done done.
00:53:14.480 --> 00:53:15.360
Pretty biased.
00:53:15.599 --> 00:53:16.639
I think it's pretty good.
00:53:16.719 --> 00:53:16.960
Yeah.
00:53:17.199 --> 00:53:17.519
All right.
00:53:17.760 --> 00:53:24.480
Theoretically, also you can store certain transformations in less space in G as a multivector than as a matrix, but I don't know.
00:53:24.639 --> 00:53:25.760
Um that is the feature.
00:53:25.840 --> 00:53:29.599
I don't know if this is gonna make it in to not to ever not experimental.
00:53:29.679 --> 00:53:33.679
Um, but I think it's very useful for these kinds of like cool visualizations and things.
00:53:33.840 --> 00:53:34.639
Um yeah.
00:53:35.039 --> 00:53:43.440
I think uh these uh geometric numbers uh are as fundamental as uh complex numbers, which uh uh dialogue supports as well.
00:53:44.079 --> 00:53:53.440
I know um NARS 2000 has um uh octonians, which is also which are also not good.
00:53:53.519 --> 00:53:59.679
Um and this is like the way better version of hyper some version of hyper complex numbers um that are actually used in different.
00:54:00.239 --> 00:54:05.519
Use use a geometric algebra, forget about a complex octonius, quaternious.
00:54:05.760 --> 00:54:08.800
It's uh just the under one uh you know the framework.
00:54:09.119 --> 00:54:09.920
Yeah, exactly.
00:54:10.159 --> 00:54:10.559
All right.
00:54:10.719 --> 00:54:14.639
That is the biggest features of, and they're all experimental, like you said, of 0.19.
00:54:14.719 --> 00:54:15.760
There are a lot of other little things.
00:54:15.920 --> 00:54:17.360
There's a million little tiny things.
00:54:18.000 --> 00:54:20.559
Depends on how much tiny is relative.
00:54:20.639 --> 00:54:22.079
Uh, but there are a lot of other little things.
00:54:22.880 --> 00:54:25.199
How do you do uh everyday?
00:54:25.599 --> 00:54:34.719
Well, I I understand that the there are issues with the equatorians, luxonians, and and even there's another name for the ones with 16 dimensions, whatever over there.
00:54:34.880 --> 00:54:36.159
That's like useless.
00:54:36.400 --> 00:54:50.960
Um but uh be that as it may that that the geometric album might be better, it's fairly no common to need to do mathematics on just normal complex numbers.
00:54:51.119 --> 00:54:52.960
But does we actually do that?
00:54:53.199 --> 00:54:54.559
Like have complex numbers?
00:54:54.719 --> 00:54:55.519
Yeah, yeah.
00:54:55.679 --> 00:54:57.119
It's had them for a long time.
00:54:58.239 --> 00:55:00.880
I mean, I'm not I'm not a regular weaver user, so I don't know.
00:55:01.199 --> 00:55:03.679
But I can imagine that I'm not the only one with this question.
00:55:04.079 --> 00:55:04.400
Sure.
00:55:04.480 --> 00:55:05.360
Um complex.
00:55:06.000 --> 00:55:08.000
Um what uh one, two, three.
00:55:08.400 --> 00:55:11.039
It's uh it's a pervasive operation too.
00:55:11.199 --> 00:55:16.639
Um so this makes the uh four and one i, five and two i, six and three i.
00:55:16.719 --> 00:55:20.239
So the complex is the first argument, and the real is the this argument.
00:55:20.400 --> 00:55:22.000
Um you can also write them if you want to.
00:55:22.079 --> 00:55:31.199
I could write like um four, I think it's four r i five r two i six r three i.
00:55:31.440 --> 00:55:47.280
And the real and complex uh thing, but but if I take the square root of a negative number, then ah yes, so it will not automatically convert because it's not so um square roots on a just normal negative number is negative.
00:55:47.519 --> 00:55:53.760
Yeah, um it doesn't check, it's not gonna check your numbers um to see if they can be made complex.
00:55:53.840 --> 00:56:16.159
And also you don't want to check, I don't want things that the type output is based on the input values because in the output, if I did this, for example, um like if I if I put some my negative number in a list with a bunch of other potentially non-negative numbers, I don't want it to have to check all the numbers first and then conditionally output complex or real.
00:56:16.400 --> 00:56:17.280
I want to just short.
00:56:17.840 --> 00:56:24.159
However, if I do if I make it complex myself, um it will give you the complex results.
00:56:24.639 --> 00:56:29.199
So okay, so so we was basic numbers are floats.
00:56:29.360 --> 00:56:30.079
Is that how it works?
00:56:30.880 --> 00:56:31.119
Yeah.
00:56:31.440 --> 00:56:31.760
Okay.
00:56:32.400 --> 00:56:36.400
And but then you don't you don't auto-convert types like that.
00:56:36.800 --> 00:56:43.199
You can also do uh e12 under experimental, I think that uh returns uh i as well.
00:56:43.519 --> 00:56:45.760
Uh yes, because oh there we go.
00:56:46.000 --> 00:56:56.000
Um e1, well it is i it's a e12 is a geometric algebra multivector that is um has all the same properties as i basically.
00:56:56.480 --> 00:57:02.960
But it doesn't special case uh under this uh uh e12 uh system.
00:57:03.360 --> 00:57:03.840
Yeah, it is.
00:57:04.079 --> 00:57:09.280
Do you have uh types uh uh for complex as well if you want to type check it's on complex number?
00:57:09.599 --> 00:57:10.000
Sure.
00:57:10.320 --> 00:57:19.920
Um there's that it actually considers i and e12 as equivalent if you compare them, even if it's yeah, like if oh does it?
00:57:20.079 --> 00:57:20.559
That's cool.
00:57:20.880 --> 00:57:27.360
Yeah, but it's interesting because they are sort of distinct in identity, so they're sort of like positive and negative zero type thing, right?
00:57:27.840 --> 00:57:38.079
Currently uh multivectors are considered the same like type as complexes, or or rather complexes are considered multivectors.
00:57:38.159 --> 00:57:44.480
And so like a type of these uh type of i and type of e1, two, is gonna be evaluated the same.
00:57:44.639 --> 00:57:49.519
Their representation in like internally is different, but um these are considered the same.
00:57:49.679 --> 00:57:54.719
Uh the the built-in complex numbers are gonna be way faster than the multivectors currently.
00:57:55.280 --> 00:58:00.079
So uh you added uh geometric algebra as an extension, right?
00:58:00.159 --> 00:58:03.599
It's not uh breaking any existing logic with complex numbers.
00:58:04.400 --> 00:58:07.760
Especially because it is um experimental.
00:58:08.079 --> 00:58:13.119
And also by having hard-coded complex numbers, you can they're so much faster.
00:58:13.280 --> 00:58:17.920
Um multivectors can be kind of arbitrary size and can take up a lot more memory than they necessarily need.
00:58:18.000 --> 00:58:22.079
And if all you need is complex numbers, which you do um a good chunk of the time.
00:58:22.480 --> 00:58:24.960
I I use them for I use them for stuff you wouldn't.
00:58:25.199 --> 00:58:29.920
It's a sort of thing, and this is uh kind of a philosophy I have about adding stuff to the language.
00:58:30.079 --> 00:58:36.719
There's a lot of things you can use elegantly to solve problems that you wouldn't always do.
00:58:36.960 --> 00:58:41.440
Like you would, there's a lot of things you could use to solve problems that you wouldn't import a library for.
00:58:41.599 --> 00:58:47.039
But if you just got the thing there at your fingertips in the language, it's a good, it's a cool thing you can use.
00:58:47.119 --> 00:58:50.719
Um so I've used complex numbers for like um what's good?
00:58:51.039 --> 00:58:55.519
A good example is like um if I have some list of numbers, um I don't know.
00:58:56.639 --> 00:58:57.920
Actually, I'll just make a range.
00:58:58.000 --> 00:59:17.599
If I have like a range of numbers and then I do like uh range raise i to all their powers, um I'll just round so we can see um I now have like directions and I can even like uncomplex these and then uh make my these nice vectors of like all my offset directions.
00:59:17.679 --> 00:59:22.960
And if I want them to be specific directions, I can just put a bunch of different numbers in um and it'll give you that.
00:59:23.039 --> 00:59:25.920
So there's some cool applications of complex numbers for things.
00:59:26.000 --> 00:59:30.960
Um we also have like complex number image output and stuff, like a visualization of your complex fields and things.
00:59:31.039 --> 00:59:37.119
Um and and your complex numbers are just paired floats or yeah, with all the operations.
00:59:37.360 --> 00:59:44.239
Um a couple other small things from 0.19 is like um all uh in the past we've only had like signed.
00:59:44.639 --> 00:59:47.280
Um it's not there we are.
00:59:47.440 --> 00:59:53.519
Um we now have like named stuff for all the I don't know why this device is such a weird decimal.
00:59:53.599 --> 00:59:59.840
Um but we have uh named versions of all the trig and hyperbolic trig or hyperbolic functions.
01:00:00.320 --> 01:00:07.679
Um so yeah, the the reason you have the odd numbers because it's all essentially zero with a rounding.
01:00:08.159 --> 01:00:09.039
Yeah, it is.
01:00:09.199 --> 01:00:14.239
Um so you just got like cosine, sine, tangent, and then like all the hyperbolic ones and all their inverses.
01:00:14.960 --> 01:00:15.360
Huh.
01:00:15.519 --> 01:00:18.400
That's an eta uh tau before.
01:00:24.719 --> 01:00:25.119
Quarter pi.
01:00:25.280 --> 01:00:27.119
Sorry, quarter quarter tau, quarter tau.
01:00:27.519 --> 01:00:31.599
Yeah, the support for tau is also uh very insightful.
01:00:31.679 --> 01:00:34.960
That's another you know, uh map I was trying to use in school.
01:00:35.440 --> 01:00:37.679
Um we do have tau in there.
01:00:37.920 --> 01:00:38.159
Right.
01:00:38.400 --> 01:00:43.599
And I use this, I use tau mainly for and you can do write stuff like I don't know, tau report and potato.
01:00:44.559 --> 01:00:45.199
That's cute.
01:00:45.519 --> 01:00:53.119
Um what it does is does it has like fuzziness factor or something to make this work?
01:00:53.280 --> 01:01:01.360
Or I mean if I type like like if I just type typing out enough digits of pi eventually 2253 five eight nine?
01:01:01.599 --> 01:01:03.199
Look at this nerd flex right here.
01:01:03.440 --> 01:01:04.320
There we go, there we go.
01:01:04.400 --> 01:01:06.880
I typed in enough digits of pi, and it's like, oh yeah, that's just pi.
01:01:07.519 --> 01:01:11.039
Okay, but that mean that mean uh hold on, but you said that doubles.
01:01:11.280 --> 01:01:17.760
Okay, so uh if you have to type out every single digit to be precise, 17 or something.
01:01:18.480 --> 01:01:22.239
That's like possible exactly as no desist of a pi.
01:01:22.480 --> 01:01:25.280
Oh, look when I when I took out a digit, it says it's about pi.
01:01:25.760 --> 01:01:28.400
Oh it really seems like it's supposed to be pi.
01:01:28.880 --> 01:01:29.440
Oh, okay.
01:01:30.880 --> 01:01:32.000
Um there's a lot of things like that.
01:01:32.079 --> 01:01:36.079
If another likes uh square root two, it's just like oh that's square root two.
01:01:36.639 --> 01:01:41.440
Oh, so uh okay, but this is not actually symbolic algebra, it's just faking it.
01:01:41.519 --> 01:01:46.960
But it's just yeah, it's for stuff that really looks seems like it's supposed to be something it does that.
01:01:47.199 --> 01:01:51.519
Yeah, if it has rationale, so why not add uh the same support for rooted numbers?
01:01:51.679 --> 01:01:54.000
That's uh answered that's a cool idea.
01:01:54.239 --> 01:01:54.639
Yeah.
01:01:54.880 --> 01:01:59.119
Um, I think that's I have like blog posts for every single release.
01:01:59.360 --> 01:02:07.039
If people want to like know the main features from that, um I can't quite some of the uh it's uh voxel support.
01:02:07.119 --> 01:02:08.480
Uh is it in this version too?
01:02:08.800 --> 01:02:12.000
Uh yeah, that's now that's from a few versions ago.
01:02:12.159 --> 01:02:15.679
Um, this is a great visualization tool.
01:02:15.920 --> 01:02:30.559
Um so what it is, is a built-in renderer that turns your arrays into images that are like voxels, like like three-dimensional pixels, and it renders them from a certain can camera angle.
01:02:30.639 --> 01:02:32.719
It's good for visualizations or making quick little stuff.
01:02:32.880 --> 01:02:33.679
This is another idea.
01:02:33.840 --> 01:02:35.519
This is still experimental currently as well.
01:02:35.599 --> 01:02:41.199
This is another example of if it's there at your fingertips, it's easy for you to reach for.
01:02:41.360 --> 01:02:42.559
Um, I'll give a quick example.
01:02:42.639 --> 01:02:52.800
If I make just a random array, um, I'll just generate an array of um 10 by 10 by 10 um with a random seed.
01:02:52.960 --> 01:02:55.440
Here's a bunch of numbers, and then I'm gonna round them.
01:02:55.920 --> 01:02:57.599
I'll make them a little smaller.
01:02:57.840 --> 01:03:03.679
Basically, I'm just generating a bunch of a three-dimensional array, a bunch of ones in some places, but mostly zeros.
01:03:03.920 --> 01:03:05.280
Um, there it is.
01:03:05.519 --> 01:03:08.639
And then what I can do is I can call this voxels function.
01:03:08.880 --> 01:03:10.559
Um now it's very small.
01:03:10.639 --> 01:03:11.760
I'll make this a little bigger.
01:03:11.840 --> 01:03:14.480
I'll make a hundred, well, let's do 30 by 30 by 30.
01:03:14.639 --> 01:03:16.800
So you can kind of see this cloud of points in my example.
01:03:16.880 --> 01:03:23.440
But what's cool is that it has this is another feature that's been around since I think a version or two ago.
01:03:23.599 --> 01:03:29.920
Um, is that some primitives, but also your own built-in functions, can have optional arguments if you turn them into uh modifiers.
01:03:30.000 --> 01:03:40.000
So if I do actually I want it to be bigger, I want the scale to be three, I want there to be a fog so that it's easier to render, and then I can see, oh, there's my there's my array.
01:03:40.239 --> 01:03:42.559
Here's a let's make a little starser here.
01:03:42.639 --> 01:03:43.840
There's a bunch of points there.
01:03:44.000 --> 01:03:53.760
Um and I can do cool stuff like if I want to render it with um rotation, I can do um just make a quick rotation array.
01:03:53.920 --> 01:03:59.519
Um, I don't know, maybe 20 frames, and then I will uh do a camera position.
01:03:59.840 --> 01:04:02.880
And we should oh, and I have to do a row zone here.
01:04:03.039 --> 01:04:06.559
Maybe that's a little quick, uh, maybe like 60 frames.
01:04:06.960 --> 01:04:10.480
There's my cool like visualization of this rotating cloud of points.
01:04:10.639 --> 01:04:16.800
Um I just like that for quick and quick and dirty like multimedia visual visualizations of stuff.
01:04:17.199 --> 01:04:20.159
It's uh we can do color, it can do transparency.
01:04:20.400 --> 01:04:21.039
Yeah, yeah.
01:04:21.119 --> 01:04:25.280
I can't think of another language that can uh get this done in this uh Q code.
01:04:25.599 --> 01:04:27.360
Yeah, I like applying it to other certain things.
01:04:27.440 --> 01:04:35.280
Like if I go to say the game of life example, I can then just take this and be like, oh, turn it, uh just turn this whole array of the game of life.
01:04:35.440 --> 01:04:40.880
Uh I'm not gonna upscale it here, I'm just gonna do like voxels, uh set scale.
01:04:41.199 --> 01:04:42.320
I'll do like three.
01:04:42.559 --> 01:04:43.760
I think that should just work.
01:04:43.920 --> 01:04:46.400
Um, and then I'll and I'll do some flock.
01:04:46.639 --> 01:04:54.320
And so here's like my whole visual three-dimensional visualization of the the lifetime of this game of life simulation, which I think is cool.
01:04:54.559 --> 01:04:55.119
That's awesome.
01:04:55.360 --> 01:04:58.800
Um this is one of like a few other experimental features.
01:04:58.880 --> 01:05:00.000
Another one is like noise.
01:05:00.239 --> 01:05:13.280
So if I do like noise, and I think I want seed zero to two octaves, and then I'll do like times two this this basically given some numbers, um, it generates um corner right.
01:05:13.679 --> 01:05:14.960
Do I have this backwards?
01:05:15.199 --> 01:05:17.840
Um, I might, I shouldn't.
01:05:18.000 --> 01:05:21.199
Maybe I'll just go to the examples for this for this thing to know how it works.
01:05:21.360 --> 01:05:29.119
Um so it just generates basically perlining noise, um, which is useful for a lot of other visualization things or like cool simulations and whatnot.
01:05:29.360 --> 01:05:31.039
These are kind of like the edge features.
01:05:31.119 --> 01:05:35.039
They're like other like more array-esque language features I could go over.
01:05:35.199 --> 01:05:47.119
Um, I could talk about if you guys wanted to, why unbuy is a set operation, like set this thing um about this thing, and conversely, and also anti buy, which is similar.
01:05:47.280 --> 01:05:48.480
Um yeah, definitely.
01:05:48.559 --> 01:05:49.840
I'm I'm curious to hear that.
01:05:49.920 --> 01:05:51.519
Uh sure, sure.
01:05:51.760 --> 01:05:59.760
Um, so uh the unmodifier has the rule that the resulting modified functions signature.
01:06:00.320 --> 01:06:02.400
Must be the opposite of the input.
01:06:02.639 --> 01:06:11.119
So if I have a say couple function, uh like couple two numbers together, um uncoup that takes in two arguments and gives you back one.
01:06:11.440 --> 01:06:14.639
Uncouple must take one argument and get back a two.
01:06:15.119 --> 01:06:25.440
So if I have something like um uh the by function, the by modifier, let's say I do say buy pick um three out of my like array of numbers.
01:06:25.599 --> 01:06:36.239
So I'm pick would pick um the number three or the sorry, the third index three out of my array, and then buy uh keeps the original array around.
01:06:36.559 --> 01:06:40.960
So this takes in two values and it um returns two values.
01:06:41.199 --> 01:06:45.679
Um actually I should do one with buy action, uh with un instead of NT.
01:06:45.840 --> 01:06:47.360
So I'm gonna do first instead.
01:06:47.679 --> 01:06:52.800
So the function first gives you the first item in the array, um, and the buy operation keeps the array around.
01:06:52.880 --> 01:06:54.880
So this takes in one value and gives back two.
01:06:55.039 --> 01:07:00.960
If I do unbuy and then first, you are doing the opposite of this operation.
01:07:01.039 --> 01:07:12.320
And because uh the original unfur or buy first takes in an array and gives you back two results, this unbuy first should take in two results and give you one.
01:07:12.559 --> 01:07:24.400
So if I do say if I do unbuy first and then I do say some character, I can then put some string and then it'll set the first item in that string, which is cool.
01:07:24.480 --> 01:07:26.239
And so this is like an amend essentially.
01:07:26.400 --> 01:07:32.400
And if I wanted it to do it for um at a certain index, I have to use what's called anti-by.
01:07:32.800 --> 01:07:36.320
Um, there's a reason I can't use unby because pick is a dyadic function.
01:07:36.480 --> 01:07:39.440
Um, but it works essentially the same way.
01:07:39.599 --> 01:07:41.599
Let's actually do select for a cool.
01:07:41.840 --> 01:07:51.440
If I do anti by select uh like the numbers one and two, and then I'll do like the two, I don't know, two other characters into some bigger string.
01:07:51.599 --> 01:07:57.519
Um, we can see that it puts those characters in the given positions in that string.
01:07:57.679 --> 01:08:00.320
Um, this is a logical result of.
01:08:00.480 --> 01:08:02.800
I guess there's other ways that this could be implemented.
01:08:02.880 --> 01:08:06.159
This is the most useful, and that is a sound inverse.
01:08:06.320 --> 01:08:14.400
Um and so this is just one of the many ways that we uses inverses to make a bunch of operations available that you don't need new primitives for.
01:08:14.719 --> 01:08:20.159
OmniCar in the chat is saying show them unbuy ddope or unbuy classify and or.
01:08:20.800 --> 01:08:23.279
Uh let me see if I remember how this one works.
01:08:23.439 --> 01:08:28.159
So ddup is this is one that like I did not know about until someone showed it to me.
01:08:28.399 --> 01:08:32.800
It's one of the benefits of having like an emergent system of inverses.
01:08:32.960 --> 01:08:36.319
And so ddup, uh, what's it actually I'm gonna do like this.
01:08:36.479 --> 01:08:37.760
Uh here's one of my favorites.
01:08:37.920 --> 01:08:40.479
Lego helmet is a good DDP thing.
01:08:40.640 --> 01:08:45.920
Um so ddup just deduplicates duplicate items in an array.
01:08:46.159 --> 01:08:50.159
Um, if I remember, so by ddup keeps the original array around.
01:08:50.319 --> 01:08:55.039
And if I do un by ddup, I think if I just put numbers here, I think I need more numbers.
01:08:55.359 --> 01:08:56.880
Six, seven, eight, nine.
01:08:57.199 --> 01:09:03.439
Okay, so this is saying if you were to if the let's see, there we go.
01:09:03.600 --> 01:09:16.000
It's saying if one, two, three, four, five, six, seven, eight is the deduplicated version of something, re-duplicate it so that it would be reduplicated in the same way this string that I'm deduplicating is.
01:09:16.159 --> 01:09:18.560
And somebody showed this to me and I'm like, what is going on?
01:09:18.880 --> 01:09:19.680
How does that work?
01:09:19.760 --> 01:09:21.199
And they're like, Why don't you know?
01:09:22.159 --> 01:09:30.720
And because I didn't actually, I implemented this is basically um unbuy and anti-by use the same hook into the same logic that under does.
01:09:30.960 --> 01:09:38.079
And so when I implemented under deduplicate, I essentially implemented this um as well on accident.
01:09:38.319 --> 01:09:45.680
Um and so there's a lot of anything that can be under essentially, or most things um can be unbied or anti-byed depending on their signature.
01:09:45.840 --> 01:09:47.359
Um stuff like that.
01:09:47.680 --> 01:09:48.319
Very neat.
01:09:48.640 --> 01:09:50.800
So I mean I could go over line, but I don't know.
01:09:51.199 --> 01:09:57.760
This is the same thing as a self index in the index into the unique.
01:09:58.079 --> 01:09:59.920
Um, I don't know.
01:10:00.319 --> 01:10:01.119
I guess, yeah.
01:10:01.199 --> 01:10:10.960
I guess if you took your original string and then you did um you find the first position of every element and it's in the unique elements.
01:10:11.840 --> 01:10:14.800
Oh, it's not class, it's um occurrences, oc one.
01:10:15.119 --> 01:10:16.800
All right, there's the unique ones.
01:10:17.039 --> 01:10:21.039
And then it's see the thing is is it's not just a keep on this number.
01:10:21.119 --> 01:10:23.359
It's this is not a mask that used to filter.
01:10:23.680 --> 01:10:26.560
This is reverse this filtering.
01:10:26.720 --> 01:10:39.520
Yeah, like if you if you take if you deduplicate Lego helmet, yeah, and then you look up the Lego helmet in the in that look up every uh every character when it what's what's the position of it across.
01:10:39.840 --> 01:10:41.439
Oh you're right, you're right.
01:10:41.520 --> 01:10:52.319
So if I keep that and then I do like index, I think it's actually this way, like this, and then oh, and and then I take this and I I I use that to select on there, right?
01:10:52.560 --> 01:10:53.039
Or no.
01:10:53.359 --> 01:11:02.159
No, it's like look, I don't know how to compose things like this in in Wea, but I want to look up uh the position of L in the deduplicated Lego helmet.
01:11:02.239 --> 01:11:04.560
I want to find the position of E in the Dego.
01:11:05.039 --> 01:11:07.920
Like okay, so we have zero, one, okay.
01:11:08.000 --> 01:11:11.920
Yeah, L is at one, E is at just increment by one.
01:11:12.000 --> 01:11:14.960
I don't know why it's off by one, but that's oh, because the numbers you gave.
01:11:15.039 --> 01:11:18.880
You you counted from one to eight, but you should have counted from zero to zero to seven, right?
01:11:18.960 --> 01:11:19.840
Then we would have gotten the same.
01:11:20.880 --> 01:11:22.079
If I do this, right?
01:11:22.479 --> 01:11:22.880
Yeah.
01:11:23.359 --> 01:11:23.600
Yeah.
01:11:24.239 --> 01:11:25.039
That's the same thing.
01:11:25.359 --> 01:11:25.680
Yeah.
01:11:25.840 --> 01:11:27.439
Um, so yes, you could do this.
01:11:27.600 --> 01:11:31.439
Um I think this is mildly more in well, I don't know.
01:11:31.600 --> 01:11:33.359
I wouldn't, I don't know if she'd even use this for.
01:11:33.520 --> 01:11:37.119
I it was just a funny thing that happened recently of something that I didn't know aware about.
01:11:37.520 --> 01:11:45.680
There are there are many computations that are cheaper to do on indices into the unique rather than doing it on the data itself.
01:11:45.920 --> 01:11:59.840
For the characters, it might not matter so much, but if you've got some large array, complex arrays, and uh you all you need to do is is deal with their um their relations to each other rather than the data itself.
01:11:59.920 --> 01:12:04.239
So you can use their sort of ID tags instead of using the array.
01:12:04.640 --> 01:12:05.199
That makes sense.
01:12:05.279 --> 01:12:08.479
I mean that's why a case where you might use under deduplicate.
01:12:08.720 --> 01:12:16.319
Um, but if you but that's only if that's if you want to go back to the data at the end, but you might not even want to do that.
01:12:16.399 --> 01:12:22.079
You might end up with some grand uh uh conclusion about the data.
01:12:22.399 --> 01:12:22.800
Yeah.
01:12:23.039 --> 01:12:30.399
Um all right, I can pick through the self-index is not the same because you don't get a uh you don't get a permutation.
01:12:30.560 --> 01:12:34.720
Uh not permutation, you don't self-index can skip elements, right?
01:12:34.800 --> 01:12:41.279
When you've got duplicates before the first occurrence of some element, then you don't get consecutive numbers.
01:12:41.520 --> 01:12:43.680
So it's not the same thing as a self-index.
01:12:44.479 --> 01:12:45.760
I think that makes sense.
01:12:45.920 --> 01:12:48.880
Um I'm trying to think of any, I guess like some of the biggest ones.
01:12:49.039 --> 01:12:51.439
I I don't think this was the case last time.
01:12:51.520 --> 01:13:01.600
Um, in that I've basically entirely moved away from any language about a stack, and all the functions that most of the functions that would have manipulated a stack are gone.
01:13:01.760 --> 01:13:04.479
Um so like there's no duplicate, there's no flip.
01:13:04.720 --> 01:13:10.079
Um those have all been mainly superseded by um modifiers.
01:13:10.239 --> 01:13:34.479
Um primarily because it is an easier way to both well, it's an easier way to conceptualize um tacit um data flow uh is to keep it rather than like say duplicating a bunch of arguments you're gonna need later, then you have to remember the order of the stack as you're going instead of do duplicating a bunch that you need for later, you use on or by or with or off, which are these four modifiers that do very similar things.
01:13:34.720 --> 01:13:43.920
Um and so this sort of addresses a thing I think I mentioned in an earlier episode that that bothered me about the fourth type language.
01:13:44.159 --> 01:13:54.479
If I realize later that I need some value from earlier on, I have to go back in the program and duplicate at that point and then keep track of where in the stack is that value going to be until I need it.
01:13:55.039 --> 01:13:59.359
Yes, this large I mean it doesn't entirely address it, but it like addresses I'd say like 80%.
01:13:59.920 --> 01:14:05.520
Um so these are just four modifiers that are various sorts of combinators.
01:14:05.600 --> 01:14:14.319
I don't think they're combinators that make a ton of sense in, I guess they would make sense in the classical like tree-based combinator sense, but they are multi-output.
01:14:14.560 --> 01:14:17.760
They do make your function multi-output, even if it was just single output.
01:14:18.000 --> 01:14:22.640
And so I mean, I if I if we're interested about just like what they do, right?
01:14:22.800 --> 01:14:24.800
Um, if I just whip them up real quick.
01:14:24.960 --> 01:14:31.680
Um I think we probably know I think you guys probably know most of these, but we've got like these.
01:14:32.159 --> 01:14:37.119
Um there's like self and and backward, which are like duplicate and flip essentially.
01:14:37.439 --> 01:14:40.159
So you've got like yourself, like say couple.
01:14:40.399 --> 01:14:42.399
Um that'll put your things together.
01:14:42.560 --> 01:14:45.680
It's essentially uh is that the W combinator, Connor?
01:14:45.840 --> 01:14:46.479
Or is that C?
01:14:46.800 --> 01:14:48.079
It's the W combinator, yeah.
01:14:48.239 --> 01:14:48.560
Dupe.
01:14:48.960 --> 01:14:52.239
And then C is the uh swap.
01:14:52.560 --> 01:14:53.279
C is the flippy one.
01:14:53.840 --> 01:14:55.600
Or not self, yeah, swab, uh or commute.
01:14:55.920 --> 01:14:56.560
Oh yeah, yeah.
01:14:56.640 --> 01:14:58.960
Um it's called backward and we went.
01:14:59.119 --> 01:15:08.319
Um so with the combination of all these, there's also like below, which is just some other things, and then also these other sort of um argument management modifiers.
01:15:08.479 --> 01:15:12.560
Um, we I think we mostly solve a lot of the tacit problems.
01:15:12.720 --> 01:15:14.479
There's still some stuff I need to address.
01:15:14.640 --> 01:15:22.000
I have some like it's currently in the work, some experimental non-tacit stuff that I'm leaning toward not adding because I just it makes me feel bad.
01:15:22.159 --> 01:15:23.279
Um, but yeah.
01:15:23.680 --> 01:15:27.760
What did uh your users say react to this uh deprecation notice?
01:15:27.920 --> 01:15:34.479
Were they happy or about what about uh you know this uh removal of uh you know these uh stack functions?
01:15:34.880 --> 01:15:40.960
Um I think by this time people were mainly writing in this style anyway, so it wasn't a big deal.
01:15:41.199 --> 01:15:41.359
Yeah.
01:15:41.840 --> 01:15:45.279
So this brings us to a question uh sorry, go ahead, Max.
01:15:45.520 --> 01:16:06.079
Yeah, I'm asking because uh um I stumbled upon Netherlands uh uh page for we we love like the designs and uh I saw like there's like some uh great uh uh retirement uh meme about uh you know these systemica functions and no I know I wasn't I wasn't sure what uh what the design was about.
01:16:06.560 --> 01:16:09.760
Is it the is it the one with a bunch of blue a bunch of blue symbols on it?
01:16:10.000 --> 01:16:15.680
Yeah that is such an old niche joke that it's crazy to have like a shirt for.
01:16:15.920 --> 01:16:20.479
Um that that's like a very old notation when I was really trying a bunch of stuff out.
01:16:20.720 --> 01:16:32.079
Um the language that I uh in the past like I'd say year and a half, which is I think the last time I was here talking about it, um has been in much less flux, I will say.
01:16:32.319 --> 01:16:40.399
Um mainly because I have other stuff I have to work on, but when I do work on it, I'm not changing like big huge things, right?
01:16:40.560 --> 01:16:47.119
I'm not changing like the fundamental way you interact with it because I think we've mostly converged on a model that works.
01:16:47.359 --> 01:16:50.640
Um I'm mostly happy with it as I actually work on things.
01:16:50.720 --> 01:16:56.640
There's a few minor things here and there I might I might improve or change, but for the most part, I like how it works currently.
01:16:56.880 --> 01:17:03.439
Um there also aren't like a ton of like fundamental primitives that I think need to be added, really.
01:17:03.600 --> 01:17:15.039
Um the one that the one that people really want the most, um, that they might be annoyed that I'm so hesitant on is called uh reach, which is um I'm about to give you a positive couple.
01:17:15.279 --> 01:17:28.399
Uh given a function that takes there's a few permutations of it, but given a function that takes two arguments, um, it takes three arguments and it gets rid of the middle one, um, which is annoying to spell otherwise.
01:17:28.640 --> 01:17:35.760
Um, but my philosophy is kind of like you should ex you should spell it explicitly because it makes it easier to read.
01:17:35.920 --> 01:17:37.439
Um I don't know.
01:17:37.600 --> 01:17:40.479
That this is like the most fundamental one that might get added.
01:17:40.560 --> 01:17:44.479
But like any other array primitives, I think I'm mostly happy with at this point.
01:17:44.800 --> 01:17:51.119
Um version wise, like I do still plan to hit a 1.0 at some some stage.
01:17:51.439 --> 01:18:00.479
Um there's definitely gonna be a 0.20 and likely a 0.21, maybe a 22, but I don't think the I don't think we'll get much farther than that before uh a 1.0.
01:18:00.880 --> 01:18:10.239
This is kind of a good or I was gonna say uh and I guess we can have a couple more questions, but I do have to wind down soon because the diapers are need to be changed at some point.
01:18:10.319 --> 01:18:20.000
Um but uh earlier in the chat, and this is kind of topical to what you're talking about now, Kai, with adding primitives, uh Chris C4TUBO in the chat asked, serious question now.
01:18:20.079 --> 01:18:23.920
Uh APL per atom is very slow and cautious when uh adding features, i.e.
01:18:24.079 --> 01:18:25.600
new primitives and other capabilities.
01:18:25.760 --> 01:18:27.840
How does Wewa decide when adding more?
01:18:28.079 --> 01:18:33.279
And it actually says is two with double O, but I clearly copy and pasted not the full question.
01:18:33.359 --> 01:18:35.600
So we'll just end the question in the middle of the question.
01:18:35.680 --> 01:18:37.600
But yeah, how does Wewa decide?
01:18:38.159 --> 01:18:41.359
Or yeah, when when you decide when adding more is too much.
01:18:41.760 --> 01:18:42.399
Adding more is too much.
01:18:42.479 --> 01:18:43.359
Yeah, that makes that adding it.
01:18:43.680 --> 01:18:44.159
That's a good question.
01:18:44.239 --> 01:18:48.399
I mean, so so I feel like one, I guess it's not a question of stability.
01:18:48.479 --> 01:18:49.920
I was thinking it was, but it's not.
01:18:50.079 --> 01:18:55.840
Um, the main things are there's things like um, how used is this operation?
01:18:56.000 --> 01:19:01.119
How fundamental is this operation, like how hard would it be to implement if you didn't have it?
01:19:01.439 --> 01:19:07.279
Um, so for example, something like occurrences, which um I think BQN has.
01:19:07.359 --> 01:19:08.800
I don't know if APL has it.
01:19:08.960 --> 01:19:20.960
This is very annoying to spell, um, as far as I remember, um, if you don't have it, um, which marks each element of an array with which occurrence of the the element in the array that is.
01:19:21.199 --> 01:19:26.640
Um there's other things, I guess, like um, I don't know, what's a good example?
01:19:26.880 --> 01:19:28.479
I guess something like sort.
01:19:28.560 --> 01:19:32.079
Like you can spell sort with um select by rise, right?
01:19:32.239 --> 01:19:37.680
But like you use sorting is such a fundamental operation that I don't know, sometimes you just want it to be nice and short.
01:19:37.920 --> 01:19:41.279
Um there's also the line between like what is it?
01:19:43.600 --> 01:19:44.720
Yeah, yeah.
01:19:44.960 --> 01:19:53.119
Um there's also the question of like some things that I don't think there's a lot of things I don't think need glyphs, but are definitely like nice to have built in.
01:19:53.359 --> 01:19:56.720
So example that I just showed earlier is like cosine, right?
01:19:56.880 --> 01:20:05.279
There's not a oh my gosh, if there was a cosine glyph built in, like sorry, in in Unicode that was like this signed one except the cosine shape, I would use that in a second.
01:20:05.439 --> 01:20:10.479
Um, but like like tangent and stuff, like we don't need this, or like I have built-in JSON support, right?
01:20:10.640 --> 01:20:15.359
Um, where you don't really need like a glyph for JSON.
01:20:15.520 --> 01:20:21.840
It's it's it's so useful to have on hand, but like you don't you don't need a special symbol for it.
01:20:22.000 --> 01:20:24.399
It's not something you need to read as part of like array operations.
01:20:24.560 --> 01:20:30.720
So I have a ton of things like this that are just like words and they are built in, but they're not glyphs, they're not they're not like symbols you need to learn or anything.
01:20:30.880 --> 01:20:32.960
Um would you like them to be symbols?
01:20:33.520 --> 01:20:38.159
That was uh quad names, like uh they they dialogue that literally has quadization.
01:20:38.720 --> 01:20:49.039
Yes, I do have um there is a distinction in that in like if you go to the list, big list of things, you'll you'll see in all the what I call system functions, um, which have ampersand names in front of them.
01:20:49.279 --> 01:20:56.399
These are specifically functions that are they're built in, but they are dependent on the backend that you are working within.
01:20:56.560 --> 01:20:59.920
So there's like a default backend when you download the interpreter.
01:21:00.079 --> 01:21:12.000
There's like safe backends you can give if you are trying to like um embed WeWa in a broader like REST application where you can like block off certain operations if you want to.
01:21:12.159 --> 01:21:16.319
The web, uh like the pad on the web uses a totally different backend.
01:21:16.560 --> 01:21:20.479
So these things are all things that may or may not be implemented for your backend.
01:21:20.640 --> 01:21:33.119
Um whereas just the ones that have names that don't have ampersands in front of them are things that are implemented regardless of back end um that will always work, but which are probably not common enough to need like symbols.
01:21:33.439 --> 01:21:34.000
That makes sense.
01:21:34.319 --> 01:21:46.960
But but but to go back to what Max is saying with APS quad symbol that introduces system names, that sort of exists in We as well, by looking at the capitalization.
01:21:47.199 --> 01:21:53.520
You really should be using capital letters for your and and for your own things and lowercase letters for for the built-ins.
01:21:53.920 --> 01:21:58.800
And then yes, that's like the convention for although that wouldn't be, I don't know.
01:21:58.880 --> 01:22:05.039
I I I my understanding is quads in APL are a like standard library type thing.
01:22:05.119 --> 01:22:06.560
It's built into the interpreter, right?
01:22:06.800 --> 01:22:07.520
Yeah, yeah.
01:22:07.680 --> 01:22:08.399
I mean these are built.
01:22:08.720 --> 01:22:10.560
Hold on, hold on, wait, wait, wait, wait, what did you just say?
01:22:10.640 --> 01:22:12.960
Are they they're standard library as opposed to built in?
01:22:13.119 --> 01:22:13.840
That's what you said?
01:22:14.079 --> 01:22:15.920
Well, I'm asking uh which arch we should try.
01:22:16.720 --> 01:22:17.920
Sorry, yeah, I misunderstood you.
01:22:18.079 --> 01:22:26.560
No, uh those things that begin with quad are always built into the interpreter, but that they're not necessarily the same across uh implementations of APL.
01:22:26.880 --> 01:22:35.279
You don't have the same sort of uh landscape of WiiWare as you had in APL, where there's there are larger differences between APL vendors and so on.
01:22:35.520 --> 01:22:50.479
But the ones that I have shared name now across vendors are usually the same or very similar to each other, but they always for every APL implementation, quad names are always part of the interpreter and never something you can plug in or or the user can't add any.
01:22:51.039 --> 01:23:08.319
So they are they have the same um role in the language as your lowercase built-in names here that don't have glyphs, have and and a potentially a uh a system name in in APL can be upgraded to become a primitive.
01:23:08.560 --> 01:23:09.600
It can get a glyph.
01:23:09.760 --> 01:23:17.199
And there are there are primitives and and system uh names that are the same, they're synonymous.
01:23:17.520 --> 01:23:20.479
So they are just word primitives in that sense.
01:23:20.560 --> 01:23:32.000
But generally speaking, it's for dirty stuff, is for the is the system names and for pure merry manipulation have glyphs, but it's not it's not a clear-cut distinction between them.
01:23:32.319 --> 01:23:33.680
I agree, I agree.
01:23:33.840 --> 01:23:37.840
Um, and that's that's the same thing with like what what do you even make glyphs?
01:23:37.920 --> 01:23:40.000
It's not a clear-cut distinction of what should be.
01:23:40.239 --> 01:23:48.319
Um, in my mind, though, the glyph stuff is like all your fundamental sort of one, either some array operations like all these are, right?
01:23:48.560 --> 01:24:00.399
Your rotates, your sorting, your various indexing and analysis operations on arrays that are your like fundamental composable units that you use to make array algorithms.
01:24:00.640 --> 01:24:08.640
And then also, well, of course, all your math and stuff, and then all the things that you all the things that you use to like thread uh values through the program.
01:24:08.880 --> 01:24:15.439
Those are kind of like the most fundamental sort of operations that I do think it makes sense to have glyphs for, where most of the other things can be named, right?
01:24:15.840 --> 01:24:16.079
Right.
01:24:16.319 --> 01:24:21.439
Yeah, I think we in agree agreement on that sort of thing with how APL does it.
01:24:21.520 --> 01:24:25.840
I think it sort of folds up naturally, but it's not always clear what something is.
01:24:26.319 --> 01:24:35.920
Yeah, whereas a language, but although a language like say, like definitely APL, but also BQN are much more conservative with what they give glyphs as opposed to Wiwa, right?
01:24:36.239 --> 01:24:38.399
I don't think I don't think that's the case actually.
01:24:38.640 --> 01:24:43.760
I think they have the same sort of uh notion of what should be a glyph and what shouldn't.
01:24:43.840 --> 01:24:47.840
It's just that we were has a larger vocabulary of things.
01:24:48.000 --> 01:24:50.319
Um sort of things.
01:24:51.279 --> 01:24:56.000
That's why I say BQ, I think BQN is generally more conservative than like APL is.
01:24:56.159 --> 01:24:58.000
Like BQN doesn't have partition.
01:24:58.159 --> 01:25:02.399
Partition is so useful for any kind of like text processing at all.
01:25:02.560 --> 01:25:14.720
But BQN doesn't have it because you can spell it with group and for for group done, like it's not a difference of uh what sort of thing should have a glyph, only what should how big should the vocabulary of the language be?
01:25:15.119 --> 01:25:25.920
But they could all but then you can't even speak about APL because tiny APL supposedly is a type of APL that has a giant vocabulary compared to I mean a dialogue.
01:25:26.079 --> 01:25:28.479
Okay, but that's dialogue sort of falls in the middle.
01:25:28.880 --> 01:25:34.880
Doesn't Marshall have like an article, like literally where he talks about like principled versus practic practical or pragmatic?
01:25:34.960 --> 01:25:52.960
I always forget, and like he always says BQN is supposed to be principled first and foremost, whereas like Kai has mentioned on past podcasts and now that if something is inconvenient to spell, even if it might not be, if it violates like pure principledness, um, you'll put it in.
01:25:53.119 --> 01:26:02.399
And I I lean way more towards your perspective on this, Kai, because there are things in BQN all the time that like I'm constantly reaching for.
01:26:02.560 --> 01:26:17.039
Probably the most painful uh and probably the most often is that uh BQN has Windows, but doesn't have anything for doing NWISE reduction or the equivalent of Stencil in Tiny Apple.
01:26:17.359 --> 01:26:21.119
Uh and is it called Stencil in in Weewa as well, or is it tuples?
01:26:21.279 --> 01:26:21.840
Yeah, stencil.
01:26:22.239 --> 01:26:22.800
Stencil, yeah.
01:26:22.880 --> 01:26:34.479
And I think Stencil in Weewa was the first time I ever saw a two-character spelling of adjacent difference, which is like my it's it's I probably stuff like that shouldn't make me as well.
01:26:35.359 --> 01:26:36.479
You made a video about that too.
01:26:36.640 --> 01:26:36.960
Yeah, yeah.
01:26:37.039 --> 01:26:38.000
Oh yeah, I did, I did.
01:26:38.239 --> 01:26:43.359
It was the the Batman Dark Knight Rises, because it I like it literally, it was a highlight.
01:26:43.439 --> 01:26:50.479
I don't know if it was the week or the month when that happened, but I was like, this is what I've been talking about for folk for for centuries.
01:26:50.800 --> 01:26:52.800
And uh and then Tiny Apple has it now.
01:26:52.960 --> 01:26:58.159
And dialogue can spell it in three with the N-wise reduction, but BQN, it's like five.
01:26:58.319 --> 01:27:17.279
And like that just it breaks my heart because especially for certain types of applications, these adjacent comparisons, whether it's differences or uh equality may happen, all that that's why like uh Q specifically have differ and deltas like as keywords because they're so uh common.
01:27:17.359 --> 01:27:22.399
And those are specializations of the uh adjacent kind of uh operation.
01:27:22.640 --> 01:27:32.000
Anyways, the point being is that I definitely agree with Kai that BQN draws the line at principled and dialogue probably sits in between, although Adam can speak better.
01:27:32.399 --> 01:27:35.760
But from my view, dialogue sits in between BQN and WeWa.
01:27:35.920 --> 01:27:42.159
And like if I had my own, like I and that's why Tiny Apple a lot of the times is my because they just throw everything, Madeline throws everything in it.
01:27:42.479 --> 01:27:44.239
I love that, you know, if it's in it and I can reach.
01:27:44.479 --> 01:27:48.880
I don't I want there to be an all-equal glyph, which I don't think any array language would ever add.
01:27:49.039 --> 01:28:00.640
But like all equal, when you want it, it's just oh man, I gotta spend three or four characters on this, and it's just like it doesn't belong, but it's it's is a kind of thing that almost feels fundamental.
01:28:00.800 --> 01:28:02.319
Um, but uh yeah.
01:28:02.800 --> 01:28:04.640
I have I have two optimizations for that.
01:28:04.720 --> 01:28:06.319
They're each four glyphs long, right?
01:28:06.479 --> 01:28:08.399
But they're optimizations, but they're not glyphs.
01:28:08.640 --> 01:28:09.439
Yeah, and that's the thing.
01:28:09.520 --> 01:28:11.279
And so do these optimize to the same thing?
01:28:11.439 --> 01:28:11.920
Yeah, they do.
01:28:12.079 --> 01:28:18.319
And that's the kind of like I even I even the the the what is it, not the irony, but like the over the Sega of my array language journey.
01:28:18.399 --> 01:28:30.159
I gave a talk like years ago um called Array, uh, what is it, array notation or algorithms as a tool of thought, which is a play on the uh notation as a tool of thought, where I showed like 14 ways to spell it all equal.
01:28:30.399 --> 01:28:42.239
And uh I I keep coming back to it, and I used it the other day, and I was like, wow, wouldn't I if a tiny apple had an all-equal glyph, it would have the same effect as the two-character stencil um uh that had uh you know, anyways, I'll get off my soapbox.
01:28:42.319 --> 01:28:46.000
Uh I'm kinda you'll love my next talk at the dialogue.
01:28:46.560 --> 01:28:48.319
You had an all-equal dialogue before sort?
01:28:48.479 --> 01:28:49.840
No, Adam, that's a big mistake.
01:28:49.920 --> 01:28:50.720
Use sort first.
01:28:51.600 --> 01:28:53.279
No, no, no, no, no.
01:28:53.760 --> 01:28:54.640
That's not what I'm saying.
01:28:54.720 --> 01:28:56.479
I'm just saying that you're going to like my talk.
01:28:56.800 --> 01:28:57.600
Okay, okay.
01:28:57.760 --> 01:29:11.840
Anyways, um, but in K, even K that has like it has the strictest uh vocabulary, smallest vocabulary of any Amazonian language has an adjacent uh prior operator.
01:29:12.239 --> 01:29:14.399
Yeah, you can do minus prior.
01:29:14.640 --> 01:29:20.399
Anyways, we've got 10 minutes over, mostly due to my di tribe or soliloquy or whatever you want to call it, monologue.
01:29:20.560 --> 01:29:22.159
Um, any last things you want to mention?
01:29:22.479 --> 01:29:27.520
I feel like we should have you back because uh I know Max had a laundry list of questions, which I think we got to some of them.
01:29:27.600 --> 01:29:29.760
We got to the uh geometric algebra.
01:29:29.840 --> 01:29:37.680
Um, or are any any major features that were you just want to like mention for people to go look into uh in between dot 15 and dot 19?
01:29:37.760 --> 01:29:44.159
Or should we just have you back uh for uh for another um I mean I can do a like a two-second scan here real quick.
01:29:44.319 --> 01:29:51.680
I'm sure there's some like big ones that I'm just like are not in forefront in my head, but were like big at the time.
01:29:51.920 --> 01:29:59.920
Um the main things that get added, right, are like subscript currently, uh lately are like subscript behaviors and then like inverses.
01:30:00.159 --> 01:30:02.800
Um and these allow for a lot of different stuff.
01:30:02.960 --> 01:30:09.760
Um, I don't know if we ever went over like data definitions, which is like my answer to structs at enums and stuff.
01:30:09.920 --> 01:30:12.800
Um, I don't know, I forget how long ago that was added.
01:30:13.039 --> 01:30:15.840
Um, or all like the Mac way you do macros and stuff.
01:30:15.920 --> 01:30:17.439
That's a whole thing.
01:30:17.680 --> 01:30:27.279
Um but yeah, I mean if you if you ever want to like learn, just know the features of Weewa, all the staple stuff is documented in the tutorial or in these other tutorials and docs here.
01:30:27.600 --> 01:30:27.920
Perfect.
01:30:28.000 --> 01:30:29.119
We will make sure to link to those.
01:30:29.199 --> 01:30:31.199
And they are they're amazing uh docs.
01:30:31.520 --> 01:30:36.479
Uh I can vouch for them because I spend much time uh learning about the new glyphs of Weewa when they get interesting.
01:30:36.720 --> 01:30:39.039
I guess we will say thank you so much, Kai, for coming on.
01:30:39.119 --> 01:30:42.720
It's been uh overdue and it's always fantastic.
01:30:42.880 --> 01:30:46.880
Um, lots of really, really cool features that uh have been added.
01:30:47.039 --> 01:30:59.279
And so we will make sure to link to all of the uh, you know, definitely the changelog that mentions all this stuff, but also we'll I'll go through when reviewing this to make sure that we we link to the different glyphs and validate and whatnot.
01:30:59.359 --> 01:31:01.439
So if people want to dig in more, they definitely can.
01:31:01.600 --> 01:31:04.800
And uh also thank you to Max for being our guest panelists for the day.
01:31:04.880 --> 01:31:06.960
We'll we'll we'll hopefully do this again in the future.
01:31:07.119 --> 01:31:10.079
And with that, I guess we will say happy array programming.
01:31:10.319 --> 01:31:11.119
Happy Array Programming.
01:31:11.279 --> 01:31:12.239
Happy Array Programming.
01:31:12.560 --> 01:31:15.199
All right, and thanks to everybody on the YouTube uh chat.
01:31:15.359 --> 01:31:17.119
We will see you in the next array cap.