# Reveal by history that several commits are independent from each other?
Suppose I am working on a feature `Search` for which I need to add some
configuration and some types first. So, I have three patches:
1. Add some configuration. To be more descriptive, I have to add some fields to
the structure that holds the configuration of my program, like say what URL
the search service is found at, and a way to parse these fields from the
configuration files.
2. Add some types. To be more descriptive, I have to add a structure with fields
like _«search string»_, _«case sensitivity»_ and so on, and a way to convert
this structure to JSON so that it can be sent to the search service.
3. Add the logic that looks into the configuration structure, sends a search
request to the appropriate search service and returns the results.
See that there is a partial but not total order of dependency on these patches:
_{3 > 2; 3 > 1}_. I want to wire this information into the repository.
One way to go about it is as follows: make a branch with patch 1, another branch
with patch 2, merge 1 into 2, then add patch 3 on top. This would create the
desired lozenge structure for me, showing to everyone that I believe patches 1
and 2 to be independent prerequisites for patch 3.
Is this a reasonable practice? Is there any prior art? What are the troubles to
look forward to?
There are some other version control systems, say `darcs` and `pijul`, that work
with a partial order of patches, but I do not have any experience working with
them.
One problem I foresee is that `git` will mess up my carefully crafted branching
structure when I try to rebase the patches 1, 2 and 3 together.
