What is need to specify how to reconcile divergent branches?

MERGE STRATEGIES – The merge mechanism ( git merge and git pull commands) allows the backend merge strategies to be chosen with -s option. Some strategies can also take their own options, which can be passed by giving -X arguments to git merge and/or git pull,

• Recursive This can only resolve two heads using a 3-way merge algorithm.
• When there is more than one common ancestor that can be used for 3-way merge, it creates a merged tree of the common ancestors and uses that as the reference tree for the 3-way merge.
• This has been reported to result in fewer merge conflicts without causing mismerges by tests done on actual merge commits taken from Linux 2.6 kernel development history.

Additionally this can detect and handle merges involving renames. It does not make use of detected copies. This is the default merge strategy when pulling or merging one branch. The recursive strategy can take the following options: ours This option forces conflicting hunks to be auto-resolved cleanly by favoring our version.

Changes from the other tree that do not conflict with our side are reflected in the merge result. For a binary file, the entire contents are taken from our side. This should not be confused with the ours merge strategy, which does not even look at what the other tree contains at all. It discards everything the other tree did, declaring our history contains all that happened in it.

theirs This is the opposite of ours ; note that, unlike ours, there is no theirs merge strategy to confuse this merge option with. patience Deprecated synonym for diff-algorithm=patience, diff-algorithm= Use a different diff algorithm while merging, which can help avoid mismerges that occur due to unimportant matching lines (such as braces from distinct functions).

• See also git-diff -diff-algorithm,
• Defaults to the diff.algorithm config setting.
• Ignore-space-change ignore-all-space ignore-space-at-eol ignore-cr-at-eol Treats lines with the indicated type of whitespace change as unchanged for the sake of a three-way merge.
• Whitespace changes mixed with other changes to a line are not ignored.

See also git-diff -b, -w, -ignore-space-at-eol, and -ignore-cr-at-eol,

• If their version only introduces whitespace changes to a line, our version is used;
• If our version introduces whitespace changes but their version includes a substantial change, their version is used;
• Otherwise, the merge proceeds in the usual way.

renormalize This runs a virtual check-out and check-in of all three stages of a file when resolving a three-way merge. This option is meant to be used when merging branches with different clean filters or end-of-line normalization rules. See “Merging branches with differing checkin/checkout attributes” in gitattributes for details.

• No-renormalize Disables the renormalize option.
• This overrides the merge.renormalize configuration variable.
• No-renames Turn off rename detection.
• This overrides the merge.renames configuration variable.
• See also git-diff -no-renames,
• Find-renames Turn on rename detection, optionally setting the similarity threshold.

This is the default. This overrides the merge.renames configuration variable. See also git-diff -find-renames, rename-threshold= Deprecated synonym for find-renames=, subtree This option is a more advanced form of subtree strategy, where the strategy makes a guess on how two trees must be shifted to match with each other when merging.

Instead, the specified path is prefixed (or stripped from the beginning) to make the shape of two trees to match. ort This is meant as a drop-in replacement for the recursive algorithm (as reflected in its acronym — ”Ostensibly Recursive’s Twin”), and will likely replace it in the future. It fixes corner cases that the recursive strategy handles suboptimally, and is significantly faster in large repositories — especially when many renames are involved.

The ort strategy takes all the same options as recursive, However, it ignores three of those options: no-renames, patience and diff-algorithm, It always runs with rename detection (it handles it much faster than recursive does), and it specifically uses diff-algorithm=histogram,

• Resolve This can only resolve two heads (i.e.
• The current branch and another branch you pulled from) using a 3-way merge algorithm.
• It tries to carefully detect criss-cross merge ambiguities.
• It does not handle renames.
• Octopus This resolves cases with more than two heads, but refuses to do a complex merge that needs manual resolution.

It is primarily meant to be used for bundling topic branch heads together. This is the default merge strategy when pulling or merging more than one branch. ours This resolves any number of heads, but the resulting tree of the merge is always that of the current branch head, effectively ignoring all changes from all other branches.

• It is meant to be used to supersede old development history of side branches.
• Note that this is different from the -Xours option to the recursive merge strategy.
• Subtree This is a modified recursive strategy.
• When merging trees A and B, if B corresponds to a subtree of A, B is first adjusted to match the tree structure of A, instead of reading the trees at the same level.

This adjustment is also done to the common ancestor tree. With the strategies that use 3-way merge (including the default, recursive ), if a change is made on both branches, but later reverted on one of the branches, that change will be present in the merged result; some people find this behavior confusing.

What is divergent branches?

A diverged branch means the data you’re looking at locally isn’t the same as what is currently stored on our servers. This most frequently occurs if your network connection is spotty while merging a branch or you’ve been working offline while colleagues have continued to make changes to the project.

How do you compare divergent branches in git?

Manage Git branches | WebStorm In Git, branching is a powerful mechanism that allows you to diverge from the main development line, for example, when you need to, or freeze a certain state of a code base for a release, and so on. You can also manage branches and perform batch operations with multiple branches in the of the Git tool window.

1. In the Branches popup, choose New Branch or right-click the current branch in the Branches pane of the Git tool window and choose New Branch from ‘branch name’,
2. • In the dialog that opens, specify the branch name, and make sure the Checkout branch option is selected if you want to switch to that branch.
   • Once you start typing a name for your new branch, WebStorm will suggest relevant prefixes based on the names of existing local branches.
   • The new branch will start from the current branch HEAD.

1. In the Branches popup or in the Branches pane of the Git tool window select a local or a remote branch that you want to start a new branch from and choose New Branch from Selected,
2. In the dialog that opens, specify the branch name, and make sure the Checkout branch option is selected if you want to switch to that branch.

1. In the, select the commit that you want to act as a starting point for the new branch and choose New Branch from the context menu.
2. In the dialog that opens, specify the branch name, and make sure the Checkout branch option is selected if you want to switch to that branch.

1. In the Branches popup or in the Branches pane of the Git tool window, select the branch you want to rename and choose Rename,
2. In the dialog that opens, change the branch name to the one you need.

To copy the name of a branch, hover your mouse over the branch and press Control+C, If you have many branches, you may want to see only your favorite ones. The main branch is marked as a favorite by default. Favorite branches are always displayed at the top of the Branches popup and in the Branches pane of the Git tool window.

To mark a branch as a favorite, in the Branches popup, hover the mouse cursor over the branch name, and click the star outline that appears on the left: Alternatively, select the branch you want to mark as favourite and press Space, You can also select a branch in the Branches pane of the Git tool window and click on the toolbar.

While searching for a particular branch and navigating the list of branches, press Control+F to move the focus back to the search field. In the Branches popup, WebStorm keeps branches in three nodes:

• Recent branches node shows up to five recently checked-out branches.
• Local branches node lists all local branches.
• Remote branches node shows all remote branches available after the latest,

Also, WebStorm automatically groups branches by prefix and stores them in expandable lists. In order for branches to be grouped, prefixes in branches’ names should be separated with forward slashes /, For example, new/test, If you do not want your branches to be grouped by prefix, click in the upper-right corner of the Branches popup and then deselect the Group by Prefix option to disable it. If you want to work on a branch created by someone else, you need to check it out to create a local copy of that branch. To make sure you have a full list of remote branches, click in the Branches popup:

1. In the Branches popup or in the Branches pane of the Git tool window, select a branch that you want to check out locally from Remote Branches, or Common Remote Branches if your project has several roots and is enabled, or from Repositories | Remote Branches if it is disabled.
2. Choose Checkout from the list of actions.

1. new local branch will be created, checked out and set to track the origin remote branch.
2. It can happen that you already have a local branch with the same name as a remote branch you want to check out. Depending on the situation, here is how you can finish the checkout process:

• If no commits will be lost, and the local branch already tracks the remote, WebStorm automatically resets the local branch to the remote branch and then checks it out.
• If the local branch contains commits that can be lost because of the reset, WebStorm will offer you to:
  • Drop Local Commits : WebStorm will drop your local commits, reset the local branch, and change tracking.
  • Rebase onto Remote : WebStorm will rebase your local branch onto the remote branch, keep your local commits, reset the local branch, and change tracking.

When, you often need to jump between branches to commit unrelated changes.

1. In the Branches popup or in the Branches pane of the Git tool window, select the branch that you want to switch to under Local Branches and choose Checkout from the list of available operations. For multi-repository projects, branches are automatically grouped by repositories. To check out the neccesary branch, in the Branches popup, choose the repository first.
2. What happens next depends on whether there are conflicts between your local changes that you have not committed yet, and the branch that you are going to check out:
   • If your working tree is clean (that means you have no uncommitted changes), or your local changes do not conflict with the specified branch, this branch will be checked out (a notification will pop up in the bottom-right corner of the WebStorm window).
   • If your local changes are going to be overwritten by checkout, WebStorm displays a list of files that prevent you from checking out the selected branch, and suggests choosing between Force Checkout and Smart Checkout, If you click Force Checkout, your local uncommitted changes will be overwritten, and you will lose them. If you click Smart Checkout, WebStorm will uncommitted changes, check out the selected branch, and then unshelve the changes. If a conflict occurs during the unshelve operation, you will be prompted to merge the changes. For details, see, If you want to clean your working copy using instead of shelve, go to the Version Control | Git page of the IDE settings Control+Alt+S and choose Shelve under the Clean working tree using setting.

WebStorm saves your (a set of opened files, the current run configuration, and ) provided that the Restore workspace on branch switching option is enabled in the Settings dialog Control+Alt+S under Version Control | Confirmation, When you switch to a branch, WebStorm automatically restores your context associated with that branch.

1. From the Branches popup or from the Branches pane of the Git tool window, select the branch that you want to compare with the current branch, and choose Compare with Current, A new tab will be added to the Git tool window listing all commits that exist in the selected branch and do not exist in the current branch. You can click the Swap Branches link to change which branch is considered as a base against which you are comparing the other branch.
2. To see a list of all files that are different in the two branches, click Control+A : the will list all files that contain differences.

Apart from comparing a branch with the current branch, you can compare it against the local state of the current branch. This is useful if you have local uncommitted changes.

• From the Branches popup or from the Branches pane of the Git tool window, select the branch that you want to compare with the local working tree, and choose Show Diff with Working Tree, The Changes tool window that opens shows a list of all files that are different in the selected branch compared with the branch that is currently checked out:
  • Files that exist in the selected branch and are missing in the current branch are marked with grey.
  • Files that exist in the current branch but are missing in the selected branch are marked with green.
  • Files that contain differences between the selected and the current branch are marked with blue.

  You can click the Swap Branches link to change which branch is considered as a base against which you are comparing the other branch.

  • To review the differences within a specific file, select it and click on the toolbar, or press Control+D,
  • To apply the entire file contents to the current branch, click (see for details).

Watch this video to get a better view on how to compare changes to your branch: After you have from a feature branch into the main line of development, you can delete the branch you do not need anymore.

1. Check out a branch that you are going to use for further work.
2. In the Branches popup or from the Branches pane of the Git tool window, right-click the branch you want to delete and choose Delete,

After you have deleted a branch, a notification will be displayed in the bottom-right corner from which you can restore the deleted branch: If the branch contained commits that have not yet been merged to its upstream branch or to the current branch, it will still be deleted immediately (equivalent to the git branch -D or git branch -delete -force command), but the notification will also contain a link allowing you to view the unmerged commits.

1. Press Control+Alt+S to open the IDE settings and select,
2. Select the Execute branch operations on all roots option (note that this option is only available if your project has multiple roots).

If an operation fails at least in one of the repositories, WebStorm prevents branches from diverging by suggesting you to roll back this operation in the repositories where it was successful. If you check out a branch only on one of the roots, WebStorm will show the Branches have diverged warning in the Branches popup.

It means that the root projects are on different branches. In case you want to proceed, either ignore this warning or disable the Execute branch operations on all roots option. If you still want to execute branch operations on all roots simultaneously, check out the branch with the same name in the rest of the repositories manually.

Last modified: 20 July 2023 : Manage Git branches | WebStorm

What is the meaning of rebasing?

What is git rebase? – Rebasing is the process of moving or combining a sequence of commits to a new base commit. Rebasing is most useful and easily visualized in the context of a feature branching workflow. The general process can be visualized as the following: From a content perspective, rebasing is changing the base of your branch from one commit to another making it appear as if you’d created your branch from a different commit. Internally, Git accomplishes this by creating new commits and applying them to the specified base. It’s very important to understand that even though the branch looks the same, it’s composed of entirely new commits.

What does reconciling divergent values mean?

Reconciling divergent values Reconciling divergent accounts is a metacognitive task of a high order. It entails deep thinking about the thought processes of other people, as represented in multiple accounts that may be at odds with one another and with one’s own ideas.

Making sense of and reconciling divergent views is a challenge of our time. Consider the following scenario: You were asked to investigate why people living in your city are getting cancer more often than people who live outside the city. You discovered that air pollution was worse inside the city than outside.

You wrote a report to the Health Department director stating that air pollution was a likely cause of the high cancer rate. The director also received a report from another person that said a likely cause was not enough stores in the city for people to buy healthy fruits and vegetables.

• The director is not sure what to conclude and has asked you for advice.
• The roots of epistemological understanding are found early in life in the conception of knowledge as reflecting an objective reality.
• This conception evolves toward a more correct one of knowledge as constructed by human minds but initially only as a multiplicity of subjective opinions a way of making sense of the inevitable discovery of multiple, often seemingly reasonable diverging claims.

Only eventually, and only by some people, do subjective and objective dimensions become coordinated in an understanding of knowledge as judgment (rather than immutable fact or unconstrained opinion) based on evaluation in a framework of alternatives and evidence and, accordingly, subject to change.

• The absolutist believer in a single objective reality can simply dismiss one of two divergent claims as a false belief requiring correction.
• The multiplist, who acknowledges multiple realities, faces no reconciliation task at all because claims are regarded simply as the freely chosen personal possessions of their holders, like pieces of clothing.

The evaluativist, in contrast, who seeks to evaluate and weigh contrasting accounts, supports the right to one’s opinion without succumbing to the view that all opinions are equally right and hence not subject to scrutiny. Only at an evaluativist level, then, do diverging claims become a problem needing solving.

Empirical support for this association exists. Individuals better at evaluating and reconciling diverging claims also show higher levels of epistemological understanding. Intervention studies have shown strengthening awareness of the existence of multiple perspectives to be effective in supporting progression from an absolutist to multiplist epistemology, either by explicitly pointing them out or by asking participants to envision them.

Inducing progression beyond this, however, to the evaluativist level that would support comparison and potential reconciliation of divergent claims has proven more challenging. Despite their scaffolding efforts, participants “found it difficult to construct fully justified dual-position arguments and to explain and reconcile differences between accounts, instead seeing the task as identifying which account was correct.

• Furthermore, recognizing the existence of conflicting accounts does not necessarily reduce individuals’ certainty regarding a decision to be reached on the topic.
• They may simply feel they now know more about it.
• Recognizing the existence of divergent views is an essential first step toward reconciling them, but it does not appear to be enough.

Comparative analysis requires evaluating sources and hence accuracy of each account and then constructing relations among their components, as well as between each account and one’s own prior beliefs. These are all preparatory steps to reconciliation.

Multivariable Causality The critical importance of evaluation and reconciliation of diverging claims, both within and beyond academic contexts, and the hypothesized mediating role of epistemological understanding led me to wonder whether there could be a weak link hampering progress beyond awareness of diverging views and toward efforts to evaluate, compare, and potentially reconcile them.

This possibility takes us back to the earlier vignette. Adolescents typically failed to recognize that the two accounts were not in conflict because the two potential causes may jointly contribute to the outcome. This was not entirely surprising. Reasoning about cause and effect is the most common form of reasoning humans engage in and the form most extensively studied by cognitive psychologists.

Criteria for inferring causes change during the first decades of life in ways that are predictable but may seem paradoxical. Young children commonly regard an event as causal simply because it co-occurs with an outcome. They later adhere to more rigorous criteria and begin to distinguish causality from covariation and eventually may become able to eliminate potential causes via controlled comparison.

Surprisingly, however, children, teens, and even adults who have mastered this skill are likely to attribute a particular outcome to only a single factor. This is so even when they have themselves just demonstrated that other factors also affect the outcome.

1. Moreover, the single factor to which causal power is attributed is likely to shift, with prior beliefs sometimes affecting these attributions: With factors A and B present in both instances, an outcome in one instance is attributed to factor A and in the next instance to factor B.
2. A similar tendency appears in open-ended explanations, unconstrained by requests to examine specific evidence.

Adults show a preference for explaining a phenomenon in terms of a single favored factor. Failure of will power explains obesity. Discounting of an original cause follows discovery of a second cause. In addition, single-cause views are held more firmly and with higher reported affect than multiple-cause ones.

What are divergent branches in github?

How can we diverge two branches in Git A branch in git is a series of interrelated commits. If two branches follow a non-linear path then they diverge each other. The diagram shows two diverged branches master and feature, Consider the above diagram. Let us assume that both the branches were following a linear path before the initial commit. After the initial commit, the branch master has an independent commit c1 and the branch feature has its own commit c2, As the branches now follow a non-linear path, we can say that both the branches are diverged. Let us see this through an example Step 1 − Create an empty repository with an initial commit. $git init $echo hello>hello.txt $git add, $git commit -m ‘Initial commit’

How do you explain Divergent?

Two divergent paths are moving in opposite directions — away from each other. Things that are divergent are diverging — moving away from a path or a standard. A teacher who comes to work in a clown outfit is being divergent; a clown who comes to work in a business suit is also being divergent.

What does Divergent mean in calculus?

Divergent series Infinite series that is not convergent For the book series, see, For the film series, see, Les séries divergentes sont en général quelque chose de bien fatal et c’est une honte qu’on ose y fonder aucune démonstration. (“Divergent series are in general something fatal, and it is a disgrace to base any proof on them.” Often translated as “Divergent series are an invention of the devil “), letter to Holmboe, January 1826, reprinted in volume 2 of his collected papers.

1. In, a divergent series is an that is not, meaning that the infinite of the of the series does not have a finite,
2. If a series converges, the individual terms of the series must approach zero.
3. Thus any series in which the individual terms do not approach zero diverges.
4. However, convergence is a stronger condition: not all series whose terms approach zero converge.

A is the 1 + 1 2 + 1 3 + 1 4 + 1 5 + ⋯ = ∑ n = 1 ∞ 1 n,1+ }+ }+ }+ }+\cdots =\sum _ ^ }. The divergence of the harmonic series by the medieval mathematician, In specialized mathematical contexts, values can be objectively assigned to certain series whose sequences of partial sums diverge, in order to make meaning of the divergence of the series. A summability method or summation method is a from the set of series to values. For example, assigns 1 − 1 + 1 − 1 + ⋯ 1-1+1-1+\cdots the value 1 / 2, Cesàro summation is an method, in that it relies on the of the sequence of partial sums. Other methods involve of related series. In, there are a wide variety of summability methods; these are discussed in greater detail in the article on,

What defines a Divergent answer?

Divergent question

A divergent question is a with no specific answer, but rather exercises one’s ability to think broadly about a certain topic.

How to compare two different branches in git?

In order to compare two branches easily, you have to use the ‘git diff’ command and provide the branch names separated by dots. Using this command, Git will compare the tip of both branches (also called the HEAD) and display a ‘diff’ recap that you can use to see modifications.

How to compare two files from different branches in git?

Overview – The git diff command is used to perform the diff function The diff function computes the difference between pairs of consecutive elements of a numeric vector on Git data sources. For example, commits, branches, files, and so on. It can also be used to compare two files of different branches.

How to compare two branches in git software?

Comparing Branches in Tower – In case you are using the Tower Git GUI, comparing branches is very easy. You can simply select the branches in the sidebar, right-click, and select the “Compare.” option from the contextual menu. Tower will then start a comparison and show the differing changes in your favorite diff tool.

What is golden rule of rebasing?

The Golden Rule of Rebasing – Once you understand what rebasing is, the most important thing to learn is when not to do it. The golden rule of git rebase is to never use it on public branches. For example, think about what would happen if you rebased main onto your feature branch: The rebase moves all of the commits in main onto the tip of feature, The problem is that this only happened in your repository. All of the other developers are still working with the original main, Since rebasing results in brand new commits, Git will think that your main branch’s history has diverged from everybody else’s.

The only way to synchronize the two main branches is to merge them back together, resulting in an extra merge commit and two sets of commits that contain the same changes (the original ones, and the ones from your rebased branch). Needless to say, this is a very confusing situation. So, before you run git rebase, always ask yourself, “Is anyone else looking at this branch?” If the answer is yes, take your hands off the keyboard and start thinking about a non-destructive way to make your changes (e.g., the git revert command).

Otherwise, you’re safe to re-write history as much as you like.

How do I rebase a branch?

Git Rebase – Rebasing a branch in Git is a way to move the entirety of a branch to another point in the tree. The simplest example is moving a branch further up in the tree. Say we have a branch that diverged from the master branch at point A: /o-o-o-o-o- branch -o-o-A-o-o-o-o-o-o-o-o- master When you rebase you can move it like this: /o-o-o-o-o- branch -o-o-A-o-o-o-o-o-o-o-o master To rebase, make sure you have all the commits you want in the rebase in your master branch.

What are the 4 levels of reconciliation?

The four RAP types – Reflect, Innovate, Stretch and Elevate – allow organisations to continuously develop their reconciliation commitments. – Reconciliation Australia’s RAP Framework provides organisations with a structured approach to advance reconciliation.

What are the 3 stages of reconciliation?

The Process of Reconciliation: Chapter 2 in Reconciliation after Violent Conflict Reconciliation means different things to different people. Its significance varies from culture to culture, and changes with the passage of time. To understand the concept this paper poses four basic questions namely: what is Reconciliation; who is involved; how; and when, in what order and how fast? Key findings:

Ideally reconciliation prevents, once and for all, the use of the past as the seed of renewed conflict. It consolidates peace, breaks the cycle of violence and strengthens newly established or reintroduced democratic institutions. In practice such all-encompassing reconciliation is not easy to realize. It is not an isolated act, but a constant readiness to leave the tyranny of violence and fear behind. It is also not an event but a process, and as such usually a difficult, long and unpredictable one, involving various steps and stages. The reconciliation process is not a linear one. At each stage a relapse back into more violent means of dealing with conflicts is always a real possibility and the stages do not always follow logically after each other in any set order. The three stages for reconciliation are: replacing fear by non-violent coexistence; building confidence and trust; and developing empathy. Coexistence, trust and empathy develop between individuals who are connected as victims, beneficiaries and perpetrators. This is reconciliation at the interpersonal level. Many initiatives in the area of healing (counselling victims and offenders together) and restorative justice (mediation) take this route towards reconciliation. All the steps in the process also entail the reconciling of groups and communities as a whole. Each perspective, the interpersonal and the collective, has its own chemistry but they are equally important in the process of reconciliation. Burying the past in a reconciliatory way requires the mobilization of a variety of techniques. Most of them have to be activated in the short run: healing the wounds of the survivors; some form of retributive or restorative justice; historical accounting via truth-telling; and reparation of the material and psychological damage inflicted on the victims. There are close links between these four mechanisms. Without reparation there can be no healing. Restorative justice, if adequately organized, can heal the wounds of both victim and perpetrator. Given the volatility of an immediate post-conflict context, time management in processing reconciliation is an extremely important but difficult dimension in the search for a shared future. Policies must not come too soon or too late. The end of a violent conflict creates a complex agenda- rebuilding the political machinery and the civil service, holding free elections, prosecuting human rights abusers and so on. More often than not it will be impossible to tackle all tasks simultaneously. As reconciliation is only one of the many challenges, short-term political or economic interests may lead to reconciliation measures being postponed. However, reconciliation efforts cannot be put off indefinitely. Healing, truth-telling and reparation deliver important short-term benefits but generally they will not eliminate altogether the underlying causes of the past violence. Long-term tools are also required, three such tools are: education, memory and retrospective apologies.

: The Process of Reconciliation: Chapter 2 in Reconciliation after Violent Conflict

Why use rebase instead of merge?

Rebase – Merge lets you merge different Git branches. Rebase allows you to integrate the changes from one branch into another. Merge logs show you the complete history of commit merging. Rebase logs are linear. As the commits are rebased, the history is altered to reflect this. All the commits on a feature branch are combined into a single commit on the master branch. All commits are rebased, and the same number of commits are added to the master branch. Merge is best used when the target branch is supposed to be shared. Rebase is best used when the target branch is private. Merge preserves history. Rebase rewrites history.

How do you generate diff between two branches?

In order to compare two branches easily, you have to use the ‘ git diff’ command and provide the branch names separated by dots. Using this command, Git will compare the tip of both branches (also called the HEAD) and display a ‘diff’ recap that you can use to see modifications.

How do I rebase a branch?

Git Rebase – Rebasing a branch in Git is a way to move the entirety of a branch to another point in the tree. The simplest example is moving a branch further up in the tree. Say we have a branch that diverged from the master branch at point A: /o-o-o-o-o- branch -o-o-A-o-o-o-o-o-o-o-o- master When you rebase you can move it like this: /o-o-o-o-o- branch -o-o-A-o-o-o-o-o-o-o-o master To rebase, make sure you have all the commits you want in the rebase in your master branch.