<!DOCTYPE html>

<!---
  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an
  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, either express or implied.  See the License for the
  specific language governing permissions and limitations
  under the License.
-->

<html lang=" en"><head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link href="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/image/mxnet-icon.png" rel="icon" type="image/png"><!-- Begin Jekyll SEO tag v2.6.1 -->
<title>Git Usage Tips | Apache MXNet</title>
<meta name="generator" content="Jekyll v4.0.0" />
<meta property="og:title" content="Git Usage Tips" />
<meta property="og:locale" content="en_US" />
<meta name="description" content="A flexible and efficient library for deep learning." />
<meta property="og:description" content="A flexible and efficient library for deep learning." />
<link rel="canonical" href="https://mxnet.apache.org/versions/master/community/git_howto" />
<meta property="og:url" content="https://mxnet.apache.org/versions/master/community/git_howto" />
<meta property="og:site_name" content="Apache MXNet" />
<script type="application/ld+json">
{"url":"https://mxnet.apache.org/versions/master/community/git_howto","headline":"Git Usage Tips","description":"A flexible and efficient library for deep learning.","@type":"WebPage","@context":"https://schema.org"}</script>
<!-- End Jekyll SEO tag -->
<script src="https://medium-widget.pixelpoint.io/widget.js"></script>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/docsearch.js@2/dist/cdn/docsearch.min.css" />
  <link rel="stylesheet" href="/versions/master/assets/main.css"><link type="application/atom+xml" rel="alternate" href="https://mxnet.apache.org/versions/master/feed.xml" title="Apache MXNet" /><script>
if(!(window.doNotTrack === "1" || navigator.doNotTrack === "1" || navigator.doNotTrack === "yes" || navigator.msDoNotTrack === "1")) {
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-96378503-1', 'auto');
  ga('send', 'pageview');
}
</script>
  
<script src="/versions/master/assets/js/jquery-3.3.1.min.js"></script><script src="https://cdn.jsdelivr.net/npm/docsearch.js@2/dist/cdn/docsearch.min.js" defer></script>
  <script src="/versions/master/assets/js/globalSearch.js" defer></script>
  <script src="/versions/master/assets/js/clipboard.js" defer></script>
  <script src="/versions/master/assets/js/copycode.js" defer></script></head>
<body><header class="site-header" role="banner">

  <script>
    $(document).ready(function () {

      // HEADER OPACITY LOGIC

      function opacity_header() {
        var value = "rgba(4,140,204," + ($(window).scrollTop() / 300 + 0.4) + ")"
        $('.site-header').css("background-color", value)
      }

      $(window).scroll(function () {
        opacity_header()
      })
      opacity_header();

      // MENU SELECTOR LOGIC
      $('.page-link').each( function () {
        if (window.location.href.includes(this.href)) {
          $(this).addClass("page-current");
        }
      });
    })
  </script>
  <div class="wrapper">
    <a class="site-title" rel="author" href="/versions/master/"><img
            src="/versions/master/assets/img/mxnet_logo.png" class="site-header-logo"></a>
    <nav class="site-nav">
      <input type="checkbox" id="nav-trigger" class="nav-trigger"/>
      <label for="nav-trigger">
          <span class="menu-icon">
            <svg viewBox="0 0 18 15" width="18px" height="15px">
              <path d="M18,1.484c0,0.82-0.665,1.484-1.484,1.484H1.484C0.665,2.969,0,2.304,0,1.484l0,0C0,0.665,0.665,0,1.484,0 h15.032C17.335,0,18,0.665,18,1.484L18,1.484z M18,7.516C18,8.335,17.335,9,16.516,9H1.484C0.665,9,0,8.335,0,7.516l0,0 c0-0.82,0.665-1.484,1.484-1.484h15.032C17.335,6.031,18,6.696,18,7.516L18,7.516z M18,13.516C18,14.335,17.335,15,16.516,15H1.484 C0.665,15,0,14.335,0,13.516l0,0c0-0.82,0.665-1.483,1.484-1.483h15.032C17.335,12.031,18,12.695,18,13.516L18,13.516z"/>
            </svg>
          </span>
      </label>
      <div class="gs-search-border">
        <div id="gs-search-icon"></div>
        <form id="global-search-form">
          <input id="global-search" type="text" title="Search" placeholder="Search" />
          <div id="global-search-dropdown-container">
            <button class="gs-current-version btn" type="button" data-toggle="dropdown">
                <span id="gs-current-version-label">master</span>
                <svg class="gs-dropdown-caret" viewBox="0 0 32 32" class="icon icon-caret-bottom" aria-hidden="true">
                    <path class="dropdown-caret-path" d="M24 11.305l-7.997 11.39L8 11.305z"></path>
                </svg>
            </button>
            <ul class="gs-opt-group gs-version-dropdown">
              
                
                  <li class="gs-opt gs-versions active">master</li>
                
              
                
                  <li class="gs-opt gs-versions">1.8.0</li>
                
              
                
                  <li class="gs-opt gs-versions">1.7.0</li>
                
              
                
                  <li class="gs-opt gs-versions">1.6.0</li>
                
              
                
                  <li class="gs-opt gs-versions">1.5.0</li>
                
              
                
                  <li class="gs-opt gs-versions">1.4.1</li>
                
              
                
                  <li class="gs-opt gs-versions">1.3.1</li>
                
              
                
                  <li class="gs-opt gs-versions">1.2.1</li>
                
              
                
                  <li class="gs-opt gs-versions">1.1.0</li>
                
              
                
                  <li class="gs-opt gs-versions">1.0.0</li>
                
              
                
                  <li class="gs-opt gs-versions">0.12.1</li>
                
              
                
                  <li class="gs-opt gs-versions">0.11.0</li>
                
              
            </ul>
        </div>
          <span id="global-search-close">x</span>
        </form>
      </div>
      <div class="trigger">
        <div id="global-search-mobile-border">
          <div id="gs-search-icon-mobile"></div>
          <input id="global-search-mobile" placeholder="Search..." type="text"/>
          <div id="global-search-dropdown-container-mobile">
            <button class="gs-current-version-mobile btn" type="button" data-toggle="dropdown">
                <svg class="gs-dropdown-caret" viewBox="0 0 32 32" class="icon icon-caret-bottom" aria-hidden="true">
                    <path class="dropdown-caret-path" d="M24 11.305l-7.997 11.39L8 11.305z"></path>
                </svg>
            </button>
            <ul class="gs-opt-group gs-version-dropdown-mobile">
              
                
                  <li class="gs-opt gs-versions active">master</li>
                
              
                
                  <li class="gs-opt gs-versions">1.8.0</li>
                
              
                
                  <li class="gs-opt gs-versions">1.7.0</li>
                
              
                
                  <li class="gs-opt gs-versions">1.6.0</li>
                
              
                
                  <li class="gs-opt gs-versions">1.5.0</li>
                
              
                
                  <li class="gs-opt gs-versions">1.4.1</li>
                
              
                
                  <li class="gs-opt gs-versions">1.3.1</li>
                
              
                
                  <li class="gs-opt gs-versions">1.2.1</li>
                
              
                
                  <li class="gs-opt gs-versions">1.1.0</li>
                
              
                
                  <li class="gs-opt gs-versions">1.0.0</li>
                
              
                
                  <li class="gs-opt gs-versions">0.12.1</li>
                
              
                
                  <li class="gs-opt gs-versions">0.11.0</li>
                
              
            </ul>
        </div>
        </div>
        <a class="page-link" href="/versions/master/get_started">Get Started</a>
        <a class="page-link" href="/versions/master/blog">Blog</a>
        <a class="page-link" href="/versions/master/features">Features</a>
        <a class="page-link" href="/versions/master/ecosystem">Ecosystem</a>
        <a class="page-link" href="/versions/master/api">Docs & Tutorials</a>
        <a class="page-link" href="https://github.com/apache/incubator-mxnet">GitHub</a>
        <div class="dropdown">
          <span class="dropdown-header">master
            <svg class="dropdown-caret" viewBox="0 0 32 32" class="icon icon-caret-bottom" aria-hidden="true"><path class="dropdown-caret-path" d="M24 11.305l-7.997 11.39L8 11.305z"></path></svg>
          </span>
          <div class="dropdown-content">
            
              
                <a class="dropdown-option-active" href="/">master</a>
              
            
              
                <a href="/versions/1.8.0/">1.8.0</a>
              
            
              
                <a href="/versions/1.7.0/">1.7.0</a>
              
            
              
                <a href="/versions/1.6.0/">1.6.0</a>
              
            
              
                <a href="/versions/1.5.0/">1.5.0</a>
              
            
              
                <a href="/versions/1.4.1/">1.4.1</a>
              
            
              
                <a href="/versions/1.3.1/">1.3.1</a>
              
            
              
                <a href="/versions/1.2.1/">1.2.1</a>
              
            
              
                <a href="/versions/1.1.0/">1.1.0</a>
              
            
              
                <a href="/versions/1.0.0/">1.0.0</a>
              
            
              
                <a href="/versions/0.12.1/">0.12.1</a>
              
            
              
                <a href="/versions/0.11.0/">0.11.0</a>
              
            
          </div>
        </div>
      </div>
    </nav>
  </div>
</header>
<main class="page-content" aria-label="Content">
    <script>

</script>
<article class="post">

    <header class="post-header wrapper">
        <h1 class="post-title">Git Usage Tips</h1>
        <h3>Git 101</h3><a style="float:left; margin-top:20px" href="/versions/master/community/index" class="btn btn-action">Contribute
            <span class="span-accented">›</span></a></header>

    <div class="post-content">
        <div class="wrapper">
            <!--- Licensed to the Apache Software Foundation (ASF) under one -->
<!--- or more contributor license agreements.  See the NOTICE file -->
<!--- distributed with this work for additional information -->
<!--- regarding copyright ownership.  The ASF licenses this file -->
<!--- to you under the Apache License, Version 2.0 (the -->
<!--- "License"); you may not use this file except in compliance -->
<!--- with the License.  You may obtain a copy of the License at -->

<!---   http://www.apache.org/licenses/LICENSE-2.0 -->

<!--- Unless required by applicable law or agreed to in writing, -->
<!--- software distributed under the License is distributed on an -->
<!--- "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -->
<!--- KIND, either express or implied.  See the License for the -->
<!--- specific language governing permissions and limitations -->
<!--- under the License. -->

<h1 id="git-usage-tips">Git Usage Tips</h1>

<p>Here are some tips for git workflow.</p>

<p>## How to resolve conflict with master</p>

<ul>
  <li>First rebase to most recent master</li>
</ul>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># The first two steps can be skipped after you do it once.</span>
git remote add upstream git@github.com:apache/incubator-mxnet.git
git fetch upstream
git rebase upstream/master
</code></pre></div></div>

<ul>
  <li>The git may show some conflicts it cannot merge, say
<code class="highlighter-rouge">conflicted.py</code>.
    <ul>
      <li>Manually modify the file to resolve the conflict.</li>
      <li>After you resolved the conflict, mark it as resolved by</li>
    </ul>
  </li>
</ul>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>git add conflicted.py
</code></pre></div></div>

<ul>
  <li>Then you can continue rebase by</li>
</ul>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>git rebase <span class="nt">--continue</span>
</code></pre></div></div>

<ul>
  <li>Finally push to your fork, you may need to force push here.</li>
</ul>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>git push <span class="nt">--force</span>
</code></pre></div></div>

<h2 id="how-to-manage-branches">How to manage branches</h2>

<p>We recommend to always reserve the master branch for synchronizing with upstream.
For development of new features, create a new branch for each feature:</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>git checkout <span class="nt">-b</span> fancy_new_feature
</code></pre></div></div>

<p>The benefit of this practices is that you can easily rebase onto the latest master
changes with little effort</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>git pull upstream master <span class="nt">--rebase</span>
</code></pre></div></div>

<h2 id="how-to-combine-multiple-commits-into-one">How to combine multiple commits into one</h2>

<p>Sometimes we want to combine multiple commits, especially when later
commits are only fixes to previous ones, to create a PR with set of
meaningful commits. You can do it by following steps.</p>

<ul>
  <li>Before doing so, configure the default editor of git if you haven't
done so before.</li>
</ul>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>git config core.editor <span class="o">[</span>the-editor-you-like]
</code></pre></div></div>

<ul>
  <li>Assume we want to merge last 3 commits, type the following commands</li>
</ul>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>git rebase <span class="nt">-i</span> HEAD~3
</code></pre></div></div>

<ul>
  <li>It will pop up an text editor. Set the first commit as
[pick]{.title-ref}, and change later ones to [squash]{.title-ref}.</li>
  <li>After you saved the file, it will pop up another text editor to ask
you modify the combined commit message.</li>
  <li>Push the changes to your fork, you need to force push.</li>
</ul>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>git push <span class="nt">--force</span>
</code></pre></div></div>

<h2 id="reset-to-the-most-recent-master">Reset to the most recent master</h2>

<p>You can always use git reset to reset your version to the most recent
master. Note that all your <strong>*local changes will get lost</strong>*. So only
do it when you do not have local changes or when your pull request just
get merged.</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>git reset <span class="nt">--hard</span> <span class="o">[</span><span class="nb">hash </span>tag of master]
</code></pre></div></div>

<h2 id="recover-a-previous-commit-after-reset">Recover a Previous Commit after Reset</h2>

<p>Sometimes we could mistakenly reset a branch to a wrong commit. When
that happens, you can use the following command to show the list of
recent commits</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>git reflog
</code></pre></div></div>

<p>Once you get the right hashtag, you can use git reset again to change
the head to the right commit.</p>

<h2 id="apply-only-k-latest-commits-on-to-the-master">Apply only k-Latest Commits on to the master</h2>

<p>Sometimes it is useful to only apply your k-latest changes on top of the
master. This usually happens when you have other m-commits that are
already merged before these k-commits. Directly rebase against the
master might cause merge conflicts on these first m-commits(which are
can be safely discarded).</p>

<p>You can instead use the following command</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># k is the concrete number</span>
<span class="c"># Put HEAD~2 for the last 1 commit.</span>
git rebase <span class="nt">--onto</span> upstream/master HEAD~k
</code></pre></div></div>

<p>You can then force push to the master. Note that the above command will
discard all the commits before the last k ones.</p>

<h2 id="what-is-the-consequence-of-force-push">What is the consequence of force push</h2>

<p>The previous two tips requires force push, this is because we altered
the path of the commits. It is fine to force push to your own fork, as
long as the commits changed are only yours.</p>

<script async="" defer="" src="https://buttons.github.io/buttons.js"></script>

<script src="https://apis.google.com/js/platform.js"></script>


        </div>
    </div>

</article>

</main><footer class="site-footer h-card">
    <div class="wrapper">
        <div class="row">
            <div class="col-4">
                <h4 class="footer-category-title">Resources</h4>
                <ul class="contact-list">
                    <li><a href="/versions/master/community#stay-connected">Mailing lists</a></li>
                    <li><a href="https://discuss.mxnet.io">MXNet Discuss forum</a></li>
                    <li><a href="/versions/master/community#github-issues">Github Issues</a></li>
                    <li><a href="https://github.com/apache/incubator-mxnet/projects">Projects</a></li>
                    <li><a href="https://cwiki.apache.org/confluence/display/MXNET/Apache+MXNet+Home">Developer Wiki</a></li>
                    <li><a href="/versions/master/community">Contribute To MXNet</a></li>

                </ul>
            </div>

            <div class="col-4"><ul class="social-media-list"><li><a href="https://github.com/apache/incubator-mxnet"><svg class="svg-icon"><use xlink:href="/versions/master/assets/minima-social-icons.svg#github"></use></svg> <span class="username">apache/incubator-mxnet</span></a></li><li><a href="https://www.twitter.com/apachemxnet"><svg class="svg-icon"><use xlink:href="/versions/master/assets/minima-social-icons.svg#twitter"></use></svg> <span class="username">apachemxnet</span></a></li><li><a href="https://youtube.com/apachemxnet"><svg class="svg-icon"><use xlink:href="/versions/master/assets/minima-social-icons.svg#youtube"></use></svg> <span class="username">apachemxnet</span></a></li></ul>
</div>

            <div class="col-4 footer-text">
                <p>A flexible and efficient library for deep learning.</p>
            </div>
        </div>
    </div>
</footer>
<footer class="site-footer2">
    <div class="wrapper">
        <div class="row">
            <div class="col-3">
                <img src="/versions/master/assets/img/apache_incubator_logo.png" class="footer-logo col-2">
            </div>
            <div class="footer-bottom-warning col-9">
                <p>Apache MXNet is an effort undergoing incubation at The Apache Software Foundation (ASF), <span
                        style="font-weight:bold">sponsored by the <i>Apache Incubator</i></span>. Incubation is required
                    of all newly accepted projects until a further review indicates that the infrastructure,
                    communications, and decision making process have stabilized in a manner consistent with other
                    successful ASF projects. While incubation status is not necessarily a reflection of the completeness
                    or stability of the code, it does indicate that the project has yet to be fully endorsed by the ASF.
                </p><p>"Copyright © 2017-2018, The Apache Software Foundation Apache MXNet, MXNet, Apache, the Apache
                    feather, and the Apache MXNet project logo are either registered trademarks or trademarks of the
                    Apache Software Foundation."</p>
            </div>
        </div>
    </div>
</footer>




</body>

</html>
