Understory
Feed
Map
Sign in with your Atmosphere Account
Everything Everywhere All at Once - Blaine
11 min
Your browser does not support video playback.
Speaker A
0:00
Most of it didn't exist 2 weeks ago.
0:02
My brain has been melting.
0:04
There's some exciting people that are going to join me on this stuff.
0:08
We've been a little bit coy.
0:10
Paul isn't here.
0:12
Silly boy.
0:14
Anyways, it starts with GML.
0:20
GML is IBM's script markup language in 1969.
0:27
It's the same thing as Markdown.
0:34
We went through this big loop to get back to GML through SGML and HTML.
0:39
I'm not going to get into that.
0:43
For those who know me, Markdown makes my brain say angry things.
0:52
Because it's a local maxima.
0:56
But it's not just a local maxima.
0:57
It's a global minima.
0:59
In terms of— But it's easy to type.
1:11
So as developers, we like it.
1:14
But in terms of the expressiveness that Markdown gives us, It's a real problem.
1:21
So how do we get out of this pit of despair where we're talking about Markdown as possibly a standard.site sort of medium, like the way that we communicate?
1:37
This is— actually, I'll give you a little bit of context.
1:40
A month ago, when some of the standard site conversations were happening, I had some chats with some people and I'm like, we need to not base standard site on Markdown.
1:53
That would be a bad outcome.
1:55
And some things happened.
1:58
And then let me see if I can share.
2:05
Can I?
2:08
Oops, where'd that window go?
2:11
Hey.
Speaker B
2:15
Where—
Speaker A
2:16
there we go.
2:17
OK.
2:18
So this is a tiny little demo that I built a little while ago, about a month ago.
2:24
I'm going to make that bold in Lexical.
2:29
And it updates in TipTap and HTML and Markdown and any one of these formats.
2:38
And it uses a consistent interface to do all of that.
2:43
So I'm going to switch to Markdown.
2:49
And so we get lists across all of these formats automatically.
2:58
Yay, fun.
3:00
So that's just sort of the introduction.
3:03
I didn't add this to the slide, but I'm going to say it anyways.
3:05
A thing that I've said to a lot of people recently is, you know, normally we have this situation where extraordinary claims require extraordinary evidence.
3:13
I've found myself in the last month of extraordinary evidence requires extraordinarily legible claims.
3:21
And so we're starting here as a way of sort of introducing some of these concepts.
3:26
So if I go back here.
3:28
Here.
3:29
Does that show?
3:32
Ah, Google.
3:38
There we go.
3:38
I'm going to introduce Nick to the stage, who's going to give a little demo.
3:46
Can I use your computer?
Speaker C
3:49
Sure.
Speaker B
3:49
Wonderful.
Speaker C
3:50
Hi, my name is Nick.
3:52
I think I'm on the mic.
3:54
Hold it up higher on the mic.
3:59
Is this left or right?
4:03
The middle of the mic.
4:06
The antenna with my hand.
4:09
Hold it like this.
Speaker A
4:12
Hold it physically higher.
4:14
The antenna's right here.
Speaker C
4:17
Oh, thanks.
4:18
How do I— Find the browser.
4:24
How do I find the browser?
4:26
How do I find the browser?
4:27
There we go.
4:29
This is not stand-up comedy.
4:30
I'm so sorry.
4:34
Great.
4:34
Good enough.
Speaker B
4:35
Perfect.
Speaker C
4:40
So one of the things that One of the things that I do is I've got this thing called Lexicon Garden.
4:49
It understands schemas.
4:52
So you can go to a schema and then like look at the documentation, the schema, all of that fun stuff.
4:58
So when Blaine showed this to me, I was like, well, what if we do some really wild stuff, like take a random lexicon record of one type, populate it.
5:10
So we've got some information here and then give a destination.
5:13
Scheme and then provide a little bit of mapping information and then convert it to other types on the fly.
5:22
And this is not— you can see that it's not going through the entire bit of field-by-field mapping.
5:27
This is not a manual operation.
5:29
But it is taking lexicons of other types and then converting them using this process that Blaine and Aaron produced.
5:39
Areas, which I think is really fun.
5:42
So can I talk about the interface thing, like the internal?
Speaker A
5:47
Yeah.
5:47
I mean, Peter was going to talk about lenses.
5:51
Oh.
5:52
So maybe just summarize what you've got here.
Speaker C
5:54
So basically, we have a way to show that with tooling and XRPC interface, lexicon resolution, basic app protocol primitives, plus this lensing stuff that's coming up, we can do real-time transformation of records from one type to another type using this GAT, using this process, this ma— basically just using magical math to do this conversion.
6:22
And it does not require complex mapping.
6:25
It does not require predetermination of known types or records.
6:30
You're just basically saying if something looks like the shape in interface, and then it applies.
6:36
And when you look at how it works, it's a really good explanation.
6:40
That's my little demo.
Speaker B
6:45
Hey all, I'm Peter.
6:52
I'm holding it.
6:54
I'm choked up.
6:57
Should I plug in my screen.
6:59
I can just go to the website actually, because it's just the essay.
7:01
So hi, my name is Peter.
7:02
I'm the director of research at Ink Switch, which is an independent research lab.
7:07
And in 2020, we had a problem.
7:12
We still have this problem, but we had it in 2022, 2020 as well.
7:17
And the problem is this: we have been building real-time collaboration tools for editors of all kinds, text editors, to-do lists, scheduling, planning, all kinds of things, drawings.
7:31
And the issue is that they change.
7:34
And we build this stuff called local-first software, which is the idea that, you know, your software should run on your computer, not somebody else's computer who could stop running it and stop paying to run it.
7:42
And then you have to pay to use your software.
7:44
So what if you had your software on your computer?
7:46
That seems nice.
7:47
But the problem is the reason why we went to the cloud in many ways in the first place is that if there's only one copy of the software, there's only one place to be wrong about.
8:00
And suddenly, if you have a copy on your computer, and your colleague is running a patch on their computer, and one of you has changed the schema of the file you're both looking at, suddenly things start to misbehave in very exciting and dramatic ways that tend to make your laptop's fans spin very loud and cause buffer overflows in your JavaScript stacks.
8:22
And so we knew this problem existed, but we put off working on it.
8:25
And so we— this real-time thing is called AutoMerge.
8:29
And basically we have a similar kind of thing.
8:31
And, you know, we saw demos of text.
8:33
I'll show structured kind of migrations here.
8:36
These are lenses.
8:37
And the idea behind a lens is that you take data in one format, you pass it through the lens, and it comes out in a new shape.
8:43
And so you can see here, for example, we're renaming body on the left into description on the right.
8:49
Right?
8:49
And that's pretty simple.
8:50
You're just changing a field name.
8:51
No big deal.
8:52
Anyone can do that.
8:52
Why are we talking about this?
8:54
Right?
8:55
But of course there are harder and more interesting ones.
8:57
So for example, here we're mapping a Boolean status.
9:01
So we're mapping a particular set of labels on the left to a different set of labels on the right.
9:08
And that's harder and more annoying, right?
9:10
Like the status on the left has open, to-do, and done, but it also has closed and doing.
9:15
And the one on the right has, has different things.
9:17
And so you're creating these bidirectional mappings.
9:19
Now bear in mind, in our ideally what we want— I'll scroll down to the example— is something that looks like this, where my colleague is working on their computer and I'm working on mine, and we're running different versions of the software, but we want, you know, live, real-time migration of the data between the two schemas so that I don't have to commit to running their version of the software and they don't have to commit to running mine.
9:43
We just want to translate the schemas at runtime.
9:47
Now, for bonus points, right, you might have noticed there are these little lenses here which are moving one thing to the other.
9:54
Right, we're changing, you know, complete to status, and then we're doing this mapping from a Boolean to some kind of enum.
10:00
But like, ideally we want to run this in both directions.
10:02
And in fact, each of these lenses is stacking like a telescope to create longer and more complicated lenses.
10:09
So the vision here is that Indeed, you don't need to have an explicit mapping from my schema to your schema.
10:17
We can compose these migrations either between versions within our own applications and then across bridges between applications in order to create any kind of arbitrary lens path so that different versions of software can interoperate.
10:32
And in fact, you know, I'm losing the— no, it's back.
10:38
This is kind of inherently a fragile thing, right?
10:40
Different programs do different things.
10:43
This is an unsolvable problem.
10:44
Like, let's be real here.
10:46
However, many programs do similar things.
10:50
And there's a great deal of common interface.
10:52
And so the example here that we're looking at in this code is imagine an issue tracker.
10:57
And you could imagine corresponding with someone at a different company or lab or project who track issues in their own way.
11:06
Right now, if you use GitHub and I use GitLab, there's