WEBVTT

00:00.000 --> 00:13.680
Welcome to the first talk of the day of the gaming and VR at their room, beyond

00:13.680 --> 00:17.600
git, a collaborative version control for Gadot with Paul Zonetta.

00:17.600 --> 00:20.600
Yeah, thanks for having me.

00:20.600 --> 00:30.360
Hi, my name is Paul Zonettaq, and today I want to talk about version control beyond

00:30.360 --> 00:35.000
git, and I want to share some of the work we've been doing around better collaboration

00:35.000 --> 00:38.360
tools for Gadot Editor.

00:38.360 --> 00:43.320
I'm part of a research lab called Ingrid Switch, and the work I'm presenting here

00:43.320 --> 00:47.800
is a has been a collaboration together with my colleagues, Lilith Duncan, Nikita

00:47.800 --> 00:51.560
Hashtag Kuj and Shafri Lilith.

00:51.560 --> 00:55.320
This project was commissioned by the enters foundation.

00:55.320 --> 01:02.600
They are a non-profit, with a goal to teach students useful skills through game development.

01:02.600 --> 01:07.200
And they specifically picked the Gadot Ancient because they didn't just want to teach

01:07.200 --> 01:12.640
a toy version of game development, they wanted students to learn real tools that actual

01:12.640 --> 01:16.520
professionals are using to build games.

01:16.600 --> 01:22.320
Continuing on the goal of making real games, they started a new project called threat

01:22.320 --> 01:23.320
there.

01:23.320 --> 01:29.640
And the idea behind threat there is to build this RPG style game, and as the students go

01:29.640 --> 01:35.200
through the course, they can form teams and make their own level and contribute that

01:35.200 --> 01:37.520
back to the main game.

01:37.520 --> 01:43.240
So the idea is that you have to like rich world that evolves as students contribute new

01:43.240 --> 01:46.320
levels to this game.

01:46.320 --> 01:50.960
And they came to us with this question of how can we make it easier for students to collaborate

01:50.960 --> 01:53.080
on games.

01:53.080 --> 01:58.440
So to figure this out, let's see what this looks like right now.

01:58.440 --> 02:03.840
So imagine your student you are excited about making your first game, but first of all,

02:03.840 --> 02:06.320
you need to learn Git.

02:06.320 --> 02:12.400
And what this looks like, you need to go first of all to the terminal.

02:12.400 --> 02:16.480
And that's probably the first time that they are doing this, and initially the terminal

02:16.480 --> 02:18.200
can be very intimidating.

02:18.200 --> 02:22.760
You have to speak blank, screen, no obvious buttons, and now you need to learn all these

02:22.760 --> 02:24.520
cryptic commands.

02:24.520 --> 02:30.000
But they have some tutorial, they push through, they start by cloning the repo, and now

02:30.000 --> 02:33.800
they're in Gido, and they can start working on the game.

02:33.800 --> 02:39.040
And what's interesting about how enters teachers' game development is that they are starting

02:39.040 --> 02:41.320
with already working game.

02:41.320 --> 02:47.520
So here you have an example of platform approach act, and the students can start by doing

02:47.520 --> 02:49.760
simple edits, like moving platforms around.

02:49.760 --> 02:55.000
So they don't need to learn a lot of stuff upfront, they immediately can do interesting

02:55.000 --> 02:56.000
things.

02:56.000 --> 03:02.200
So the student might start by doing something simple, like making this level a little bit

03:02.200 --> 03:05.320
more interesting by moving the platforms around.

03:05.320 --> 03:08.480
But now they want to share it with their friends.

03:08.480 --> 03:12.960
So what they need to do is they need to go back to the terminal, they need to enter a bunch

03:12.960 --> 03:18.160
more commands, like commit all their changes, and they're finally done, and now they run

03:18.160 --> 03:22.400
get push, and they get this error.

03:22.400 --> 03:26.920
Somebody else has modified the level, and now they basically screw it, like they can't

03:26.920 --> 03:30.640
really, it's really the kind of stack.

03:30.640 --> 03:35.720
And in practice what endless what they've learned is that teaching students to like fix

03:35.800 --> 03:37.880
merge conflicts is just too complicated.

03:37.880 --> 03:43.680
So in the end, what they teach students is to avoid merge conflicts at all costs, basically

03:43.680 --> 03:49.800
they should talk to each other only once students should touch a single file at a time.

03:49.800 --> 03:54.040
So they still need to go through all this hassle of Git, but in the end they don't really

03:54.040 --> 03:59.160
get many benefits out of it.

03:59.160 --> 04:04.720
And games, in particular, are challenging with Git, because you're not just versioning code,

04:04.760 --> 04:08.840
you have other things like scene files, for example, which are these like highly

04:08.840 --> 04:16.520
visual and structured artifacts, but Git can only version text, so you end up representing

04:16.520 --> 04:18.520
these as text files.

04:18.520 --> 04:21.480
So when you're looking at a diff, you're not seeing what changes in the scene, you're

04:21.480 --> 04:26.200
looking at a text file, and you have to pass back, like how does this relate to changes

04:26.200 --> 04:27.680
in the scene.

04:27.680 --> 04:31.160
And what's even worse, if you get a merge conflict, this means actually you're seeing

04:31.160 --> 04:32.160
files broken now.

04:32.160 --> 04:36.920
So you need to go into a text editor, fix all the merge conflicts, and only once

04:36.920 --> 04:42.880
you've done that you can load it in the GitHub.

04:42.880 --> 04:49.520
So what are, like, outside of games, how are students collaborating today?

04:49.520 --> 04:54.560
One tool that students are probably very familiar with is something like Google Docs, which

04:54.560 --> 04:56.520
is much more approachable.

04:56.520 --> 05:01.760
You have real-time collaboration, it's really easy to share document with other people,

05:01.760 --> 05:07.480
changes are automatically saved, so it would be nice to have some of these features

05:07.480 --> 05:11.040
for game development as well.

05:11.040 --> 05:16.360
So our goal is to build a new collaborative environment that builds on the strength of

05:16.360 --> 05:19.040
both of these tools.

05:19.040 --> 05:23.560
Right now, endless are using Git, because they need a collaboration tool that works

05:23.560 --> 05:25.040
on code.

05:25.040 --> 05:31.080
But this means they're also now locked into this very formal way of working with, like,

05:31.080 --> 05:35.760
explicit commits, with branches, and merging changes.

05:35.760 --> 05:40.960
Sometimes it would be nice to work more in a Google Doc style, especially in the beginning

05:40.960 --> 05:45.640
when students are making simple changes, like moving platforms around or adding points

05:45.640 --> 05:50.040
of what would be really nice if they could just jam together on a level, and like changes

05:50.040 --> 05:52.680
are a think and real-time.

05:52.680 --> 05:57.440
But you wouldn't always want to be in Google Docs mode.

05:57.440 --> 06:02.080
Like one thing that's really nice about Git are branches, like you can just break your

06:02.080 --> 06:08.760
own branch, work in private on some changes or on a new feature, and once you're happy

06:08.760 --> 06:13.880
with your changes, you can review them and merge them back into Git.

06:13.880 --> 06:19.200
But actually in practice, students are not really experiencing this power of Git.

06:19.200 --> 06:25.720
And the reason for that is that beyond code, we also need great support for scene files.

06:25.720 --> 06:31.600
Like merging scenes should be easy, you should be able to see changes in the scene instead

06:31.600 --> 06:32.600
of a text file.

06:32.600 --> 06:41.440
And of course also, we should support other assets, like images in audio and so on.

06:41.440 --> 06:51.840
So here is what we've built in our tool.

06:51.840 --> 06:55.360
So here you can see the Gado editor.

06:55.360 --> 07:00.320
On the left here we have the scene hierarchy, there are some coins, some platforms, and various

07:00.320 --> 07:01.960
other game objects.

07:01.960 --> 07:07.600
I have here this main panel where I can inspect elements and move them around.

07:07.600 --> 07:11.920
And what our plugin adds is this version control tab here.

07:11.920 --> 07:16.840
So you can see right now I'm checked out on the main branch, and I can also see a history

07:16.840 --> 07:19.280
of recent edits.

07:19.280 --> 07:25.280
And as a student, I might start by creating my own branch.

07:25.280 --> 07:31.480
And now you can see the history is empty because I haven't made any changes on this branch.

07:31.480 --> 07:35.000
And it's really nice that I was able to do all these things like viewing what branch

07:35.000 --> 07:38.600
I'm on and checking out in the new branch, just directly in the editor, I didn't have

07:38.600 --> 07:41.600
to go to any external tool.

07:41.600 --> 07:48.360
So maybe next, I want to move around these platforms.

07:48.360 --> 07:54.240
And once I save these changes, you can see that every time I save it, all the magic

07:54.240 --> 07:58.360
it creates a new snapshot of the game.

07:58.360 --> 08:04.200
And if I open up this panel if you below, I can see a list of all the changes that I made

08:04.200 --> 08:06.520
in the game.

08:06.520 --> 08:11.880
And this is using the native UI of Gedou to show me the before and after value.

08:11.880 --> 08:16.600
And if I hover over these change nodes, it also highlights this in the scene where this

08:16.600 --> 08:17.880
changed happened.

08:17.880 --> 08:23.200
So this is really important that I can both see the context where it changed happened,

08:23.200 --> 08:27.040
and also the details of what's specifically changed.

08:27.040 --> 08:32.080
This is especially useful if I'm making non-wishable changes.

08:32.080 --> 08:41.680
For example, if I go into the player here and if I go into the player here and I

08:41.680 --> 08:50.320
crank up the speed and save it, now I can see here that the speed changed from default

08:50.320 --> 08:54.160
value to 730.

08:54.160 --> 08:57.640
And this is otherwise a change that's really easy to miss if you're just looking at the

08:57.680 --> 09:00.960
scene file.

09:00.960 --> 09:06.280
So now that I'm happy with my changes, I can just click here on merge.

09:06.280 --> 09:11.120
And this brings me into a merge preview where I can see how these changes will look once

09:11.120 --> 09:13.440
I'm much and back into main.

09:13.440 --> 09:17.320
So I can click here on merge.

09:17.320 --> 09:19.120
And now I'm back into main.

09:19.120 --> 09:24.520
And you can also see in the history I have here this entry for the merge, and I can see

09:24.560 --> 09:27.840
what changes I've made.

09:27.840 --> 09:34.600
So this is kind of the happy path, but what happens if another student and parallel

09:34.600 --> 09:37.720
why we were marching in these changes, they made some changes as well.

09:37.720 --> 09:39.920
They added some coins to the scene.

09:39.920 --> 09:43.800
What happens now if they want to merge them?

09:43.800 --> 09:46.840
So we click merge here as well.

09:46.840 --> 09:50.720
And now we can see the level looks a little bit messed up.

09:51.040 --> 09:54.160
There are some all-app between the coins and the platforms.

09:54.160 --> 09:58.240
But what's nice is that at least I can load the scene and look at it.

09:58.240 --> 10:04.840
So our principle is that it's better to have level that might not work as intended,

10:04.840 --> 10:08.920
but at least I can see how it works and can make changes to it.

10:08.920 --> 10:12.840
So here in a merge preview I can also make changes.

10:12.840 --> 10:18.400
So I can fix this and align the coins with the platforms.

10:18.400 --> 10:27.080
And once I'm happy with these changes I can save and merge them into main.

10:27.080 --> 10:35.360
And now I have both these changes combined, the move platforms and the added coins.

10:35.360 --> 10:43.120
So this is how you can work together on branches, but we also support life thinking.

10:43.120 --> 10:51.400
So here you can see in the background I have a second version of the added or running.

10:51.400 --> 10:59.800
And whenever I make a change here and save it you can see it automatically sinks to the other side.

10:59.800 --> 11:04.320
And this also works the other way around.

11:04.320 --> 11:10.840
This obviously is not quite like Google Doc style live collaboration.

11:10.880 --> 11:13.400
The limitation here is mostly the Gedou editor.

11:13.400 --> 11:17.480
It wasn't like designed with collaboration in mind.

11:17.480 --> 11:21.320
So like the only point where we can like think is when all the files are saved.

11:21.320 --> 11:26.440
But we already found this to be quite useful if you're pairing, especially if you're together

11:26.440 --> 11:33.000
like on a Zoom call for example, that you can like take turns and easily like make progress together on a game.

11:33.000 --> 11:46.920
So we started this exploration with the question of how can we make it easier for students to collaborate on games.

11:46.920 --> 11:56.600
But beyond that specific use case we have a broader version, we want to make it easier for every person to collaborate on every document.

11:56.600 --> 12:01.320
And we call this version universal version control.

12:01.320 --> 12:09.320
We've already seen with that games are actually they have quite broad requirements for collaboration tools.

12:09.320 --> 12:11.640
And that's not just the challenge for students.

12:11.640 --> 12:17.880
This is also something that people in the game industry is tricky for them.

12:17.880 --> 12:23.400
You have different specialists like artists and developers both with their own set of tools.

12:23.400 --> 12:29.080
But in the end they need to collaborate together on the same project.

12:29.160 --> 12:31.320
And this is not unique to games.

12:31.320 --> 12:38.360
For example, if you think about researchers writing scientific papers, a scientific paper is not just a text document.

12:38.360 --> 12:45.400
It might contain graphs and charts that are generated by some script that's based on some data.

12:45.400 --> 12:50.760
So it would be nice to version all these things together in a single environment.

12:51.000 --> 12:56.520
And even if you're just a single person working in a single medium,

12:56.520 --> 13:01.800
version control tools could be really powerful if they were more flexible.

13:01.800 --> 13:06.200
You could think of a musician working on a new track.

13:06.200 --> 13:08.920
Like initially they want to work very loosely.

13:08.920 --> 13:11.480
They have some ideas, they want to sketch something out.

13:11.480 --> 13:17.640
But like as they are making progress and like holding in on a final version it would be really nice if they could

13:17.720 --> 13:24.200
like easily compare different versions like what has changed between them to figure out what they actually want.

13:25.960 --> 13:32.360
So what we want is universal version control that works for every person, not just programmers.

13:33.000 --> 13:39.320
Every document, not just code and every workflow, not just from a software development.

13:40.280 --> 13:50.280
And we already explored some of these use case in an online browser based collaboration platform that we call patchwork.

13:50.280 --> 13:55.880
And patchwork we have things like every document you can create a branch of by default.

13:55.880 --> 13:58.200
We have application specific diff.

13:58.200 --> 14:02.040
Like here you can see a diff for a spreadsheet or a drawing.

14:02.040 --> 14:08.040
We have history that's automatically generated, but you can also manually annotate it.

14:08.680 --> 14:13.880
And we've explored provenance for generated artifacts in scientific papers.

14:16.200 --> 14:23.080
So to build these new kind of collaboration tools we needed some new infrastructure.

14:23.960 --> 14:30.600
And that's why we've built auto merge, which is an open source library to store and think version documents.

14:31.560 --> 14:35.800
In some sense, auto merge is very similar to Git.

14:35.800 --> 14:42.200
By default it works locally without a server, but you can optionally think your changes.

14:42.200 --> 14:47.080
Either peer to peer or you can think it through a sample server.

14:48.120 --> 14:50.280
But there are some differences to Git.

14:51.480 --> 14:56.040
So first of all, it works on structured and binary data, not just text.

14:56.200 --> 15:01.320
This is really important if you want to version any kind of application.

15:01.320 --> 15:06.200
So like in auto merge you can represent most applications as a document.

15:07.960 --> 15:12.840
And the second thing is that auto merge has much more granular commits.

15:12.840 --> 15:19.720
Because we also want to model things like Google Doc or like real-time collaboration.

15:19.720 --> 15:23.960
So in this case each keystroke is an individual commit.

15:24.600 --> 15:29.720
And then later you can still introduce more formable workflows where you can like group these together

15:29.720 --> 15:35.480
and like annotate them into like meaningful units if you want to, but you don't have to.

15:37.080 --> 15:41.320
And another thing that's different is that changes merge by default.

15:42.200 --> 15:48.680
So for example, if you have a conflict like two people concurrently change the same field to a different value.

15:49.320 --> 15:52.600
Auto merge by default takes one of these versions.

15:54.120 --> 15:59.400
But this doesn't mean you can still do, you can still work with merge conflicts.

15:59.400 --> 16:01.160
We don't throw this information away.

16:02.200 --> 16:05.320
You can ask for like what are conflicts in this document.

16:05.320 --> 16:11.080
And then the application can decide to like surface this to the user to like manually let and take

16:11.080 --> 16:12.680
between like version A and B in.

16:15.640 --> 16:20.760
Yeah, so this has just been like a brief overview of auto merge.

16:21.720 --> 16:26.280
All most of the stuff I've been talking about in this talk is already open source.

16:27.400 --> 16:30.440
If you want you can check out our plugin on GitHub.

16:31.080 --> 16:36.520
It's still under heavy development right now think of it more as alpha software.

16:38.520 --> 16:43.640
Like a few free to experiment it with and try to use it in your game.

16:43.640 --> 16:47.240
But I wouldn't recommend using it for anything critical yet.

16:48.120 --> 16:53.880
And if you want to learn more about auto merge, there is an upcoming talk by my colleagues,

16:55.160 --> 16:57.320
which is going more into technical details.

16:58.200 --> 17:04.360
And finally, I want to also thank Antlers who are funded all this work on the GitHub plugin.

17:05.960 --> 17:12.280
You should also check out their projects if you want to learn more about how they are teaching game development to kids.

17:12.840 --> 17:15.640
That's it for me now.

17:16.840 --> 17:18.840
Let me know if you have any questions.

17:28.920 --> 17:30.920
All right, we have some time for questions.

17:30.920 --> 17:32.440
And you're all right.

17:32.760 --> 17:42.760
Hello, thank you for the talk.

17:43.320 --> 17:52.600
So you said there are maybe sync conflicts because you have to save the scene before change our applied.

17:53.320 --> 18:00.680
Maybe maybe you're doing it already, can you force auto saving like every five seconds to have

18:01.560 --> 18:03.160
more life thing?

18:03.160 --> 18:09.480
Yeah, the problem is that whenever you save it kind of like blocks the whole editor.

18:10.040 --> 18:17.240
So that's like why it's not a great like we want to give the user the control like when kind of like this happens.

18:21.720 --> 18:24.520
All right, yeah, my question.

18:25.480 --> 18:35.560
What do you do with conflicts? It can't be merged automatically like two objects that are by boots moved around?

18:35.560 --> 18:41.880
Yeah, so like the way we represent scene files is that we store it as fracture data.

18:41.880 --> 18:46.200
So basically like each node has an idea and then references each children.

18:46.760 --> 18:54.280
So like we can always like merge things together, but like of course this doesn't necessarily mean that this is like a meaningful

18:54.360 --> 19:01.480
scene like basically we can combine like all the changes of like nodes that were added and like properties that were changed.

19:01.480 --> 19:09.160
But like if like semantically it still might these like changes might be like income in compatible.

19:09.160 --> 19:11.320
So like there's not that much we can do about it.

19:12.520 --> 19:17.720
Yeah, but I mean like if you change the same property of the same notes.

19:17.800 --> 19:29.480
I hear right, so like in that case we automatically pick like one version and like one thing that we do not doing right now is like exposing this conflict.

19:30.040 --> 19:36.680
Like under the hood be like the Texas conflict and like what we want to work on next is to give the user like a way that they can see like

19:37.640 --> 19:41.480
Here is like value A or value B like choose between one of them.

19:42.120 --> 19:51.560
All right, by the way, if the next presentation is in the room, please kind of come over.

19:54.120 --> 19:56.760
Good question about the conflicts as well.

19:57.880 --> 20:04.920
So if you have this conflict that you automatically resolve, have you thought about any characteristics to maybe

20:05.880 --> 20:11.880
detect if you can do something smarter like for example peak value that makes more sense.

20:11.880 --> 20:17.400
Yeah, I like it to succeed something like that yeah, that's a great way that's a great question.

20:17.400 --> 20:25.880
So right now, we're still working on like making this plug and more like stable so we can like use it in class so we can use it more in class rooms.

20:26.920 --> 20:33.560
We haven't like deeply explored yet like what happens if you like actually like use this in more heavy context, but yeah

20:34.040 --> 20:40.280
Like thinking about like what are heuristics to like resolve much conflicts that's definitely like a great question that we want to explore.

20:41.560 --> 20:43.560
All right, we have some time for my questions.

20:49.000 --> 20:50.680
Is good though the only

20:52.920 --> 21:01.240
current showcase there is of auto merge or is there also other ones like from music or like it is correct?

21:02.040 --> 21:07.880
Yeah, so like what we have we don't have anything yet from music, which I think would be cool to do.

21:09.000 --> 21:18.040
Like patchwork is like the other project we've been doing so in patchwork we have like version markdown document.

21:18.040 --> 21:25.480
We have done like versioning a lot of tech documents and also like we you can easily build like

21:26.440 --> 21:32.440
smaller tools like we also have like a drawing editor yeah.

21:34.440 --> 21:36.440
All right, one last question.

21:38.920 --> 21:44.440
Can you talk a little bit about the results in the classroom was it well accepted?

21:44.440 --> 21:55.320
Yeah, so basically get us like super like you've seen how like difficult experiences with kids so like just having something where you can like

21:55.320 --> 22:01.400
automatically merge is already huge. We haven't right now we are still like in development mode.

22:02.120 --> 22:07.240
So like in a couple of months we want to bring this like back into the classrooms.

22:07.240 --> 22:12.840
But so far what we've heard from teachers is that they are like we want to have this tool right now.

22:12.840 --> 22:19.720
Like we don't even care about like having better UX we just like if you have if just like what you have right now

22:19.800 --> 22:25.640
would be working like more stable. We would use this immediately. So that's why we are right now focusing on like

22:26.440 --> 22:29.320
better engineering and like making this work more solidly.

22:32.440 --> 22:35.640
All right and we have unfortunately out of time. Thank you.

