All right, here I run, it's megan, this is about something that is very raw, very fresh,
very new, very prototype, distributed real-time collaboration for writer.
So I'm just here presenting that actually, quote,
I've just been packed by Michael Stahl into T-Board.
So I'm just talking about it.
Although I had some ideas down about the actual work that's done with some money else.
I'm distributed real-time, what does it mean?
Let's start with a few definitions.
Document collaboration.
So this is not collaborating in a video call.
This is actually a document that you want to work with more than one person on that.
Distributed, which means not like a collaborative online with a one copy,
and then like getting all the input into one copy,
but more than one copy, two, three, ten, twenty,
and different places on different machines and different instances in this world.
So you need to kind of synchronize all those documents.
And real-time means like not just sending the document around by email,
and then everybody does that sequentially, but collaboratively,
like in real-time, like at the same time editing.
So right, there's some history there.
Of this in the, let's say, computer science community,
there was some ad hoc things to do collaboration as this mother of all,
for demos from the Engelbord late sixties,
which was allegedly at least the Wikipedia, the very first instance of some collaboration
on some text document.
Then in the early 2000s, there was the pre-web,
if you will, area on Mac, most of this moon added,
so ether added, which already did some sort of collaboration,
we wrote different machines rightly, it was another one.
And then it started slowly with the Ajax JavaScript world,
and then it really was taking off, so that was the some Google wave,
either paired, CK editor, started in the mid 2000s.
And it was the first time that people actually started to look into that more
conceptually, so there was this time of operational transformation,
which was a formalized way to reason about what kind of algorithm do we need
before that it was mostly ad hoc, so someone just somehow implemented that and made it work.
And it was the second wave that's item three conflict free replicated data types,
which is I think one step further from operational transformation.
The idea there is to do something where you do not have inherent conflicts.
So the problem with operational transformation was that it was formalized,
but it didn't solve the problem that if someone was ten minutes offline
and was editing something, and the rest was then editing in the same paragraph,
there would be a conflict of this person come online again,
and someone would need to resolve that conflict.
And there's a CRDT which is this kind of newfangled thing,
at least supposedly resolves that in a way that it's this always defined way
that the conflict will be resolved, so for simple cases there are no conflicts.
Although sometimes surprising behavior.
So that is actually pretty wide spread now, it's all over the place, it's databases,
the next cloud, if you've been using the next cloud editor,
and the markdown editor is using that zip tab.
But it was through the code, if you do a collaboration there is using that code,
not always using that.
And there's a number of libraries, many of them,
obviously for the web, YAS, auto merge,
and that's 2010, 2011 and later,
and there's plenty of papers and plenty of research there.
So let's say the history and the background.
What we thought we could do is run a little prototype and see whether that is actually feasible and doable.
So we were asking and now that, and I'm happy to say that they approved that project,
and there was a bit of funding there to implement a prototype real-time collaboration.
So we started small, so we said let's use CRDTs,
because that's most of the parties these days,
and do it for writer and do it for writer, read only document,
where people want to collaborate on the comments.
So that's the serious, very small use case, but I think not irrelevant.
You get a contract, you get a, I don't know,
there's some law enacted, that's like 20 pages of document,
you want to review that, so you get like 20 people in the room,
and you want to comment that, so you highlight the things,
or this is a problem, or this is fine, and ask Jack about that.
So go over that, and yeah, so that will be asked and then to fund.
There's a project page there, and the first thing, of course,
is we need to have editable comments while the document is read only.
So that's what T were implemented, the patches there.
And that's the comment from the, from the git commit,
this is a prototype, obviously, and it creates a special note,
that allows editing comments, and adding new comments,
and deleting comments while the rest of the document is actually read only,
which is mostly, there's a bit of plumbing there,
but it's mostly enabling that part of the UI,
whether the rest is still disabled, so there's this lot,
there's a little bit of tweaking there,
to make that still work.
There's an environment variable you need to set to enable that, so yeah, very early days.
The second one is actually, and that's the more,
more involved, but here, hook an existing CIDT library into liberal office,
and so we thought, let's start with rest here,
and the good thing is that there was actually the only option,
so there was either JavaScript, and there's some auto merge C++,
but those were early days.
The only thing I was really like mature enough,
and our opinion was the MyRS library, which is Rust,
and it's one of my secret plans, a number of years,
to get some rest, just to prototype a way
to get Rust integrated into the build system,
and I'm making that usable from liberal office,
and so Michael did that, that's the commit,
Command-WRS working progress,
which was linked on Garrett,
so that adds a shadow added engine model,
which mirrors what is in the added engine,
which is the text engine that powers the commands,
which models what is in the added engine,
text model into the CODT data type,
so that the CODT can then sum that,
and then we copy it out back into the added engine.
Right, what's not working?
This cavalry and transport is mostly not working.
This cavalry means, well, I'm sitting here,
and somebody else sits in Berlin,
and so how can we collaborate?
So we need some way to find each other,
that is superbly done by piggybacking
on existing chat protocols.
You already have a signal or an XMPP,
or a matrix, chat, or teams, or whatever,
so you would say, okay, we need an external,
and then let's collaborate on the document,
so there would be a way then to have an existing
encrypted peer to peer,
or at least an existing way for two people
or any people to talk to each other.
Yeah, there's peer to panda,
which is quite interesting,
that they are building blocks for peer-to-peer apps.
They're also having some project there,
with the norm, possibly getting libraries,
and to the norm stack, so that might be interesting things there,
and interesting projects to piggyback on,
that's not done.
So what we do currently is we just have local sockets,
so that's one machine,
it's obviously a demo, there's no very much practical use of that,
but that needs to be doing.
The other one is some,
the improve the common skewie for that particular use case.
The, I think there's a problem with a slide.
Let's go here.
So the common skewie is not really suitable for this actually,
so it is in Colabron line obviously,
because when you've seen that talk earlier from Planam here,
but for playing desktop liberal office,
it's clearly not been made for this,
actually there's more than one user on the same document.
The other thing is having multi-user curses,
so being able to see where the other person has the attention,
so that's quite useful then if you want to collaborate,
if you can see Jack is over there,
so let's not disturb him and Bob is here with me,
so we can chat about this thing.
Are you really reading what I'm reading, et cetera?
And I've done this overlay with the user names,
pretty much the same experience that you've got from Colabron line.
We push this all into the feature branch,
so this is a kind of consolidated,
all this patches into one, if you're curious,
as I said, it's really quite a prototype,
so let's see demo if I can pull this off.
Important is get this branch, build the branch,
and then you need to set,
edit, comment and read only mode for both instances,
and for one instance you need to set this wire as a set,
which is making the sockets listen here,
so that's this guy, let's see if that comes up.
Yeah, so that comes up, but it's waiting,
it's waiting for the other side of the demo,
which is this one here,
right, and it does seem to work.
So let's start here,
so you watch the right side,
which is the other side,
so first thing is,
I'm typing something, it works.
Okay, so let's try the other side,
let's type something here,
well, that works as well,
oops,
yeah, that works as well.
Okay, let's go one step up, let's,
let's make this bold, let's be bold,
and I'll actually know this is the,
the read only side, which is,
I think there's a bug in the,
there should actually be,
well, let's look here,
so the, the, the text and edit rule,
why it's not not active here,
but it's on this side, so let's let's go here,
and let's make this bold,
and let's make this italic,
and let's make this underlying,
so you see that, that's mirrored to the other side,
let's, let's go over here,
and let's do something like,
delete command, oh yeah, that also works.
Right, so,
so basically, what works is,
text on both sides,
what works is adding and deleting of commands,
what works is basic formatting,
you can't do that much formatting,
it's not like a writer,
three column layout that you can do in the comments,
they can do basic things like change font size,
bold italic, that sort of thing,
alignment of the paragraph, you see this,
kind of, this is some,
flash,
light,
light, so let's, let's make this,
flash,
left,
and it's, it's getting reflected down,
so so the basic, so it's not just text,
but basic formatting and layout,
that works,
and it's getting mirrored by the CIDT,
but with a promise that if,
if one side goes offline,
it would still resolve,
if that comes online again,
and if that's a conflict,
usually that defined way,
to resolve that,
for example,
if somebody deletes a paragraph,
and the other side is typing in the paragraph,
then the deletion would always been,
that's,
that's the way that needs explaining, of course,
you can, but,
but the way then to resolve that,
if this, something unexpected happens,
is that undo,
is always possible,
so you can always go back,
so if the user's,
well, what, there's what's important,
then you just do undo,
and then you have the side,
see's the undo,
and it comes back,
and of course,
if there's the edit wall,
that's not something that technology
can resolve them,
so the people need to kind of talk to each other.
So yeah,
so that's,
that's the first step,
plans,
obviously,
that's the do items,
like getting some,
some discovery,
and some transport going,
and,
I guess that's it,
and I'm out of time.