Thanks for the introduction, so today I want to talk about a new tool I'm doing in my spare
time.
It's called sub-patch that I want to present to you today.
For me, I'm a embedded system developer.
I'm doing Android, embedded stuff, and Yachto, embedded stuff.
This project I'm doing for fun.
I'm doing my jacket away, my company, jacket away,
and now I have the first time the fun part.
Now begins.
What is sub-patch?
Here is the website, so I have not bought any slides today.
I show the website, so I will just read out the website
out loudly to you today and show maybe some comments.
I heard that you should repeat everything that is important,
so call to action first.
If you have questions, if you have future requests or something like that,
please join on Matrix.
I've created a channel there.
They are currently just one member in this channel.
This is me, please join.
Or go to get up, open an issue, or you can email me,
or you can also meet me then outside.
So what do I do today?
Yeah, presents the call of action.
Please contact me.
I will go through the homepage.
I will maybe do a short showcase of the tool,
and again, with PC call to action, so you know it.
So let's start with the homepage.
Yeah, it works.
So sub-head fearless multipository managed to stay relaxed.
So this is the tool I envision that does multipository managed to write.
Multipository management means that you are dealing
with multiple git repositors at once.
They should behave like a git, like a bit repository.
So if you are currently using git sub modules,
or repo, repo is a tool by Google using for the AOSP,
the Android open source project, and you are first rated.
Everyone using git sub modules, and it's a pain.
Yeah, my tool will be hopefully better.
So if you're interested, please email me.
An important point sub-head is not production ready.
I say it's currently an alpha stage prototype,
but please try it out.
And if feedback and based on your feedback,
I will develop or we together will develop the tool further.
Quick start.
You need to be for the tool.
You need to be in a git repository.
For now, then you download a Python script.
This is called the prototype.
It's just a Python script.
You download.
Then you make a script executable,
and then you can use a script.
This is the add command.
So this adds a sub repository.
We'll project into your super project.
So here it's Google Test.
Google Test is the sub project.
And the super project is the repository.
Your command line is currently in.
So that's for the terminology.
You have for sub projects.
You have here the URL.
Here, for example, you clone the Google Test repository and code.
Here, that's the path where you are cloning into.
So the local path in your super project.
And you can also specify a revision.
In that case, it's version number, which is a git tag.
But it can also be a branch.
Then you can call or step at status to see what's going on.
And in your repository, then you commit your changes.
If it's all white and both.
And then you can also get call and get status again to see what's
have changed.
So what are the intended use cases for my tool?
So you can use it to assemble a monitoring repository from multiple
Git repository.
Or whether you want to integrate a third part in dependency
in your code base, which asks source files.
So without application package manager like NPM or cargo,
if you want to just include these source files,
you can also now use or when it's ready, sub page.
And if you want to maintain a local foc of an upstream project,
but sometimes at least in the embedded spaces often
the case that you use a library using Linux kernel.
But it does not work out of the box for your device or for your target.
And then you have to apply fixes and features.
And then we are maintaining local focs of the projects.
And the sub page, this will be also possible to maintain
a linear path stack based on an upstream project.
Concept and design.
It's based on Git app.
So the files of the sub project are added just as is
into the super project.
So like unpacking a table or
zip file.
In most cases, the sub projects will be just
give you repositories.
But I envision that they can buy also
tables or make you a pool and make you a
pool with repositories or as for any repositories,
everything that should work.
For the design, the metadata is in a Git
config style format because it's easy and well known.
And you can maintain our local foc with a linear
path stack and sub page will help you
to maintain the linear path stack.
And important new versions will
be used for future new features in the sub project or
bug fixes.
Sub page should have a sub page update
command to also incorporate this new features from the
sub project.
So the main difference to other tools is that
other tools, for example, like the sub modules,
repo by Google.
Cust is by Siemens for
Dr. projects and rest is by
Saffer for
Saffer projects.
These tools deal with multiple Git repositories
that are cloned onto your local checkout
and you have multiple Git repositories in your
local checkout and the main difference to
sub page is that
sub page will only on your local checkout will have
one Git repository and that is your
super project.
And this is a lot simpler.
There's also more comparison here when
I click on this link.
You are more comparison for that.
So website and documentation.
So here you are seeing the website.
This is your homepage.
There are also the new releases
announced on the release notes page.
It's fast here.
For example, I have already three releases in
the offer stage.
So not production ready.
And again, yeah.
Supporting if you want to have support or
want to post picture requests.
Join matrix.
Go on GitHub or email.
Code and license.
Yeah.
The code is on GitHub.
This repository, I license C source code or
low license C source code.
As GPL2 only, while doing this,
it's the same license.
The Linux kernel is using.
And the Git is also using the same license.
Again, open source.
The website is licensed with creative
comments.
Yeah.
If you contribute, please add your sign-off.
Also the same factors as
get users and the Linux kernel uses.
Yeah.
Please do not look too much into the code.
So it's a prototype.
I've written it from scratch very, very quickly.
It works.
I have a good test coverage.
But roughly I have 10 to do a pair of 10 lines of code.
I have one to do comment.
So yeah, a lot of two comments in the code yet.
Yeah.
The less feedback is welcome.
And yeah, open source.
One, T, this claimer.
Yeah.
As also see in the in-get.
In the GPL version two.
So on the left side, you have the menu.
I've written an introduction to the multi repository problem.
I have written about see my personal history about
see multi repository problem.
I started to have this issue.
I think now nine years ago.
And this where I explain what I have seen in the wide, for example,
we put tool, get sub modules.
Everyone knows get sub three.
Yeah.
And I also don't like it.
Yeah.
And here I'm trying to explain what problems I see with all these tools.
And why I'm new to sub patch.
I think it's new.
Okay.
And I also have a page about two requirements.
So what are the requirements for a new tool.
So what are the requirements?
And I also recommend my design decisions.
So I want to be upfront.
Very transparent.
What I'm doing with situ.
Whereas doing the direction and why I've done that.
Yeah.
Okay.
And we have five minutes.
So we can do demo.
And I have tutorial.
How to install it.
You can also install it with tip.
So you don't have to download the standard on script.
But you can also download the standard on script.
Tutorial with basic usage.
Yeah.
I already have a command line.
Reference with four commands.
List status at an update for now.
And I also have a glossary where trying to explain all the terms that I'm using the project.
One of the problems is with this.
It's a very, very complex thing.
There are a lot of moving parts.
And just describing what is going on is one of the biggest things to do for this project.
Okay.
Then we have we go on the home.
And five minutes.
It's talk is over.
Yeah.
So click start.
We go to my console.
So here.
I have folder.
See, folder is empty.
If we do a get in it.
Yeah.
We do empty commit.
Just to be safe.
Allow empty.
Get status.
Okay.
Empty.
Nice.
So now we.
Okay.
Now we want to add a subject.
We copy this.
Of course, I can also do some such help.
So here we are listing all the commands.
We have add updates that is at list.
Now I'm pasting command to download to integrate a subject.
Now this will download it from GitHub.
And oh, it's already over.
And yeah.
And it also prints some information what you can do now.
So to inspect your changes, use get status and get different stage.
So we make a get status.
What we see.
Oh.
This has added a lot of files.
All the files from this project.
And now added to the super project.
We can also do a get diff.
Not a get diff is real.
Nothing because it's already staged.
So we do get staged.
And now we see all the changes from the upstream project.
But we can also look at the config format.
It's in the files of sub patch.
And this is the git start config format.
I'm talking about sub patch.
So here it's just sub patch.
The path you're cloning into the URL of the upstream project.
And the revision you have integrated.
But we are not finished because the changes are only staged.
And get it not committed.
So we do a commit.
Add G test.
Now we added it.
It's that is nothing to commit.
And on the disk we have the external folder where the Google test folder.
And now you have added your sub project with sub patch.
And sub patch status.
We'll also list all our sub files.
We have in this repository we now have one.
Sub project.
Add C location external.
Google test.
It was integrated from that URL.
And we have to infect the data from the configuration.
Okay.
Two minutes left.
Maybe just one thing.
So why I think sub patch will be easier to use.
And for example, sub modules.
One thing I have seen that in normal software projects.
You have two kind of different developers.
You have the occasional contributor or small contributor to our project,
which is not which is maybe from the outside or
that cannot use git very well.
And you have the project maintainers.
So they know the code base.
They know all the tools.
They get posts.
And if you use git sub modules.
Then everyone has to get use git sub modules.
So the small contributor has to use it.
When he wants to download your project,
they have to add git clone minus minus recursive load.
Sub modules.
And so if you use git sub modules,
both people have to have C pain with git sub modules.
So the small contributor and the maintainer.
If sub patch, this will be different.
Because sub patch is not a wrapper around git.
It's just a small addition to git.
So the small contributor, you will do,
or she will get clone, get clone from git.
Get the source code, make a modification.
Push, tag everything.
She will never notice that the project is actually using
or assembled from multiple sub repositories.
Only the maintainer who adds sub projects will have to
need to install sub patch and will have to use sub patch
to update dependencies.
That's why I think sub patch will be easier to use.
And for other reasons, then git sub modules.
Because small contributors will not have to deal with it.
Only the maintainers who are more experienced than you do it.
So then we come and to the presentation.
They are called to action again.
So if you think it's a good idea, if you think it's a better idea,
please join the matrix room,
present your source, open your issue,
and get up, or email me, or I will be outside right now
after the talk.
And yeah, come to me and talking about how we can make a better
multi repository management tool.
Thanks.
Thank you.