Wrapping Up

[00:00:00]
>> Steve Kinney: What kind of language are you all going to make?
>> Speaker 2: Something very lisp-like, I think.
>> Steve Kinney: Yeah, you vary this one, yeah. I think the functional ones are interesting because it is a different paradigm, right. I think there is a bunch of books, there's, I think some of the scheme stuff is really interesting.

[00:00:13]
There is a little book called the Little Typer. Which is about like type systems I think it'd be like super interesting to like implemented a type system in a language. Right, I think like on a learning level and like understanding the tools, it's also like really kind of great to like okay, yeah, a type system, I use it.

[00:00:28]
But then how does that type system really work, right? Like there's gotta be like a dependency graph and all of those kind of things like, how is that implemented? And like, traditionally when I've had to implement something myself, even if it's like on a very fundamental level, like the depths of understanding that I've had for that thing is like fundamentally like radically changed, right?

[00:00:48]
Like before doing a lot of this stuff at my job, I had a hand wavy understanding of what an AST was and the fact that Bable traversed them. [LAUGH] Right? But, and especially like when you pull the version of the library that's got all the batteries included, a very complicated project like Babel, it's on 7.0.

[00:01:10]
And I think I mean, how old is Babel now, right? Like, five years old, least, right? There's a lot of like extra like abstractions that that make it really hard to understand when you kind of even start with a very like small language implement, like the ability to diverse a tree and do the transformations yourself.

[00:01:27]
With a very limited set of tools you actually understand like the fundamental concepts. That when you see the bigger version, okay, I can like draw the line from the like kind of smaller fundamental version to the bigger. Like. there's all these helpers but I get the core concept but when you just see the, I mean it's like that anytime you like open, crack open like an open social.

[00:01:45]
I mean today's the day, right. You see that like getting it to build is like most of the work. Right, [LAUGH] And like when you see all this, I'd be like, this is like way too complicated, but the patterns are like relatively, like straightforward. It's just that yeah, it's the same reason like for a lot of cases, if I was like writing this like not for the sake of teaching.

[00:02:06]
Like, would I have used more abstractions to generate the different literals and stuff along those lines? Like absolutely. But would that have hidden away how everything works? Totally, right. And so when you kind of go and try it for yourself and do it from a rudimentary level, then when you see if we had a bunch of functions where it's like if is number token create number literal, right?

[00:02:26]
Like seeing that without having written it out like by hand, you would have been like, neat, some black magic, cool. But it seemed like yeah, it's just like, if it's, if it's got these two properties on it generate this other object you like, now have you saw those two functions now, you'd be like, yeah, I got it like.

[00:02:44]
Just making the object, I've done that. So I think a lot of times like playing with some of these things, especially the things if you're interested in it. Even if like, just trying your hand at it, I think like adds a richness to your understanding that I think is really helpful.

[00:03:00]
[APPLAUSE]