Hack or maybe not: "Deleting" master when it gets too big
Tags: todayilearned, git, discuss, productivity
Published: 2019-03-02 04:08:47

---
title: Hack or maybe not: "Deleting" master when it gets too big
published: true
description: Software dev shows me a faster way instead of pulling from a large repo
tags: TIL, git, discuss, productivity
---

Just documenting a pro-tip from a friend. Any dev opinion is precious to me due to not working amongst them. Please don't go to twitter to flame him. 

I'm just making notes for my future self.

{% twitter 1101234345598054401 %}

{% twitter 1101235541868232704 %}

{% twitter 1101244099137429504 %}

{% twitter 1101265528612638720 %}

{% twitter 1101267688226086912 %}


My initial thoughts: Perhaps the trick here is the difference between pull and fetch. Pull attempts to merge your changes with existing commits on remote, and with a huge repo that's risky...?

Update, for my own education and edification: 

@joelnet pointed out:
<blockquote> "For those of you that are confused, master is not deleted on the remote repo. It is only deleted on the local repo.
The way git fetch works, you always have a local copy.

...once you do `git checkout -b my-new-branch origin/master`, you'll have an identical copy of `origin/master`[.] it'll just be called `my-new-branch` locally."
</blockquote>
@yucer added: 
<blockquote>
"He means not checking out the master branch locally, just to use it [it] as base to checkout your branch.

You can checkout your new branch directly from the remote ("origin" in this case).

The difference is that, when you checkout master locally then git build[s] a working tree for it.

...to understand it correctly, you need to keep in mind that you can't work in all of the branches.

...git stores the changes differentially, when you checkout a branch it needs to calculate the complete state of the files and make the needed changes to you local files to reach those changes."
</blockquote>

Conrad's school of thought seems to resound with something I read a long while back on [Mark Longair's blog "GIT: FETCH AND MERGE, DON’T PULL"](https://longair.net/blog/2009/04/16/git-fetch-and-merge/) : 

<blockquote>...by both fetching and merging in one [git pull] command, your working directory is updated without giving you a chance to examine the changes you’ve just brought into your repository.

The safe ways to change remote-tracking branches are with git fetch or as a side-effect of git-push; you can’t work on remote-tracking branches directly. In contrast, you can always switch to local branches and create new commits to move the tip of the branch forward.
So what you mostly do with remote-tracking [local] branches is one of the following:

1. Update them with git fetch
2. Merge from them into your current branch
3. Create new local branches based on them

</blockquote>
I have yet to try working this way but can see git repos being updated like the former in very large projects.

@codemouse92 prefers to maintain an easy to access, canonical copy of what worked before. 
<blockquote>
You [already] pull the entire thing down the first time with `git fetch`, and then the incremental changes later with a basic `git pull`.

...`git pull` uses the same bandwidth as `git fetch`, you'll still saving yourself a step by not deleting master off your local copy every time.

...Don't delete `master`, leave it alone.
</blockquote>