Git功能分支依赖项

Question

I looked at several possible solutions on the Internet, but I still can not get it in my head, how it can help in my situation. We have a variation of git-flow: master branch, dev branch, each new feature is created in a separate branch from dev. The problem is that two developers working on one feature are dependent on each other's code.

Suppose this is a project for a microcontroller. One developer writes the system part, manages the memory. The second developer writes UI and does not touch the writing of system functions. It is most logical to assume that everyone should have their own feature branch.

However, both branches are cross-dependent on each other. To develop a feature, the UI developer needs to call the functions created by the first developer. To develop the functions, the first developer needs to test them on the resulting UI. In addition, developers must be constantly agreeing on what functions should be created and what signatures they should have - changes made by one developer are needed by the second developer almost instantly because of their close pair work.

Another example - web-dev with backend developer and frontend developer being dependent on each other changes.

How can this situation be resolved?

Answer 1

Integration branch?

I would imagine that a possible solution would be to create an integration branch where updates meet more often. If something breaks, anyone can fix it in their development branch and rebase/cherrypick to the integration branch.

They are also sometimes called "throwaway branches".

Example

Imagine a clean repository with last commit on the dev branch - D .

User F (frontend) creates its own branch frontend-dev on commit D . So does the user B (backend) a branch backend-dev on same commit.

Each user develops its own parts in their respective branches and as they are private branches, everything is allowed, including force pushes. And nobody else should commit to their branch.

After some time, the branches may look like this:

D - F1 - F2 - F3 - F4 <frontend-dev)
 \
  \ B1 - B2 - B3 <backend-dev)

Once the user F or B needs to test how their work integrate with each other, they create a new branch integration from commit D and accumulate all commits from both respective branches on top of it:

D - F1 - F2 - F3 - F4 <frontend-dev)
|\
| \ B1 - B2 - B3 <backend-dev)
 \
  \ F1 - F2 - F3 - F4 - B1 - B2 - B3 <integration)

If the backed developer finds a bug, he may create a fix, commit it as a fixup commit (with git commit --fixup ) on the integration branch and test:

D - F1 - F2 - F3 - F4 <frontend-dev)
|\
| \ B1 - B2 - B3 <backend-dev)
 \
  \ F1 - F2 - F3 - F4 - B1 - B2 - B3 - B2Fixup <integration)

Once the developer is happy, he/she may cherrypick all the work to his development branch:

D - F1 - F2 - F3 - F4 <frontend-dev)
|\
| \ B1 - B2 - B3 - B2Fixup <backend-dev)
 \
  \ F1 - F2 - F3 - F4 - B1 - B2 - B3 - B2Fixup <integration)

And possibly delete the integration branch. To clean up the repository, git rebase --interactive --autosquash dev may be used to achieve:

D - F1 - F2 - F3 - F4 <frontend-dev)
 \
  \ B1 - B2(withFixup) - B3 <backend-dev)