1. Git configuration

• Git config
  Get and set configuration variables that control all facets of how Git looks and operates.
  Set the name:
  $ git config --global user.name 'User name'
  Set the email:
  $ git config --global user.email 'himanshudubey481@gmail.com'
  Set the default editor:
  $ git config --global core.editor Vim
  Check the setting:
  $ git config -list
• Git alias
  Set up an alias for each command:
  $ git config --global alias.co checkout
  $ git config --global alias.br branch
  $ git config --global alias.ci commit
  $ git config --global alias.st status

2. Starting a project

• Git init
  Create a local repository:
  $ git init
• Git clone
  Make a local copy of the server repository.
  $ git clone

3. Local changes

• Git add
  Add a file to staging (Index) area:
  $ git add Filename
  Add all files of a repo to staging (Index) area:
  $ git add*
• Git commit
  Record or snapshots the file permanently in the version history with a message.
  $ git commit -m ' Commit Message'

4. Track changes

• Git diff
  Track the changes that have not been staged: $ git diff
  Track the changes that have staged but not committed:
  $ git diff --staged
  Track the changes after committing a file:
  $ git diff HEAD
  Track the changes between two commits:
  $ git diff Git Diff Branches:
  $ git diff List Branch:
  $ git branch --list Delete a Branch:
  $ git branch -d Rename Branch:
  $ git branch -m
• Git checkout
  Switch between branches in a repository.
  Switch to a particular branch:
  $ git checkout
  Create a new branch and switch to it:
  $ git checkout -b Checkout a Remote branch:
  $ git checkout
• Git stash
  Switch branches without committing the current branch. Stash current work:
  $ git stash
  Saving stashes with a message:
  $ git stash save ' Check the stored stashes:
  $ git stash list
  Re-apply the changes that you just stashed:
  $ git stash apply
  Track the stashes and their changes:
  $ git stash show
  Re-apply the previous commits:
  $ git stash pop
  Delete a most recent stash from the queue:
  $ git stash drop
  Delete all the available stashes at once:
  $ git stash clear
  Stash work on a separate branch:
  $ git stash branch
• Git cherry pic
  Apply the changes introduced by some existing commit:
  $ git cherry-pick

8. Merging

• Git merge
  Merge the branches:
  $ git merge
  Continue the rebasing process:
  $ git rebase -continue Abort the rebasing process:
  $ git rebase --skip
• Git interactive rebase
  Allow various operations like edit, rewrite, reorder, and more on existing commits.
  $ git rebase -i

9. Remote

• Git remote
  Check the configuration of the remote server:
  $ git remote -v
  Add a remote for the repository:
  $ git remote add Fetch the data from the remote server:
  $ git fetch
  Remove a remote connection from the repository:
  $ git remote rm
  Rename remote server:
  $ git remote rename
  Show additional information about a particular remote:
  $ git remote show
  Change remote:
  $ git remote set-url
• Git origin master
  Push data to the remote server:
  $ git push origin master Pull data from remote server:
  $ git pull origin master

10. Pushing Updates

• Git push
  Transfer the commits from your local repository to a remote server. Push data to the remote server:
  $ git push origin master Force push data:
  $ git push -f
  Delete a remote branch by push command:
  $ git push origin -delete edited

11. Pulling updates

• Git pull
  Pull the data from the server:
  $ git pull origin master
  Pull a remote branch:
  $ git pull
• Git fetch
  Download branches and tags from one or more repositories. Fetch the remote repository:
  $ git fetch< repository Url> Fetch a specific branch:
  $ git fetch

  Cheat sheets are sets of concise graphical and textual explanations, inspired by infographics, data comics, and cheat sheets in other domains. Cheat sheets aim to support learning, teaching, and the regular use of both common and novel visualization techniques in a variety of contexts. To design cheat sheets for visualization techniques, we describe six components of a cheat sheet: anatomy, build-up, visual patterns, pitfalls, false-friends, variations. We present examples for several visualization techniques, created through an iterative design process which involved data science and visualization teachers, visual designers and students. In a qualitative and iterative user study, we gather subjective feedback from participants, show readability and usefulness of our cheat sheets, and iterated on their design. We bring this together as a design methodology, with a comprehensive design framework to easily create cheat sheets for additional visualizations.

  Anatomy

  Anatomy explains the visual elements of a visualization technique, their composition, their specific terminology, and how they relate to the data. The visual components of a visualization can include individual visual marks as well as groups of marks, axes, locations in a visualization etc.

  Construction

  A Construction explains the conceptual idea behind a visualization design and how a visualization is encoding data. We chose that term to highlight the step-wise explanation used to understand a visual mapping, i.e. the transformation from data to visualization. The goal of the construction, on the other side, are twofold: (a) to provide a procedural explanation of a visualization design, (b) to deliver a blue-print for how to explain the visualization to a larger audience.

  Visual Patterns

  Visual patternssheet provide a catalogue of meaningful patterns visible in a visualization. Patterns are key in correctly interpreting visualizations and makingdiscoveries. A visual pattern can be any sort of configuration inthe visualization with a specific meaning.

  Pitfalls

  Github Cheat Sheet Reddit

  

  Pitfalls show possible misinterpretations of a visualization. While there is a long list of technique independent pitfalls.

  Github Commands Cheat Sheet

  Well-known Relative

  The “well-known relative” relates an unknown visualization to a more familiar one used to visualize the same data.

  False Friends

  Github Actions Cheat Sheet

  False-friendslists visualization techniques that are visually similar but functionally different. For example, boxplots share visualsimilarities with candlestick charts and error bars in bar chars; parallel coordinates can look similar to line charts, time curvescan look similar to connected scatter plots.