WEBVTT

00:00.000 --> 00:07.000
Thank you.

00:07.000 --> 00:13.800
So our next talk, continuing in the version control systems theme, we've got Carol, he's

00:13.800 --> 00:18.000
going to be talking about gets and rust and get oxide, okay?

00:18.000 --> 00:19.000
Thank you.

00:19.000 --> 00:20.000
Thank you.

00:25.000 --> 00:27.000
Hello everybody, you can hear me at the back, right?

00:27.000 --> 00:29.000
Sounds great.

00:30.000 --> 00:38.000
So today, sitting in the rust room today, I learned two things, falling into the pit of success.

00:38.000 --> 00:42.000
A great way to do this is to speak about how great rust is.

00:42.000 --> 00:47.000
And we definitely going to get there to get a bunch of laughs out of the room.

00:47.000 --> 00:51.000
I learned with Dunkham C++ or C works every time.

00:51.000 --> 00:58.000
I'm going to talk about taming git complexity or just doing weird stuff with git.

00:59.000 --> 01:02.000
So let me just introduce myself real quick.

01:02.000 --> 01:04.000
My name is Carol.

01:04.000 --> 01:06.000
I've been coding since 2004.

01:06.000 --> 01:09.000
I've been hacking on version control since 2020.

01:09.000 --> 01:12.000
So I really like version control to keep doing it.

01:12.000 --> 01:15.000
And I'm a co-founder of a company called Git Butler.

01:15.000 --> 01:16.000
That's enough.

01:16.000 --> 01:21.000
So let's talk about why you want to hack on git stuff.

01:21.000 --> 01:26.000
What do I mean by hack is programmatically operate git, right?

01:26.000 --> 01:33.000
So what that means is maybe you want to do some useful things like package managers.

01:33.000 --> 01:38.000
I don't know anybody working on package managers, package management in the audience.

01:38.000 --> 01:41.000
Person there actually quite a few.

01:41.000 --> 01:44.000
Developer tools, anybody?

01:44.000 --> 01:48.000
Oh wow, that's actually a lot of developer tools for folks.

01:48.000 --> 01:54.000
Is anybody automating or customizing your workflow in git?

01:54.000 --> 01:57.000
Actually that's half of the audience.

01:57.000 --> 01:59.000
So this is going to be relevant, I think.

01:59.000 --> 02:08.000
I think it's also real fun programming git or just working with the data structures that our version control gives us.

02:08.000 --> 02:12.000
And just doing stuff without it's it's kind of fun.

02:12.000 --> 02:16.000
So our agenda today we have three themes.

02:16.000 --> 02:23.000
So I'm going to introduce you the git data model data structure and kind of tell you about how awesome it is.

02:24.000 --> 02:26.000
And why it's awesome?

02:26.000 --> 02:31.000
I'm going to show you how to build stuff with a library code, git oxide.

02:31.000 --> 02:33.000
And git oxide is really cool.

02:33.000 --> 02:37.000
So hopefully by the end of this talk you'll be pulling it from GitHub.

02:37.000 --> 02:45.000
And then I will do a very quick demo for actually having implemented the stuff with git oxide.

02:45.000 --> 02:49.000
If you have any questions, heck on me.

02:49.000 --> 02:53.000
You know, just shout that's fine. I love it.

02:53.000 --> 02:59.000
So how many of you are using git?

02:59.000 --> 03:03.000
Literally everybody, right?

03:03.000 --> 03:07.000
How many of you know the data model of git?

03:07.000 --> 03:09.000
Like how should is stored on disk?

03:09.000 --> 03:11.000
Like about half of the room.

03:11.000 --> 03:18.000
So I think git has been partly, partly the reason for why git has been so successful is

03:18.000 --> 03:21.000
like the simple, very hackable primitives.

03:21.000 --> 03:24.000
And what I mean by hackable is like easy to work with.

03:24.000 --> 03:28.000
So in git everything is content addressable.

03:28.000 --> 03:32.000
Like you have the content is the identifier for the data.

03:32.000 --> 03:33.000
That's cool.

03:33.000 --> 03:37.000
You have snapshots instead of disks.

03:37.000 --> 03:41.000
So that means that you're looking at disks but the system underneath is writing snapshots.

03:41.000 --> 03:45.000
That's the limitation but that's also what makes it simple.

03:46.000 --> 03:52.000
And git works on the immutability principles, right?

03:52.000 --> 03:55.000
So it doesn't change afterwards.

03:55.000 --> 03:58.000
It makes things simpler to work with.

03:58.000 --> 04:04.000
So I'm going to share four concepts with you about the git data model by the end of this.

04:04.000 --> 04:10.000
It's not going to take long but the end of this you know more about the 90% of developers out there.

04:11.000 --> 04:15.000
So in git you have blobs.

04:15.000 --> 04:21.000
So content is everything and this is essentially this content addressable nature I mentioned earlier.

04:21.000 --> 04:26.000
So in git a blob is the file content and a hash fruit.

04:26.000 --> 04:28.000
That's it, right?

04:28.000 --> 04:33.000
Like in the example up there you know your file content you get a hash out of it.

04:33.000 --> 04:36.000
This is abbreviated and that's your blob.

04:37.000 --> 04:39.000
There is no file name.

04:39.000 --> 04:41.000
There is no metadata.

04:41.000 --> 04:45.000
It's just just a bunch of content.

04:45.000 --> 04:47.000
And that means it's reusable.

04:47.000 --> 04:53.000
So if you have two files with the exact same content you don't have another object for it.

04:53.000 --> 04:57.000
It's the same thing in the object store.

04:57.000 --> 04:59.000
So that's number one.

04:59.000 --> 05:00.000
Blobs.

05:00.000 --> 05:05.000
So we're going to build up from blobs into all the way to a version control system.

05:05.000 --> 05:09.000
And then you have the concept of trees.

05:09.000 --> 05:15.000
In git we talk our tree this tree that sounds like a complicated structure is just the file system.

05:15.000 --> 05:22.000
It's just like a you know a directory organizing the blob into a snapshot of a directory.

05:22.000 --> 05:26.000
So as you see the example over there I have two trees.

05:26.000 --> 05:34.000
And you see that those trees now you have the file name and a bunch of you know like a little bit extra metadata.

05:35.000 --> 05:41.000
But these trees are pointing to the blobs that we spoke about or other trees.

05:41.000 --> 05:44.000
And that's kind of how how the system builds up.

05:44.000 --> 05:47.000
Then you have.

05:47.000 --> 05:48.000
Yeah, exactly.

05:48.000 --> 05:56.000
So you're pointing to blobs or other trees and trees in in this structure are your main plus mode plus a hash.

05:56.000 --> 06:00.000
There's nothing else that's all.

06:00.000 --> 06:03.000
Building on top of that you have commits.

06:03.000 --> 06:06.000
Now commits is the term that you work with every day.

06:06.000 --> 06:10.000
And it's a snapshot in time of your work.

06:10.000 --> 06:18.000
And a commit is essentially a pointer to a tree plus a little bit of metadata, right?

06:18.000 --> 06:24.000
Like you have the author this little commit message bit stuff, right?

06:24.000 --> 06:27.000
I'm sure nobody writes commit messages like that.

06:28.000 --> 06:34.000
And as you know commits form a graph, right?

06:34.000 --> 06:42.000
You have a commit one of those metadata pieces that you work with is the parent or one on multiple, right?

06:42.000 --> 06:49.000
Like you have a parent that precedes it and that's kind of forms your history.

06:49.000 --> 06:54.000
You can traverse it and that's what happens when you log your history.

06:54.000 --> 07:02.000
And if you happen to have more than one parent, that's called a merge commit and those are wonderful.

07:02.000 --> 07:03.000
All right.

07:03.000 --> 07:10.000
So finally the last concept that I'm sure you already understand but references.

07:10.000 --> 07:11.000
And this is just branches.

07:11.000 --> 07:14.000
Like let's focus on branches for now.

07:14.000 --> 07:18.000
It's simply names for commits.

07:18.000 --> 07:19.000
That's all.

07:20.000 --> 07:25.000
And updating a branch is just moving the pointer.

07:25.000 --> 07:30.000
So if you create a new commit, the pointer moves, that's all.

07:30.000 --> 07:40.000
It also happens to be the case that there is this special branch called head, which is what I have checked out right now.

07:40.000 --> 07:45.000
This is more or less the interesting parts.

07:45.000 --> 07:50.000
With this set up, you have now enough knowledge to be dangerous.

07:50.000 --> 07:57.000
You can go ahead and start editing the, no, you should not edit the get directory directly.

07:57.000 --> 08:00.000
Things will get messy very quickly.

08:00.000 --> 08:05.000
But this sets you up for using the get plumbing.

08:05.000 --> 08:12.000
And what that usually means in the context of get is like the plumbing commands, right?

08:12.000 --> 08:14.000
Get hash object, right?

08:14.000 --> 08:22.000
Like you take, take a blob, you get the hash out of it or cat file to get information about the object database.

08:22.000 --> 08:25.000
You don't want to do that, right?

08:25.000 --> 08:30.000
Like one of the reasons, like there's many reasons why you don't want to talk exactly these commands.

08:30.000 --> 08:33.000
But the number one reason is it's kind of rigid.

08:33.000 --> 08:37.000
You can't get all the things that you want to do with those commands.

08:37.000 --> 08:41.000
They are built for the get kind of workflow.

08:41.000 --> 08:44.000
The way the way it's been always known.

08:44.000 --> 08:46.000
So you want something more flexible.

08:46.000 --> 08:48.000
So what would you imagine?

08:48.000 --> 08:50.000
You may want to say, how?

08:50.000 --> 08:52.000
Well, get this open source.

08:52.000 --> 08:55.000
I'm going to use it as a library.

08:55.000 --> 08:59.000
So going to the code base, there is this libget.a.

08:59.000 --> 09:04.000
And you think you may want to link this into your application and use that.

09:04.000 --> 09:06.000
Sounds like a great idea.

09:06.000 --> 09:07.000
But you can't.

09:07.000 --> 09:09.000
This does not work.

09:09.000 --> 09:14.000
And the reason is this code base is not set up for that.

09:14.000 --> 09:15.000
It's not appropriate.

09:15.000 --> 09:17.000
It does funny little things.

09:17.000 --> 09:21.000
Like inside functions, it thinks it owns the process.

09:21.000 --> 09:25.000
So it does this wonderful, wonderful, die function.

09:25.000 --> 09:26.000
Exit your process.

09:26.000 --> 09:29.000
You don't want that randomly sprinkled.

09:29.000 --> 09:32.000
So you can't use libget.a.

09:32.000 --> 09:36.000
So this was the part where I was dunking on a secode base.

09:36.000 --> 09:42.000
Now, this also means you need the library.

09:42.000 --> 09:45.000
Or like you obviously need the library if you want to access

09:45.000 --> 09:51.000
programmatically the get stuff.

09:51.000 --> 09:53.000
And I'm going to give you a very unfair list.

09:53.000 --> 09:54.000
Why is it unfair?

09:54.000 --> 09:56.000
I'm not going to cover everything.

09:56.000 --> 10:01.000
There is legit too, which if you have, if you are a rust user,

10:01.000 --> 10:04.000
you may have seen the crust get too.

10:04.000 --> 10:07.000
Anybody use the create get to in the audience.

10:07.000 --> 10:08.000
A few people.

10:08.000 --> 10:12.000
So this is rough bindings for libget to.

10:12.000 --> 10:14.000
And libget to is great.

10:14.000 --> 10:16.000
It's been around for a while.

10:16.000 --> 10:18.000
It's mature, et cetera.

10:18.000 --> 10:20.000
So it does a lot.

10:20.000 --> 10:22.000
There is other libraries.

10:22.000 --> 10:23.000
That's why it's unfair.

10:23.000 --> 10:25.000
I kind of bucket it into other.

10:25.000 --> 10:28.000
You have jagged, go get et cetera.

10:28.000 --> 10:31.000
And then you have get oxide.

10:31.000 --> 10:35.000
The rest of the talk is about get oxide.

10:35.000 --> 10:45.000
So get oxide is rough, pure rust implementation of these structures.

10:45.000 --> 10:53.000
This is just a very quick map of what's the ecosystem like.

10:53.000 --> 10:56.000
Every pixel in that image is a line of code.

10:56.000 --> 10:59.000
And that's a lot of pixels crammed in there.

10:59.000 --> 11:03.000
So in the background, this is the C get code base.

11:03.000 --> 11:09.000
That's the one with the die and shared state, et cetera.

11:09.000 --> 11:10.000
That's the background.

11:10.000 --> 11:12.000
And then you have the jagged.

11:12.000 --> 11:14.000
It's a large library.

11:14.000 --> 11:16.000
It's been around for a long time.

11:16.000 --> 11:19.000
There's go get libget to.

11:19.000 --> 11:22.000
And then in the top right corner, that's get oxide.

11:22.000 --> 11:27.000
That's at least as a 24, the size of the project.

11:28.000 --> 11:31.000
Right. So let me introduce to you get oxide.

11:31.000 --> 11:34.000
Anybody here who has used get oxide?

11:34.000 --> 11:36.000
All right, quite a few people.

11:36.000 --> 11:41.000
So it's a library by Byron Sebastian.

11:41.000 --> 11:46.000
It's actually a really cool project.

11:46.000 --> 11:48.000
So what's really cool about it?

11:48.000 --> 11:51.000
Our tradition is it's get compatible.

11:51.000 --> 11:53.000
So it does what get would do.

11:53.000 --> 11:55.000
Right, it doesn't do anything weird.

11:55.000 --> 11:58.000
Objects that it writes are going to be compatible.

11:58.000 --> 12:00.000
It reads it the same way and so on.

12:00.000 --> 12:03.000
It is safe.

12:03.000 --> 12:05.000
It is performance.

12:05.000 --> 12:07.000
It's performed because, you know, like a memory saved,

12:07.000 --> 12:09.000
you can paralyze and so on.

12:09.000 --> 12:13.000
But the part that's interesting is it's also comes with scalpel

12:13.000 --> 12:15.000
is included.

12:15.000 --> 12:18.000
And that just simply means it's very flexible.

12:18.000 --> 12:20.000
You can do a lot of weird things,

12:20.000 --> 12:24.000
or you can manipulate stuff in a flexible way.

12:24.000 --> 12:30.000
So that means the library gives you a lot of knobs and buttons,

12:30.000 --> 12:33.000
things to tweak things to adjust.

12:33.000 --> 12:36.000
This is like a maybe too much of an example,

12:36.000 --> 12:39.000
but this is, you know,

12:39.000 --> 12:42.000
imagine that we're going to clone using get oxide.

12:42.000 --> 12:45.000
So you can configure your remote.

12:45.000 --> 12:47.000
You can do a shallow cloning.

12:47.000 --> 12:50.000
You can pick a specific branch.

12:50.000 --> 12:52.000
You can override configs.

12:52.000 --> 12:56.000
You can customize you fetch,

12:56.000 --> 12:58.000
like skip the tags.

12:58.000 --> 13:03.000
In this example, you can track the progress.

13:03.000 --> 13:05.000
If you want, you know,

13:05.000 --> 13:09.000
you kind of display to the user in any way,

13:09.000 --> 13:10.000
etc.

13:10.000 --> 13:12.000
Or handle the interrupts.

13:12.000 --> 13:15.000
But the thing that's actually is really cool is also it allows you

13:15.000 --> 13:18.000
to do kind of more sophisticated operations.

13:18.000 --> 13:23.000
You can be doing your updates automatically.

13:23.000 --> 13:24.000
You can do stuff in memory.

13:24.000 --> 13:28.000
Or in this case, you can prevent race conditions by saying,

13:28.000 --> 13:33.000
OK, I want to mute my references in a particular way.

13:33.000 --> 13:37.000
And I'm going to open a transaction, prepare it,

13:37.000 --> 13:40.000
and try to obtain a lock.

13:40.000 --> 13:42.000
And if it can't, it will fail.

13:42.000 --> 13:45.000
And then do everything in the very end automatically,

13:45.000 --> 13:46.000
which is kind of neat.

13:46.000 --> 13:50.000
If you want to do stuff with the own,

13:50.000 --> 13:54.000
or if you're doing something specific that you want to make edits like that.

13:54.000 --> 14:00.000
So I'm going to run you through a quick real, real-world example.

14:00.000 --> 14:05.000
So pretend, let's pretend that we want to be a good get-ism,

14:05.000 --> 14:09.000
right? Like what that might mean is you want to make you commit

14:09.000 --> 14:12.000
super, in a super focused way.

14:12.000 --> 14:16.000
You have, you want to do one thing and not another,

14:16.000 --> 14:19.000
you know, just like a small focus commits.

14:19.000 --> 14:23.000
And sometimes you may want to move stuff between commits, right?

14:23.000 --> 14:28.000
Like, in this case, let's pretend that this file that went into one commit

14:28.000 --> 14:31.000
is supposed to go somewhere else, right?

14:31.000 --> 14:37.000
Or somebody in code review told you, hey, split your commit.

14:38.000 --> 14:40.000
So how would you do that?

14:40.000 --> 14:44.000
Does anybody change their commits after they've written them?

14:44.000 --> 14:46.000
Okay, that's the whole room.

14:46.000 --> 14:52.000
So let's pretend that we do this get gymnastics together, right?

14:52.000 --> 14:54.000
You have to do an interactive rebase,

14:54.000 --> 14:57.000
and that's the happy case scenario.

14:57.000 --> 15:00.000
So what do you do? You do an interactive rebase.

15:00.000 --> 15:03.000
You mark your source and destination as edit.

15:03.000 --> 15:07.000
You then reset to a particular point,

15:07.000 --> 15:13.000
and then you stop a commit and reset there.

15:13.000 --> 15:16.000
So let's say you're extracting this utils file,

15:16.000 --> 15:20.000
and then it's out, and then you continue your rebase,

15:20.000 --> 15:23.000
and then you stop at the destination commit.

15:23.000 --> 15:26.000
You add, you know, it's a dance.

15:26.000 --> 15:29.000
And if you have the commit's deal,

15:29.000 --> 15:32.000
we're around, you have to do the, what I like calling,

15:32.000 --> 15:34.000
the double interactive rebase sandwich.

15:34.000 --> 15:36.000
You don't want to do that.

15:36.000 --> 15:38.000
Or it's not very pleasant.

15:38.000 --> 15:41.000
So let's implement that using GitHub site.

15:41.000 --> 15:45.000
This is doing weird stuff with Git after all.

15:45.000 --> 15:48.000
So let's see.

15:48.000 --> 15:50.000
So you've now imported the library,

15:50.000 --> 15:52.000
and you have gigs open.

15:52.000 --> 15:55.000
So you open the repository in memory.

15:55.000 --> 15:57.000
So that's what we're doing here.

15:57.000 --> 16:00.000
It's open with object memory, okay.

16:00.000 --> 16:02.000
So here's something that we've set up.

16:02.000 --> 16:06.000
It's not actually gigs, but we set up something with Git gigs

16:06.000 --> 16:07.000
primitives.

16:07.000 --> 16:10.000
And then you look up the commits,

16:10.000 --> 16:13.000
like you have the hash as you can look them up.

16:13.000 --> 16:15.000
What GitHub site does, does it,

16:15.000 --> 16:17.000
it loads these lazily, right?

16:17.000 --> 16:20.000
So you're not parsing the commit message and everything,

16:20.000 --> 16:23.000
until you actually access it, which is pretty neat.

16:23.000 --> 16:27.000
And in this case, we don't need it until, or we only need the tree.

16:27.000 --> 16:33.000
So, next, we need to subtract changes from the first commit.

16:33.000 --> 16:37.000
Let's say, so in this case, you need to get the,

16:37.000 --> 16:40.000
the div spec of what you're subtracting, okay?

16:40.000 --> 16:43.000
Well, let's say, we have some function doing that.

16:43.000 --> 16:45.000
And then you have to do like a removal.

16:45.000 --> 16:47.000
You want to extract things out of a tree.

16:47.000 --> 16:50.000
And you build this with, you know,

16:50.000 --> 16:54.000
GitHub site primitives that later you can, you can say,

16:54.000 --> 16:58.000
okay, I'm now going to swap out the tree that had my change

16:58.000 --> 17:00.000
with the tree that does not.

17:00.000 --> 17:05.000
Next, you want to inject that change into the other commit, right?

17:05.000 --> 17:07.000
Like to do it automatically.

17:07.000 --> 17:10.000
And here, we're doing a three way merge,

17:10.000 --> 17:13.000
sounds interesting.

17:13.000 --> 17:15.000
You do need a three way merge of, you know,

17:15.000 --> 17:19.000
where the base is the, the source without the changes,

17:19.000 --> 17:24.000
then the one side is the, you know, the part with the tree changes.

17:24.000 --> 17:29.000
The other one is the destination where you want to actually put the,

17:29.000 --> 17:31.000
put the changes.

17:31.000 --> 17:34.000
And then you do the same swap operation.

17:34.000 --> 17:40.000
And then do everything in memory and at the very end you write to disk, right?

17:40.000 --> 17:43.000
So, time for a demo.

17:43.000 --> 17:47.000
So, I showed you in theory how, how that could look like.

17:47.000 --> 17:50.000
So, I'm going to demonstrate that it actually works.

17:50.000 --> 17:51.000
You can do that.

17:51.000 --> 17:53.000
So, it's a very quick one.

17:53.000 --> 17:56.000
Just one very small example.

17:56.000 --> 17:59.000
So, over here, is this big enough by the way?

17:59.000 --> 18:01.000
No.

18:01.000 --> 18:02.000
Okay.

18:02.000 --> 18:03.000
Okay.

18:03.000 --> 18:05.000
People are the front of saying the size is perfect.

18:05.000 --> 18:07.000
So, I'm going to go with that.

18:07.000 --> 18:09.000
Okay.

18:09.000 --> 18:11.000
So, this is just a commit history.

18:11.000 --> 18:14.000
And let's, for a second pretend that this commit,

18:14.000 --> 18:16.000
we don't, we don't care about the message.

18:16.000 --> 18:19.000
We only care about the fact that this read me.

18:19.000 --> 18:20.000
It does not belong there.

18:20.000 --> 18:24.000
It belongs in this commit five, three something.

18:24.000 --> 18:30.000
So, what you, um, a pair of them, two times.

18:30.000 --> 18:31.000
Okay.

18:31.000 --> 18:33.000
So, what do you, I will make this bigger.

18:33.000 --> 18:37.000
So, what I can say is I'm moving this read me from,

18:37.000 --> 18:41.000
from that F7 commit into commit 53.

18:42.000 --> 18:43.000
Run this.

18:43.000 --> 18:44.000
Done.

18:44.000 --> 18:46.000
Let's actually verify that it worked.

18:46.000 --> 18:48.000
If I, um,

18:48.000 --> 18:51.000
if I run the log again with this,

18:51.000 --> 18:53.000
right there, right?

18:53.000 --> 18:55.000
Single atomic operation.

18:55.000 --> 18:57.000
So, if it failed, it would fail in memory.

18:57.000 --> 18:58.000
It will let me know.

18:58.000 --> 19:00.000
And then kind of not proceed.

19:00.000 --> 19:03.000
Or not reach of partial success case.

19:03.000 --> 19:06.000
And let's actually, since we have more time,

19:06.000 --> 19:09.000
let's, let's move it somewhere else.

19:09.000 --> 19:11.000
Let's, let's move it in this commit 24.

19:11.000 --> 19:14.000
So, let's say, um,

19:14.000 --> 19:15.000
uh,

19:15.000 --> 19:18.000
BD, uh,

19:21.000 --> 19:23.000
24.

19:23.000 --> 19:24.000
Right?

19:24.000 --> 19:25.000
So, we've done it again.

19:25.000 --> 19:26.000
All right.

19:26.000 --> 19:28.000
It's the same, um, kind of move operation.

19:28.000 --> 19:30.000
Now it's, now it's in the,

19:30.000 --> 19:34.000
that's very fine.

19:34.000 --> 19:35.000
Now, you have, right?

19:35.000 --> 19:36.000
It's now this commit.

19:36.000 --> 19:37.000
So, you know,

19:37.000 --> 19:39.000
you can do stuff like that with, uh,

19:39.000 --> 19:41.000
library access to, to, to, to get, uh,

19:41.000 --> 19:42.000
get structures.

19:42.000 --> 19:43.000
Okay.

19:43.000 --> 19:45.000
That's, uh,

19:45.000 --> 19:46.000
that's it.

19:46.000 --> 19:49.000
I'm gonna leave you guys with just two final takes.

19:49.000 --> 19:51.000
One is kind of silly.

19:51.000 --> 19:52.000
The other one is a little bit more,

19:52.000 --> 19:53.000
philosophical.

19:53.000 --> 19:54.000
Or it, it will,

19:54.000 --> 19:56.000
it will tend to be philosophical.

19:56.000 --> 19:57.000
Now the first one is that,

19:57.000 --> 19:58.000
get this awesome,

19:58.000 --> 20:00.000
and get excited is pretty cool.

20:00.000 --> 20:01.000
If, if you haven't,

20:01.000 --> 20:02.000
you should try it out.

20:02.000 --> 20:03.000
After this talk,

20:03.000 --> 20:04.000
get the code.

20:04.000 --> 20:05.000
Check it out.

20:06.000 --> 20:08.000
And, um,

20:08.000 --> 20:11.000
get them on is the philosophical one.

20:11.000 --> 20:13.000
So, when facing a problem,

20:13.000 --> 20:14.000
uh,

20:14.000 --> 20:16.000
we always have a choice.

20:16.000 --> 20:19.000
And the choice is to either spend a few hours

20:19.000 --> 20:21.000
and do the boring work,

20:21.000 --> 20:24.000
or spend a few weeks,

20:24.000 --> 20:26.000
uh,

20:26.000 --> 20:27.000
building a tool.

20:27.000 --> 20:29.000
And since this is about hacking,

20:29.000 --> 20:31.000
uh, hacking with get,

20:31.000 --> 20:33.000
I would encourage you to always choose,

20:33.000 --> 20:34.000
uh, making the tool.

20:35.000 --> 20:37.000
After all, we are on a Sunday,

20:37.000 --> 20:39.000
talking about the rust,

20:39.000 --> 20:41.000
uh, like listening about rust.

20:41.000 --> 20:42.000
So, um, yeah,

20:42.000 --> 20:44.000
I think that's, that's the right choice.

20:44.000 --> 20:45.000
So,

20:45.000 --> 20:46.000
thank you very much.

20:46.000 --> 20:48.000
Uh, we have some time for Q&A.

20:48.000 --> 20:49.000
Thank you.

20:49.000 --> 20:50.000
Thank you.

20:50.000 --> 20:51.000
Thank you.

20:51.000 --> 20:52.000
Thank you.

20:52.000 --> 20:53.000
Thank you.

20:53.000 --> 20:54.000
Thank you.

20:54.000 --> 20:55.000
Thank you.

20:55.000 --> 20:56.000
Thank you.

20:56.000 --> 20:58.000
So, we have some time.

20:58.000 --> 20:59.000
Some questions.

20:59.000 --> 21:00.000
This way.

21:00.000 --> 21:01.000
Yeah.

21:02.000 --> 21:03.000
Um,

21:03.000 --> 21:04.000
uh,

21:04.000 --> 21:05.000
questions.

21:06.000 --> 21:07.000
Uh,

21:07.000 --> 21:08.000
uh, one question and one,

21:08.000 --> 21:09.000
we're much.

21:09.000 --> 21:11.000
Can you, can you show back the,

21:11.000 --> 21:12.000
uh,

21:12.000 --> 21:13.000
when you did the,

21:13.000 --> 21:14.000
when you did the demo,

21:14.000 --> 21:15.000
we can show it here.

21:15.000 --> 21:16.000
When you,

21:16.000 --> 21:17.000
when you did the demo,

21:17.000 --> 21:18.000
uh,

21:18.000 --> 21:21.000
it doesn't tell you that you created a commit without any content,

21:21.000 --> 21:23.000
because when you move the file between the commits,

21:23.000 --> 21:26.000
the photo original one did not have any content left.

21:26.000 --> 21:27.000
Yeah.

21:27.000 --> 21:29.000
Doesn't tell you at all that you,

21:29.000 --> 21:32.000
that you know of an empty commit in your story that doesn't do anything in the,

21:32.000 --> 21:33.000
right.

21:33.000 --> 21:37.000
So, I think the question is why was there no content after extracted the file?

21:37.000 --> 21:38.000
No.

21:38.000 --> 21:39.000
I get why it doesn't content,

21:39.000 --> 21:42.000
but why it doesn't tell you that there's no content left in the,

21:42.000 --> 21:44.000
you have an empty commit in your story now.

21:44.000 --> 21:46.000
So, so this is,

21:46.000 --> 21:47.000
well, this was demo, right?

21:47.000 --> 21:50.000
Like it was just like an example of of what you can't,

21:50.000 --> 21:51.000
I can do.

21:51.000 --> 21:54.000
So, I think what you're saying is it makes sense to inform the user that,

21:54.000 --> 21:56.000
oh, you're going to make an empty commit.

21:56.000 --> 21:57.000
That's completely fair.

21:57.000 --> 21:58.000
Um,

21:58.000 --> 21:59.000
probably should.

21:59.000 --> 22:00.000
Ah.

22:00.000 --> 22:01.000
Yeah.

22:01.000 --> 22:02.000
Okay.

22:02.000 --> 22:03.000
And just the remark.

22:03.000 --> 22:06.000
I think there was an earlier presentation yesterday,

22:06.000 --> 22:08.000
in a 254 of Git,

22:08.000 --> 22:12.000
there would be comments to modify the history of different commits.

22:12.000 --> 22:13.000
And for instance, you can now,

22:13.000 --> 22:15.000
you will be able to split commits.

22:15.000 --> 22:17.000
We want them, and we write their content,

22:17.000 --> 22:20.000
after they've been landed and such.

22:20.000 --> 22:22.000
So, I think that would be interesting for,

22:22.000 --> 22:23.000
yeah, for this.

22:23.000 --> 22:24.000
Yeah.

22:24.000 --> 22:27.000
I guess what you're saying is more and more of this functionality is kind of,

22:27.000 --> 22:29.000
you're going to mainline Git.

22:29.000 --> 22:30.000
Yeah.

22:30.000 --> 22:31.000
I mean, yes.

22:31.000 --> 22:32.000
You could.

22:32.000 --> 22:37.000
At some point we will have perhaps some of these in here.

22:37.000 --> 22:39.000
Any questions?

22:39.000 --> 22:44.000
Hi.

22:44.000 --> 22:48.000
Often, I like to change the metadata.

22:48.000 --> 22:56.000
So, for example, in this case, you move the content.

22:56.000 --> 23:00.000
Does it retain the metadata in this case?

23:00.000 --> 23:04.000
Does it overwrite with the current metadata?

23:04.000 --> 23:06.000
Well, so the question is,

23:06.000 --> 23:09.000
should you change the metadata as you made this kind of operations?

23:09.000 --> 23:11.000
Like, it's up to you, right?

23:11.000 --> 23:17.000
Like, it's about using the library and what you could do with programmatic access.

23:17.000 --> 23:20.000
So, if your use case means that,

23:20.000 --> 23:22.000
oh, the metadata needs to change,

23:22.000 --> 23:25.000
like, the timestamp or something, like, absolutely.

23:25.000 --> 23:26.000
Do that.

23:26.000 --> 23:28.000
Is that handled to do it?

23:28.000 --> 23:29.000
Pardon?

23:29.000 --> 23:31.000
I have the capability to do it.

23:31.000 --> 23:32.000
Yes.

23:32.000 --> 23:33.000
Right.

23:33.000 --> 23:36.000
Like, because you have all the bits and bobs to tweak.

23:42.000 --> 23:43.000
Great. Great.

23:43.000 --> 23:44.000
Then I thank you.

23:44.000 --> 23:49.000
Git or, and I've used some internal Git libraries in the past.

23:49.000 --> 23:54.000
And re-impermitations of Git in different languages have or suffer from performance.

23:54.000 --> 23:58.000
Like, packing objects and compressing and all the weird internals of Git.

23:58.000 --> 24:04.000
I imagine you guys may have done benchmarks against base Git and Git Oxide,

24:04.000 --> 24:11.000
but is Git Oxide fairly close to, to roll Git in terms of its pack and clone type performance?

24:11.000 --> 24:16.000
So, the maintainer and author of Git Oxide is very performance-conscious.

24:16.000 --> 24:21.000
And so, he cares very deeply about making a performance library.

24:21.000 --> 24:27.000
And that means that a lot of the aspects of the library are fast.

24:27.000 --> 24:30.000
And I know that cloning in particular isn't, isn't, isn't nice and fast.

24:30.000 --> 24:35.000
Because you can do things, you know, it's able to parallelize some of the workload.

24:35.000 --> 24:40.000
So, some of the operations are faster than mainline Git.

24:40.000 --> 24:41.000
And yeah.

24:41.000 --> 24:44.000
What algorithm does it use for?

24:44.000 --> 24:45.000
Sorry.

24:46.000 --> 24:51.000
What algorithm does Git Oxide use for pack for doubt to a compression?

24:51.000 --> 24:54.000
The question, I do not know.

24:54.000 --> 24:57.000
I just don't know the answer to this.

24:57.000 --> 24:58.000
Sorry.

24:58.000 --> 24:59.000
Yeah.

24:59.000 --> 25:02.000
I think that's, that's all the time we have.

25:02.000 --> 25:03.000
Great.

25:03.000 --> 25:04.000
You can catch GitHub.

25:04.000 --> 25:06.000
Yeah, you can hold outside if you guys want.

25:06.000 --> 25:07.000
Yeah.

25:07.000 --> 25:08.000
Thank you so much.

25:08.000 --> 25:09.000
Thank you.

25:09.000 --> 25:10.000
Thank you.

25:10.000 --> 25:11.000
Thank you.

