WEBVTT

00:00.000 --> 00:11.520
Hey everybody, my name is David Thompson, I'm the CTO of the Sprite League Institute and today

00:11.520 --> 00:16.960
I'd like to talk about minimalist web application deployment using scheme, a language that

00:16.960 --> 00:22.400
I know many, at least some familiar faces in the room, quite familiar.

00:22.400 --> 00:27.960
Quickly about me, again I'm Dave, I'm the CTO of the Sprite League Institute and Sprite

00:27.960 --> 00:35.240
League is a 501C3 US-based nonprofit and our mission is to build technology that makes

00:35.240 --> 00:38.120
secure, distributed, programming easy.

00:38.120 --> 00:42.840
I'm going to talk a little bit about the deployment of such technology but in this room if

00:42.840 --> 00:47.240
you stick around for the entire time you're going to see many other talks that get into

00:47.240 --> 00:51.880
all of the facets of Sprite League technology so I highly recommend you stick around.

00:51.880 --> 00:55.640
But in this talk we're going to talk about web applications, we're going to cover a number

00:55.640 --> 00:59.960
of topics, we're going to start with the topic of scale and what does that mean scaling up

00:59.960 --> 01:05.400
scaling down. The problems that I see with mainstream web development, oh and I didn't start

01:05.400 --> 01:13.400
my timer, let's fix that. Great. We're going to go into scheme as an alternative language to

01:13.400 --> 01:18.360
what is commonly used in web development. We're going to go through both the server side

01:18.360 --> 01:22.360
and the client side and the recent development Sprite League's done around there and then we'll

01:22.360 --> 01:29.320
conclude with future direction and work-lift to be done. So let's talk about scale. In the

01:29.320 --> 01:33.480
web development industry something that I worked in for about 10 years before coming to Sprite

01:33.480 --> 01:38.600
League and getting on the show hands like web developers in the room or have done it at any

01:38.600 --> 01:44.760
point. Okay, quite a number of people. Industry focus, no surprise, is on scaling up. We read a lot of

01:44.760 --> 01:51.480
articles about going from zero users to millions and public clouds and load balancers and all

01:51.640 --> 01:56.680
these sorts of things. But my focus that's Sprite League and hopefully some of the people here

01:56.680 --> 02:02.440
can relate to is on self-hostible web applications. Things that not only can maybe scale up at

02:02.440 --> 02:06.680
scale down and importantly things that can run on some hardware you just have hanging around

02:06.680 --> 02:13.160
something that maybe only supports you or you and some friends, a small community and we don't

02:13.160 --> 02:18.680
talk about this much. We don't talk about scaling down. So I really like to focus on it here and

02:18.680 --> 02:26.200
show how scheme can be a language to affect such things. So let's cover the modern web development

02:26.200 --> 02:32.520
stack. I have a pretty pessimistic view of it. One thing I hope everyone can agree on is JavaScript

02:32.520 --> 02:37.320
is essentially mandatory. On the front end until recently I'll get into this. You didn't have

02:37.320 --> 02:42.440
much of a choice. JavaScript has involved in the stack at some point. Usually no JS maybe it runs

02:42.440 --> 02:48.360
your back end. Maybe it's just for generating front end code. But more and more not only are we

02:48.360 --> 02:53.160
dependent on JavaScript we're dependent on languages that compile to JavaScript. So we have projects

02:53.160 --> 02:57.960
like Babble.js that are JavaScript compilers and we have languages like TypeScript, you know,

02:57.960 --> 03:03.640
back in the day CoffeeScript, other things. More and more we're building languages on top of JavaScript

03:03.640 --> 03:07.800
to deal with the shortcomings of JavaScript and I think Babble's really appropriately named because

03:07.880 --> 03:13.560
it really is becoming this tower of Babble in complexity and just piles of languages. When it

03:13.560 --> 03:19.320
comes to deployment you usually need a combination of your systems package manager pretty much

03:19.320 --> 03:23.480
always MPM. Any time I look at a web application, get repository there's always a package that

03:23.480 --> 03:28.600
JSON file hanging out. And if you're not using node for the back end you need at least one of

03:28.600 --> 03:33.400
the package manager. If you're using Python probably pay up if you're using Ruby, Bundler if you

03:33.400 --> 03:38.120
got a rust back end, it's cargo, et cetera, et cetera. And then, you know, web assemblies come

03:38.120 --> 03:42.520
around and now you have a whole additional tool chain for that, the most popular of which is

03:42.520 --> 03:49.880
I'm scripted. Let's focus on JavaScript for a moment. Here are my problems with MPM. Typically the

03:49.880 --> 03:56.600
dependency graphs are just massive, even for trivial things. I mean show of hands who's sort of

03:56.600 --> 04:02.520
the left pad and PM package. I mean this is okay. It's kind of an extreme example of how

04:02.600 --> 04:07.240
miniscule these packages get and they get depended upon by a bunch of things and now, you know,

04:07.240 --> 04:11.880
between legitimate security issues like typosquadding these sorts of things, we have

04:11.880 --> 04:17.400
dependency graphs that are just impossible to understand. Sorry about that. And not only

04:17.400 --> 04:20.600
they're hard to understand, they're hard to understand by the people that work on things like Linux

04:20.600 --> 04:26.440
distributions. They're difficult to near impossible to actually pull in out of MPM and go somewhere

04:26.440 --> 04:33.000
else with them, which will be a problem I'll expand on a little bit. And having done DevOps

04:33.000 --> 04:37.160
for a number of years, language package managers, they complicate deployment. Typically,

04:37.160 --> 04:41.400
I was used to needing at least three. They don't compose particularly well. You have to use

04:41.400 --> 04:46.360
additional DevOps tools, things, you know, like, like puppet or answerbuller or shaft or

04:46.360 --> 04:49.800
something like that. So to wrangle it all together and get something that you can actually,

04:49.800 --> 04:54.360
you know, push out and deploy the production. And because of all these different package

04:54.360 --> 04:59.000
managers and package ecosystems, you know, interoperating and not composing particularly well,

05:00.200 --> 05:05.320
you know, if you're under requirements to make sure for compliance reasons that you're

05:05.320 --> 05:08.680
keeping up with security updates. And so if you quickly become dependent on like centralized

05:08.680 --> 05:13.160
infrastructure like GitHub and they're dependent on to understand your CVE exposure.

05:14.520 --> 05:19.800
So how how bad could it be? Who's a geeks user in this room? Let me do a lot of these like hands

05:20.760 --> 05:27.560
and how many of you were at geeks days? So I'm okay. So the topic of using a forge for geeks has

05:27.560 --> 05:33.480
come up and particularly for GAO. And you know, how bad could this mpm thing be? Well, if you

05:33.480 --> 05:39.640
take a look at the package lock.json file for GAO, which is kind of build as a self-hostible

05:40.280 --> 05:45.880
getforge, that file is nearly 16,000 lines long encoding, you know, hundreds to potentially

05:45.960 --> 05:52.280
thousands of dependencies. That's a big lift when you try to think about taking things out of

05:52.280 --> 05:57.960
that ecosystem and actually packaging it for a district like geeks or something else. It's pretty bad

05:57.960 --> 06:05.080
in my opinion. Let's talk about WebAssembly, not just JavaScript. I'm calling this title,

06:05.080 --> 06:11.640
M-Scriptin is for the crabs, for the for the for the Russ of the world. WebAssembly provides a path

06:11.720 --> 06:15.720
away from JavaScript. Like you could imagine producing JavaScript dependence and implementing

06:15.720 --> 06:21.160
more on WebAssembly deploying that. However, the most popular tool change for this is M-Scriptin.

06:21.160 --> 06:27.160
It's based on the LOM. It's a compile tool chain. And that's the primary use case there is for

06:27.160 --> 06:33.880
your static languages, you know, compiling your Russ C++ Cs or perhaps a VM or interpreter for a

06:33.880 --> 06:38.280
dynamic language. But like, you know, the part of it that's implemented in C, you compile that.

06:38.360 --> 06:45.320
It may be run that in the browser. But what about dynamic memory memory memory. Managed memory

06:45.320 --> 06:51.800
languages, excuse me. And particularly what about why as in GC, the garbage collector extension that adds,

06:51.800 --> 06:58.120
you know, heat-allocated types and things to WebAssembly. What about this? The M-Scriptin path doesn't

06:58.120 --> 07:05.560
really give you that. And I'll stop at the bad in a minute, but just one more thing. You know,

07:05.560 --> 07:11.160
you talk a lot about DevOps. DevOps is a full-time job. If you want to pay me six figures,

07:11.160 --> 07:17.480
USD to wrangle all of your package managers and keep your database servers running. Great. That's

07:17.480 --> 07:22.920
awesome. But when we talk about applications that regular users are running or just a few people,

07:22.920 --> 07:27.320
maybe someone that's very tech savvy, but just doesn't have a lot of time, this quickly becomes like

07:27.320 --> 07:32.680
burdensome. And something you don't want to do. I certainly don't want to do it. I've done enough

07:32.680 --> 07:37.880
of that. You have to pay me to want to do these sorts of things. So we have an alternative. It's called

07:37.880 --> 07:42.120
the userOps. It's a term that's been around, I don't know if you've heard of it, but it's been

07:42.120 --> 07:46.680
around a little while. I believe coined by Deb Nicholson currently at the Python software foundation.

07:47.560 --> 07:53.960
And the idea is kind of the, you know, the inverse of DevOps. We're talking about minimal dependencies,

07:53.960 --> 07:58.440
minimal system requirements. Things that you can actually deploy from a system package manager.

07:58.440 --> 08:01.880
Thank you can actually reasonably act install something and start it up. And it's,

08:02.840 --> 08:07.720
I'm not talking flat pack. I'm not talking Docker. Like just a package managers that users

08:08.600 --> 08:13.960
use on a regular basis, at least in the Linux world. And they can also just be maintained by those users

08:13.960 --> 08:19.720
who have limited free time and energy. There's not a lot of different demons to set up and maintain,

08:19.720 --> 08:25.720
you know, redist caches, post-grace SQL services, these sorts of things. And as I try to demonstrate

08:25.720 --> 08:31.640
with the 4GA example, even apps that build themselves as self-hostible, in my opinion,

08:31.640 --> 08:35.480
you're actually quite difficult to self-host. I don't self-host a mastered on instance. For example,

08:35.480 --> 08:43.480
I use someone else's. These sorts of things. Oops. One more slide about this. You know,

08:44.600 --> 08:49.880
is it web scale, right? Again, the industry's focus is on scaling up, not down. You know,

08:49.880 --> 08:54.360
they're focused on deploying to AWS, not the old laptop that has been collecting dust in your

08:54.360 --> 08:59.880
closet, you know, and as like an analogy, it's kind of like big agriculture uses like, you know,

08:59.880 --> 09:03.640
large tractors and combines and things to do their work versus, you know, in your home garden,

09:03.640 --> 09:11.480
you have, you know, a little hand shovel and maybe, you know, maybe a hoe. And so I think the tools

09:11.480 --> 09:16.520
that have tried to make things easier, Docker, flat pack, oh, just install this, take this Docker

09:16.520 --> 09:20.920
container and run it, take this flat pack image and run it. I think they're insufficient because

09:21.000 --> 09:25.960
they're a layer of complexity on top of all of these things. They kind of hide what we've built,

09:27.160 --> 09:33.720
the tower of Babel, and I think ultimately they reduce user agency because these things are typically

09:33.720 --> 09:38.520
artifacts that are produced by the developers of something and they say, run, run this. I gave you the

09:38.520 --> 09:44.680
binary, just run it. And I think it's important for at least those of us that are interested to,

09:44.680 --> 09:49.880
you know, in software freedom and these sorts of things to be able to, you know, inspect and build

09:49.960 --> 09:54.200
and run these things on our own machines with the dependencies that we've got from wherever else.

09:54.200 --> 10:00.600
Anywhere we want. So all this is to say, maybe we need different tools and spoiler alert that

10:00.600 --> 10:09.800
tool is, I'm scheme. I think. So no, no secret that I'm a little schemeer here. So specifically,

10:09.800 --> 10:14.200
I want to talk about, I'm a guy, as a particularly good scheme implementation. So a lot of people

10:14.280 --> 10:19.080
here, like no use gigs or racer hands. I know a lot of people know guy here. But schemes are

10:19.080 --> 10:24.440
fairly minimal, language. You know, few course syntax forms are relatively small. I mean,

10:24.440 --> 10:28.600
stick to Scandard's game. It's not much there. Guyel adds a little bit in a former standard library,

10:28.600 --> 10:35.640
but it's not huge. It's something readily available in Linux distributions. It has a good bootstrapping

10:35.640 --> 10:42.360
story. It's Giles Compiler is written in scheme, but there's a path. So you don't need a previous,

10:42.360 --> 10:45.480
you don't need an already built version of Val to compile it. There's an interpreter written in

10:45.480 --> 10:50.120
C. And so you can go from GCC to the interpreter. There's this whole bootstrapping thing.

10:50.120 --> 10:54.920
I'm looking at Andy in the back. He's written blog posts about the whole process. And it's a

10:54.920 --> 11:00.920
wonderful thing. So it's a nice path to getting into Linux distribution and just being a nice

11:00.920 --> 11:06.200
built system general. It has relatively few dependencies. It's not the absolutely most minimal thing,

11:06.200 --> 11:13.720
but not a lot of dependencies. And in terms of web applications, it has some built-in web client

11:13.720 --> 11:19.480
web server goodies. And there are more goodies available in third-party libraries. And the big thing

11:19.480 --> 11:25.080
is that, you know, scheme on the server has been a thing for a very long time, but scheme in the

11:25.080 --> 11:31.000
web browser is relatively new. And that's something that's now possible. And just so you know that this

11:31.000 --> 11:37.320
talk is actually a guide web application. And I'll just show you really quick. If you get here

11:37.320 --> 11:41.960
my slides, remember, if you remember the intro slide, there's just some scheme code that's rendering

11:41.960 --> 11:49.800
these things. And that's the client side. And on the server, here's what's rendering the web page.

11:49.800 --> 11:54.120
That's running. I'm running an HTML on the server to serve it. So I'm going to talk a little bit

11:54.120 --> 12:00.280
more about maybe a few examples of how you can do these things. You can do a lot with a little

12:00.280 --> 12:08.680
bit of minimal language like scheme. So one example I'm going to give is using SXML. It's S stands for

12:08.680 --> 12:13.880
S Expressions. So what we're used to and with web development, a lot of string-based templating

12:13.880 --> 12:18.840
languages. And you put some funny looking characters to kind of drop out of string mode and run

12:18.840 --> 12:22.840
some code. And whatever that string is gets put right back in and you have this big template.

12:23.720 --> 12:27.880
The problem with that, and I'm going to talk too much about it, is that you become vulnerable to

12:27.880 --> 12:33.240
things like injection attacks. And if you're not careful about escaping your input,

12:34.280 --> 12:38.680
there's a link at the bottom. If you screen-shadowed it or whatever, it's a good article on this subject.

12:38.680 --> 12:44.920
But really what I want to focus on is with list, you can get structural templating. So it's

12:44.920 --> 12:49.320
not, it's an actual data structure. It's not just something that makes a big string blob.

12:49.320 --> 12:52.440
And so this little back-tick here, quasi-quote. That's your new best friend.

12:52.440 --> 12:57.080
The list has a built-in templating language for it. It's called quasi-code. You don't need to

12:57.080 --> 13:01.240
bring string-templating language into this. It's already there. All you need is something that

13:01.240 --> 13:09.480
can take the tree and produce the HTML. Another nice thing is, you know, URI routing, common thing.

13:09.480 --> 13:16.920
Webframe works on the here is an example of Ruby on Rails. How you might do a get request for a

13:16.920 --> 13:20.440
showing like a post. I don't know, look at it. We're going to on a blog or something like that.

13:21.400 --> 13:26.760
Well, with not that much code, you can use Giles Pattern Matcher. And you get a structural

13:26.760 --> 13:33.480
matcher. So on the left, you see like post slash ID. And if that little colon thing means capture

13:33.480 --> 13:39.320
that part of the URI path and assign it to the variable ID and post hash show is some string-encoded

13:39.320 --> 13:43.480
way of, you know, the post class and the show method. Well, instead of having to write string

13:43.480 --> 13:47.640
parses, you can just use what Giles already has. It has pattern matching. You can just take the

13:47.720 --> 13:53.720
URI, split it up, and take the method, and then just match on that, capture the ID component,

13:53.720 --> 13:59.400
and then, you know, this, you know, the right's the equivalent. Gile code. So, you know, you have a

13:59.400 --> 14:06.120
flexible DIY router, like pretty much right there. And years ago, I wrote Geeks Publish,

14:06.120 --> 14:09.880
at least the first implementation of it. And we just, we just use that for the, for the, for

14:09.880 --> 14:16.440
doing the URI, I know, no web framework necessary. Again, you get a lot with a little. And just a

14:16.440 --> 14:21.240
quick example of, um, third-party libraries. Gile web sockets, library and maintain,

14:21.960 --> 14:27.560
stands what Gile provides already for HTTP stuff to also do, uh, web sockets. Don't worry about

14:27.560 --> 14:31.720
the code, but I just wanted to show you this is like a simple, um, like echo server. You can just

14:31.720 --> 14:36.440
write that and connect to it from the browser and it'll echo things back to you. Okay,

14:36.440 --> 14:42.040
let's get to the good stuff. Let's talk about Gile in the web browser. So, who is sort of

14:42.440 --> 14:47.400
who before? Okay, great. A lot of people. So, those who don't know who is a scheme to

14:47.400 --> 14:53.720
have assembly compilers, how we get Gile onto the web. And, um, it's a project developed by

14:53.720 --> 14:58.520
sprightly, um, in conjunction with contracting with Galea and the wonderful wonderful

14:58.520 --> 15:04.680
Andy Wingo, I Andy. Um, it's not only a compiler, but it's a full purpose, uh,

15:04.680 --> 15:09.720
web assembly tool chain. Um, so if you have any interest in playing around with web assembly,

15:09.800 --> 15:15.080
either at the low level, writing actual instructions or perhaps bringing another language to the

15:15.080 --> 15:21.480
web, uh, I'd like to offer up who, as, as an interesting place to start. Um, it's an ahead of time

15:21.480 --> 15:27.080
whole program compiler for scheme and the ideas you take your whole program and, uh, you let, um,

15:27.080 --> 15:31.080
you get someone like Andy to be like, okay, we got to do all these compiler optimizations in it.

15:31.080 --> 15:35.880
And it produces a relatively compact binary, you know, that you can ship over the web and use

15:35.880 --> 15:41.240
minimal bandwidth. So, um, which is why we take the whole compilation strategy and Giles the

15:41.240 --> 15:47.160
soul dependency for this thing. That no NPM, no I'm scripted. So, but it provides us a way to kind of

15:47.160 --> 15:53.320
take an end run around this whole, you know, my opinion problematic and, uh, an NPM ecosystem. Um,

15:53.320 --> 15:57.880
and so, and we do this as sprightly, we, you know, we can actually deploy to the web without having

15:57.880 --> 16:03.000
to rely on, on NPM packages, which we think is really nice because we're big geeks fans and so

16:03.000 --> 16:06.920
we can just use stuff that's available in geeks and have one package manager that, that, that,

16:06.920 --> 16:12.840
that, for the entire, for the entire build and deployment. And, um, I don't know if fan is going

16:12.840 --> 16:16.280
to get embarrassed by this quote, but it's one of my favorite things that's ever written. So, so,

16:16.280 --> 16:21.560
who is approximately Gile? The intent is that this is Gile compiled for the web and, and it is

16:21.560 --> 16:26.040
honest of a way as we can, which means there's things like all the primitives, like,

16:26.040 --> 16:29.640
delimited continuations and things like that. They're, they're, they're implemented in tail calls,

16:29.720 --> 16:33.960
of course. Kind of scheme without tail calls, web assembly has tail calls. It's great. We can kind of

16:33.960 --> 16:38.760
reasonably deploy, you know, scheme programs without many compromises. So, I'm just going to say,

16:39.800 --> 16:44.600
Gile's web booty doesn't pack all the funk in its trunk. Probably it's just junk. And,

16:44.600 --> 16:50.680
in who does it? Um, so let's take a quick look at, uh, some more, um, examples of, of client side

16:50.680 --> 16:55.480
things. Service stuff is interesting, but it's, it's the client somewhere it's at. Um, so first

16:55.560 --> 17:00.520
to talk about fibers, is anyone know the fibers library and, and Gile Gile fibers? Okay,

17:00.520 --> 17:06.840
not so many. Um, it's an asynchronous programming library, an implementation of communicating

17:06.840 --> 17:14.280
sequential processes, um, basically. And, first, I guess I should also ask, who's familiar with,

17:14.280 --> 17:19.080
like, a sync programming in JavaScript using promises, a sync await, okay, much more people.

17:19.080 --> 17:24.920
Okay. So, those of you that are familiar with it are used to having to color the functions

17:25.000 --> 17:29.800
that can use await with a sync. And when you want to suspend it, wait on something, you use await.

17:29.800 --> 17:35.400
And, you know, I wear this function called sleep and it returns a promise. We can await on this.

17:35.400 --> 17:39.960
And, but the point is, once, once you want to use this, any, any function that's intended to use

17:39.960 --> 17:44.520
await has to be marked a sync. It's hard to take an existing code base and just like do a sync,

17:44.520 --> 17:47.960
this new async thing with it. You have to go around and, and make changes to the code base.

17:47.960 --> 17:52.680
Well, um, there's no coloring necessary with, with fibers and scheme. So, the, the,

17:52.760 --> 17:58.600
this much smaller program over there is just using, um, the fibers API from, from hoot,

17:59.480 --> 18:05.240
which is an exact copy of the one you can get for. Guile VM just, just implemented for the web.

18:05.240 --> 18:08.520
And, you don't have, you don't have to color the run function. It's just, you can do a sleep,

18:08.520 --> 18:13.160
and it'll suspend, and resume once through seconds of pass. So, I think this kind of nice is,

18:13.160 --> 18:18.440
it makes for, like, more pleasant async programming. So, not only is it kind of a, a minimal thing,

18:18.440 --> 18:24.120
I think it's like a win in terms of, like, developer ergonomics. Um, you know, um, who's used, react,

18:24.120 --> 18:28.760
or any kind of virtual dominant position view, these sorts of things. Okay, so it's pretty,

18:28.760 --> 18:34.840
pretty common. I have, like, some, you know, criticism of that, of that kind of, like, way of doing

18:34.840 --> 18:38.840
front end, but it's common. So, I just wanted to show it. You can actually do this pretty minimally,

18:39.560 --> 18:43.720
with hoot. We have a blog post here. At the bottom, I know it's a long-year-old. Don't worry about it,

18:43.880 --> 18:50.280
but, um, we, we've, we've shown, you know, you can take, we're showing, uh, earlier I showed SXML,

18:50.280 --> 18:54.280
rendered on the server. We can do the same thing on the client. Take the SXML tree,

18:55.000 --> 19:01.880
use the Dom API, render the tree, in response to a user event, generate a new tree of what the current

19:01.880 --> 19:07.080
state is, dip the two things, and then again, use the Dom API to render those changes, just like

19:07.080 --> 19:11.960
reactous. And so, we can do it from scheme, and we get the benefit of, we don't need, like, JSX or some,

19:12.040 --> 19:16.600
like, additional language to, to write, the templates is all just pure scheme code, and there we go.

19:16.600 --> 19:25.880
Is that the 10-minute? Okay, great. Um, okay, actually, really quick. I'm going to get out of full screen.

19:27.240 --> 19:37.400
Here, here is, let's go in now. I don't know what happened. Where did, where did my browser go?

19:38.280 --> 19:46.120
It's not great when I only have five minutes left. No, it's, it's there.

19:46.120 --> 19:49.160
Oh, this is a bad time to have that happen. I shouldn't have never switched.

19:49.160 --> 19:52.200
I'm suggesting you try to grab moving it to a new workspace.

19:52.200 --> 19:58.200
It's, it's mirrored is the thing. So I just kind of screwed up. Let's, let's do this real quick.

19:58.200 --> 20:04.600
Let's see if I just, if I just choose this. Sorry, everybody. There it is. Okay,

20:04.920 --> 20:14.440
I'm going to be really careful. Anyway, I'm going to skip all of that. Anyway, I won't show this

20:14.440 --> 20:18.360
particular demo. So one thing that's actually a lot more interesting than virtual done to me is,

20:18.360 --> 20:21.720
you know, we can do some interesting experiments in UI kind of moving past virtual done.

20:23.080 --> 20:27.960
Who's heard of functional reactive programming? Some, okay. Functional active programs are really

20:27.960 --> 20:33.320
neat thing. I'm interested in it. Not great with cycles in the graph. Typically, it's one way

20:33.320 --> 20:38.920
data flow. Who's sort of propagators? So MIT thing. Okay, not that many people.

20:38.920 --> 20:43.800
It's an interesting concept. There's, uh, someone by the name of Luxe Radoo wrote a dissertation

20:43.800 --> 20:48.360
in 2009 showing how to implement functional reactive programming with propagators and it

20:48.360 --> 20:55.880
encodes cycles. And so with hoot, with hoot, I've actually implemented the thing that was only

20:55.880 --> 21:02.920
described in the paper. And this is a little hoot program. I can change both sides of the sliders

21:03.480 --> 21:08.280
. There's two sets of sliders, RGB in HSV, change a slider in anyone and it's reflective

21:08.680 --> 21:14.200
in the other sets of sliders. Um, so this is an interesting implementation of functional

21:14.200 --> 21:18.680
reactive programming, but in a way that handles cycles. Um, implemented in scheme, compiled to

21:18.680 --> 21:23.400
web assembly. I think it's pretty neat. Um, I'd like to do more experiments and like what we can do

21:23.400 --> 21:29.560
to, uh, have more pleasant UI. Um, and just want to mention this really quick. I've been talking

21:29.640 --> 21:32.840
a lot about client server stuff, but it's rightly really focused on peer to peer applications,

21:32.840 --> 21:38.360
distributed applications. Um, Goblins is our framework. Um, for doing distributed programming,

21:38.360 --> 21:42.840
peer to peer uses the actor model, uses something called object capabilities. My talks nearly

21:42.840 --> 21:47.400
over, but just like a talent is going to be having a talk later talking all about this. I just wanted

21:47.400 --> 21:53.320
to note it, put a pin in it, just to go tell you later. Um, and we made a game last year, um,

21:53.400 --> 22:00.600
that uses HTML5 canvas, um, to do this. And, uh, I wish I had silenced, uh, matrix notifications

22:00.600 --> 22:07.000
right now. Um, but. So we have this little game circuit button. You can move around and it's a

22:07.000 --> 22:10.600
block-pushing game. It's really fun. Um, I want you to mention it, but look, you can see it's working.

22:10.600 --> 22:15.960
This is a scheme program, student graphics, you know, doing a thing. So, you know, you can, you can

22:15.960 --> 22:22.920
make your programs with this. Great. Really done. So, okay, to wrap up, um, let's talk about

22:22.920 --> 22:29.240
the future. Um, like I said, who's intended to be an implementation of Gile? And so, we're not quite

22:29.240 --> 22:34.040
there yet. There's a number of missing pieces. So we would like to support more or less all of Gile.

22:34.040 --> 22:37.800
You know, you don't have the access to all the things in the politics API on the web, for example.

22:37.800 --> 22:41.640
So there'll be some things that we can't do, but as much as possible, that's what we want to do.

22:42.200 --> 22:45.480
Um, we like to add the Gile standard library. There's just like Gile just doesn't have a

22:45.480 --> 22:50.920
JSON module for, for some reason. Um, the SXML stuff is really great, but there's not a, you can go

22:50.920 --> 22:56.120
SXML to XSML, but there are SXML to XSML, but there's just no way to, to render each

22:56.120 --> 23:00.440
TML. Like, but you could do it. I have code. I just had to carry it from one project to the other.

23:01.000 --> 23:05.160
The fibers API is not built into Gile, but it's built into who they should just be in Gile. These are

23:05.160 --> 23:09.880
nice things. Um, we like to advance web assembly. Um, you know, our implementation of

23:09.880 --> 23:13.880
continuations could be better if web assembly adopted a stack switching proposal, which is

23:13.880 --> 23:19.080
something that's out there right now. Um, we have some problems around bite vector performance,

23:19.160 --> 23:24.040
and, um, which we represent in web assembly as this array I ate type, um, and we'd like to

23:24.040 --> 23:27.800
advance proposals that can make these things better, so our scheme implementation is more

23:27.800 --> 23:33.400
performant and less resource intensive. And also, we would like to advance peer to peer interests

23:33.400 --> 23:38.120
on the web. Um, there's a lot of tricks you have to do right now to, to, to do peer to peer

23:38.120 --> 23:43.640
stuff on the web. You're kind of in the world of centralized domain name systems and, uh, TLS

23:43.640 --> 23:47.240
certificate authorities, and you kind of have to work with them to like bootstrap yourself into

23:47.240 --> 23:52.440
appear to peer to peer worlds. We would like web browsers to accommodate, um, uh, the peer to peer,

23:52.440 --> 23:59.080
um, model a little better. Um, so finally, please run in whether it be Gile, whether it be who

23:59.080 --> 24:03.400
whether it be Goblins, here's links. Um, I'd like to see more people using who any new person that

24:03.400 --> 24:07.720
uses who typically, that who doesn't cover amazing, and they find some bug, or they have a pet,

24:07.720 --> 24:11.880
it's, it's, it's great. So the more people that use who the better gets, so please, if, if deploying

24:11.960 --> 24:16.360
scheme to the web sounds great, give it a try. Um, so I want to thank our supporters,

24:17.080 --> 24:19.160
our funders, and thank you. I know I'm out of time.

24:27.480 --> 24:30.920
Excellent timing, Dave. Oh, questions. Cool.

24:31.720 --> 24:39.000
This one there? Yeah. Yeah. So, uh, just some like big web project like, for example, Django

24:39.000 --> 24:45.960
for, um, like, on the interior of the forest, something like that. Uh, can you repeat the question, Dave?

24:45.960 --> 24:52.120
Yep. The question is, is there, like, a framework, such like, like Django or like Rails, um,

24:52.120 --> 24:57.160
that's available for scheme now, or for Gile, or is going to be available? And there is one that I

24:57.160 --> 25:04.680
have not used, it's called Ganyu Artenis, which is the Sanatra reverse, Sanatra is like a mini

25:04.680 --> 25:10.120
Ruby web framework. I have not used it. I don't love web frameworks. Personally, I much prefer to

25:10.120 --> 25:13.720
just like grab a few little things and, and piece them together, but that's something that

25:13.720 --> 25:18.920
that could be used. I, but I can't speak to it. Um, before the next question, I just want to say,

25:18.920 --> 25:22.920
we, spread this running a donor campaign. If this kind of stuff is really interesting to you,

25:22.920 --> 25:26.920
if you'd like to see it advance, if you'd like to, to help support us, please go to Sprite

25:26.920 --> 25:31.400
Data Institute slash donate, um, you know, we've, we've met our goal, but if we can, we just

25:31.400 --> 25:36.360
stretch goal, we can do even more with hoot. So, um, we would greatly appreciate any contributions

25:36.360 --> 25:40.680
there. Um, yes, down here. Yeah, so you mentioned that you can, uh,

25:40.680 --> 25:45.320
uh, function, color, and color. But then when you have situation like, yeah, and your click

25:45.320 --> 25:50.200
handle is need to be, uh, not, you think that's, is there a way to get back to where this

25:50.680 --> 26:00.280
is. So the question is, without function coloring, is there a way to guarantee that the, like,

26:00.280 --> 26:05.480
say, a click handler is synchronous? Is that the, uh, the answer would be, no, if you were to use

26:05.480 --> 26:10.760
a fibers function, like, sleep, it would suspend. Um, so I guess the answer would be, don't, don't

26:10.760 --> 26:15.720
use them. Oh, yeah, we got to unplug. Thank you, Peter. Sorry. So you can continue on, I'll take

26:16.360 --> 26:24.600
a picture. Uh, in the back, and then I'll get to. Hi, Jenny. You mentioned, um,

26:24.600 --> 26:29.400
don't make it fairly erratic, don't make it fairly. Uh, but you mentioned that about

26:29.400 --> 26:35.480
confusing, uh, and one of the things about bio is to explain to you how to make a

26:35.480 --> 26:42.440
function, it just has heat, so, so generally. So, do you anticipate that the heat is,

26:42.440 --> 26:49.560
the package, or do you think the guy would have something a little more likely? Okay, so the

26:49.560 --> 26:53.960
question is, uh, I was talking about package managers, language package managers, and all their

26:53.960 --> 26:59.000
problems, uh, but there's another problem, which is that guy, itself, doesn't have a package manager,

26:59.000 --> 27:04.440
and is, is the package manager that I recommend geeks, or, or do you think there's something else?

27:04.440 --> 27:11.800
Did I capture that roughly? Okay, um, so, it is kind of the reverse problem, instead of having

27:11.880 --> 27:16.120
a package manager that's totally separate from, from anything in the system package manager,

27:16.120 --> 27:22.680
we have, guy, has none, and that has certain problems, uh, typically people use, like, the auto-tools

27:22.680 --> 27:28.680
build system for packages and stuff, and it's, like, kind of trash to be honest. Um, personally,

27:28.680 --> 27:33.800
for me, geeks is my package manager. Like, that's, uh, I don't, I do everything with Linux.

27:34.600 --> 27:37.800
But I understand that that's not a sufficient answer for people that want to do

27:38.440 --> 27:43.480
development on other platforms. You don't have, like, a across platform, um, solution.

27:43.480 --> 27:49.320
So, I think, maybe a language package manager would be a good idea, but it's also, it's tricky,

27:49.320 --> 27:53.800
because then you could end up in, in the same place. So, I don't, I'd like to talk more about

27:53.800 --> 27:58.760
something like that, because I don't, I don't have good answers. Sorry, what?

27:58.760 --> 28:02.440
There, as a package manager for Gile, and also said, Brother's came out,

28:02.760 --> 28:09.400
there's also Aku, like, went back home. Aku? Aku, AKKU. Okay, AKKU, Aku, yes, I've heard of it,

28:09.400 --> 28:12.840
but I haven't used it, but it's for many scheme implementations. So, that might be a path.

28:14.520 --> 28:20.040
And it works on Gile. Thank you, definitely. Do I, do I have time for any more?

28:20.680 --> 28:23.240
Yeah, you just want to, if you can, oh, right, yeah.

28:25.080 --> 28:29.320
Here's the clip. I'm up for the show, three screens, uh, there it is.

28:29.640 --> 28:33.080
Yeah, I'm used to it, so. Any, I haven't had an act.

28:34.520 --> 28:38.120
I know someone had their hand up, and I, um, Mr. They were, yes.

28:38.120 --> 28:43.880
I don't know how to, how to configure X-rams? No, it's, it's pretty, isn't it?

28:43.880 --> 28:45.880
Does anybody know how to configure X-rams?

28:58.360 --> 29:03.720
Well, well, Geeks in general allows, you know, to have your application can have an entirely different

29:03.720 --> 29:07.720
dependency graph than another application and live happily on the same system events.

29:08.120 --> 29:15.320
Um, with other things. Um, are you, sorry, the question was, uh, uh, the package.json stuff.

29:15.320 --> 29:19.720
You have find, uh, applications are very fine-grained, control of the versions of which dependencies they use to

29:19.720 --> 29:27.000
can Geeks do that. And so, um, I think you might be referring to Geeks, you know, typically has one version of

29:27.000 --> 29:34.120
something. Yeah. Um, I think for the purposes of development, um, it, in some sense,

29:34.200 --> 29:39.320
importers are useful if it's coming from another package ecosystem, but in the general case, um,

29:39.320 --> 29:43.960
I often depend on versions that are unreleased of things, either Spritly Projects or my own or

29:43.960 --> 29:50.200
someone else's, and I keep much like Nick's users have like a little Nick's shell configuration.

29:50.200 --> 29:56.600
I keep a geek shell configuration, per project, and it has customizations of every dependency that's needed.

29:56.600 --> 30:00.680
So it's not exactly automated, but if I need to refer to Git commits in order to get my work done

30:00.760 --> 30:05.320
of unreleased things, I can do that very easily inflexibly. So, um, maybe it's on a perfect answer

30:05.320 --> 30:09.480
for your question, but like, I've gotten by with that. Yeah. And I've been happy.

30:15.080 --> 30:21.080
Oh, for God, it was in my pocket. You kind of, um, yeah, thank you. Thank you for telling me.

30:21.080 --> 30:25.880
One of those things that like, just you kind of forget about like physical space when you repeat.

30:26.840 --> 30:33.560
Yes. Can you compare, uh, okay, I'll tell us please, why, uh, the criminal can never be alive.

30:33.560 --> 30:39.560
There's no more than, uh, can you tell me? Oh, the question is, can I explain why

30:39.560 --> 30:43.880
web development is better in-guile than closure, for example?

30:43.880 --> 30:50.360
Okay. And I don't know if I can, um, to me, closure is not a minimal thing, like using the JVM,

30:50.360 --> 30:55.480
like you've left the land of minimalism to me. It's, it's, it's, it's a lot. The JVM's are

30:55.480 --> 31:01.080
very heavy thing. Um, I got to wrap it up. Okay. I'm done. Um, we can talk more, but I just think that

31:01.080 --> 31:06.680
that's not exactly like minimalism to me. And I think scheme is just a smaller footprint, et cetera. So,

31:06.680 --> 31:11.480
but we can talk more. Yeah. Okay. Okay. Okay.

31:13.480 --> 31:15.480
Thank you. Thank you.

