Mastering Git

What to focus on?

    Today is a scary day. Today is the day of admitting one's faults and learning what I was supposed to long ago. So let's dig into learning curve all together by looking at a couple of Git functions I personally have never used before, which though, for some of you, might already be very familiar, so I will try to bring more interesting information about them to peak everyone's interest.
    What are the two functions that we will be looking at? Shall it be git fetch and git tag.

Let's play Fetch

    The purpose of git fetch is to download commits, files, etc. from a remote repo into user's local one (from here, and here). How is it different from git pull then? Well, git fetch does not necessary merge the content with the user's repo, but git pull does. The way to imagine it would be git pull = git fetch + git merge.

    Here is a graphical representation of the above:

    There are quite a few ways to run the command:
  • git fetch [<options>] [<repository> [<refspec>…​]]
  • git fetch [<options>] <group>
  • git fetch --multiple [<options>] [(<repository> | <group>)…​]
  • git fetch --all [<options>]/
    And some of the interesting options for the command are:
  • --all           - fetches all repos
  • --depth=<depth> - limits fetching to a particular number of commits
  • -k
    --keep              - keeps downloaded package
  • --multiple      - allows multiple repositories/groups to be specified as parameters
  • -q
    --quiet             - silences any internally used git command; progress does not get
                                             reported to standard error stream
  • --progress      - progress status gets reported on the standard error stream
  Examples of the usage can be found here.

Let' tag it

    Tagging is a process of creating a "bookmark", a label at a specific point of time, which represents the version at which the project is present. It can look like any of the following: v1.0, v0.1, v1.8.9-rls, etc. In order to see the current tags available, you can type git tag, git tag -l or git tag --list (source).
    In case if the are quite a few tags in the project, the list can be narrowed down by specifying which ones we want to see. For instance: git tag -l "2.95.*". 
    There are to types of the tags present in Git:
  • Lightweight - they are somewhat similar to pointers to specific commits and don't take up much space.
  • Annotated - stored as objects; they contain tagger's name, date, message, they can be signed and valued.
    Examples of creating lightweight tags:
  1. git tag v0.1
  2. git tag v1.0-rls
  3. git tag v2.4.1

    Examples of creating annotated tags:
  1. git tag -a v1.5 -m "here comes a mandatory message for the tag"
  2. git tag -a v1.5.1 - after that command with no message body provided,
                                                Git will open an editor
    If you want to see a detailed information on an annotated tag, then git show should run:

           git show v1.5
          
    The function will display the following metadata:
    tag v1.5
    Tagger: Vlad Rozin <vlad.rozin@example.com>
    Date:   Sun Jan 27 10:10:00 2019 -0700

    my version 1.5

    commit fd10a5aaa817ec66f44789001618690a93761618
    Author: Mike Tyson <mike.tyson@example.com>
    Date:   Mon Jan 28 01:52:11 2019 -0700

        changed the version number


Comments

Post a Comment

Popular posts from this blog

penguingV Enhancement

Good ol' C++ and Image Processing     The issue that was listed in penguinV 's repository asks for a slight improvement on their already implemented EdgeDetection()  algorithm, which currently works with double  values. The improvement must template the algorithm so the work can be done with 'float's as well.     Well, templating the class with all of its methods is not that hard, separating headers ( .h ) from implementation ( .cpp ) of a templated class is not that tricky (by the way, I have recently found a beautiful tutorial on how it can bee done in 3(!) different ways), but making sure that at the time of comparison/assignment of a double  to int  (and vise-versa) the data won't be truncated because of differences in bit sizes - that can be a bit time-consuming. As of now, the algorithm uses uint32_t  (unsigned 32-bit integer) as its integer type to be able to hold/pass data from/to double  variables (truncating decimals, obviously), but with switch to f
Read more

Two Different Frames of Same VidioCapture

Image
OpenCV Challenge     I believe, this bug is going to be one of the most challenging I have worked on. Not because of complexity of the work, not because of the scale involved, but because the part of the code is brand new to me. STDMETHODIMP SourceReaderCB::OnReadSample(HRESULT hrStatus, DWORD dwStreamIndex, DWORD dwStreamFlags, LONGLONG llTimestamp, IMFSample *pSample) {     CV_UNUSED(llTimestamp);     HRESULT hr = 0;     cv::AutoLock lock(m_mutex);     if (SUCCEEDED(hrStatus))     {         if (pSample)                     CV_LOG_DEBUG(NULL, "videoio(MSMF): got frame at " << llTimestamp);             IMFSample* prev = m_lastSample.Get();             if (prev)             {                 CV_LOG_DEBUG(NULL, "videoio(MSMF): drop frame (not processed)");             }             m_lastSample = pSample;         }     }     else     {         CV_LOG_WARNING(NULL, "videoio(MSMF): OnReadSample() is called with error status: "
Read more

Node.js: fs.open()

    Today, I would like to take a look at one of the widely used functions of Node.js ' fs  library -  open() , and its synchronous version -  openSync() .     The function's purpose is to open a file, specified by a path (the first mandatory parameter of the function). The code of the function is following ( source ): function open(path, flags, mode, callback) {   path = toPathIfFileURL(path);   validatePath(path);   if (arguments.length < 3) {     callback = flags;     flags = 'r';     mode = 0o666;   } else if (typeof mode === 'function') {     callback = mode;     mode = 0o666;   }   const flagsNumber = stringToFlags(flags);   if (arguments.length >= 4) {     mode = validateMode(mode, 'mode', 0o666);   }   callback = makeCallback(callback);   const req = new FSReqCallback();   req.oncomplete = callback;   binding.open(pathModule.toNamespacedPath(path),                flagsNumber,                mode,                re
Read more