• Collaborating
• Saving various versions of code
• Not affecting the original code by making branches that can be connect to the main at the end

Here are some basic things I learnt to do from the terminal:

Creating Repository

git:master instead of git:main

Incorrect Credentials

• On GitHub there are the steps to take to create a new git repository from the command line (don't forget you still have to create one on GitHub).

  git init

  • this will make your local folder into a git repository
  • Important to note: this for some reason gave me git:master branch instead of the updated git:main. If this happens to you to, go to the next tab on how to troubleshoot!
  Continuing on:

  git commit -m “first commit”
  git branch -M main
  git remote add origin https://github.com/username/repositoryname.git
  git push -u origin main

• 1. First, you must remove .git from your local repository:

     rm -rf .git

  2. Next, make sure your git version is up to date:

     git –version

     If it is not (and you have homebrew):

     brew install git

     Check version again. If you do not have the correct version (something that ends with “(Apple Git-...)”) on an MacOS, you might have to manually set your path. So try:

     export PATH=/usr/local/bin:$PATH

     Now you should have the correct version!
     
     Future updates to git can be done with:

     brew upgrade git

  3. Now you can change the global configuration to make the default branch main:

     git config --global init.defaultBranch main

  4. Now when you run:

     git init

     you should see that you are on the “main” branch instead of “master”!

• I had a problem with connecting with my GitHub from my terminal due to incorrect credentials. This stack overflow article helped!
  
  First I actually wanted to check out what the credentials I had were:

  git config --global --edit

  My name and email also happened to be incorrect, so I set them up using:

  git commit --amend --reset-author

  I had initially had the wrong credentials typed in so first I had to remove the username and password it had:

  git config --global --unset user.password

  Before, I did “git push” I used the following code to store the credentials for future uses (only on Macbook):

  git config --global credential.helper osxkeychain ()

  Now when you do git config --global --edit, you should see:
  

  **Update: GitHub implemented personal tokens, so to set it up go to Personal Token Setup.
  From there all you have to do is enter your personal token instead of a password. Don’t forget that they expire and you will have to update them every so often.

• Pushing up local repository to GitHub
  GitHub has a great way of explaining the steps:

  1. On GitHub: Create a new repository with no initialization (no added files)
  2. In the terminal, within the working directory:

     git init -b main

  3. Now you need to add the files:

     git add .

  4. Now commit the changes:

     git commit -m "Write commit message"

  5. Get URL of GitHub's repository: Then in your terminal:

     git remote add origin URL

     This sets the remote connection
  6. To verify that the connection was done well:

     git remote -v

     Your two lines should be the same, e.g. of output

     origin https://github.com/anjawu/test.git (fetch)
     origin https://github.com/anjawu/test.git (push)

  7. Now push the changes to finish:

     git push -u origin main

• Downloading the repository from GitHub
  1. On GitHub: go to the repository: click the green button “Code”
     
  2. Copy the HTTPS writing and in your local terminal type

     git clone HTTPSname

  3. Now you have the repository on your local machine
• Changing name of document in terminal and pushing up to GitHub
  1. Creating a branch on terminal (make sure you are in the correct repository in your terminal)

     git checkout -b pick-specific-branch-name

  2. Checking which branch you are working on, what changes have been made to what files

     git status

  3. To list all branches within the repository

     git branch

  4. To change name of file

     git mv old-name new-name

     You can also use mv to move your file to a new folder by specifying the file path instead of a name change. (using absolute file path)

     git mv file-name /location/new-name

  5. Save changes to branch locally: -m allowing you to write a commit message without going into a text editor

     git commit -m “message about commit”

  6. To push change to GitHub

     git push origin branch-name

  7. Go to GitHub to the repo you are working with and click “compare & pull request”
  8. Check over your branch, if it looks good: click “create pull request”
  9. Click “merge pull request” and “confirm merge”
  10. Once the merge is successful, to keep your repo looking clean: delete the old branch on GitHub
• Adding code with a branch and putting reviewer on code
  1. Download the repository from GitHub
  2. Put working code in repository on local drive
  3. git status should output:
  4. Next, we want to make a branch to commit/upload to GitHub. We will give this branch the name “initial-working-script” since I have working code for my costco deal hunter.

     git checkout -b "initial-working-script"

  5. Now making sure that we are on the branch (o my zsh is great because it has a different colour when you are on a github repository and it tells you which branch you are working off of), we want to add the python file.
  6. Now when we check the status, we should see that it is ready to be committed.
  7. Next, we want to commit this change with a message talking about the commit. In this case, since I am unloading a full working model, I will describe what my app does.

     git commit -m 'first working version of using selenium to enter postal code and grab coupons in a pandas dataframe, checking for savings that match a keyword, saving result to .csv'

  8. Now that all the changes are committed, we can push up the changes to the main branch

     git push origin initial-working-script

  9. Go to GitHub to the repo you are working with and click “compare & pull request”
  10. Check over your branch, if it looks good: click “create pull request”
  11. Click add reviewers (remember your reviewers must be collaborators on the project)
• Uploading code to GitHub
  1. Create a repository on GitHub and name it (in this case I will be doing a website): websitename.github.io
  2. In your terminal clone the repository in the correct location on your desktop:

     git clone “https://...”

  3. If you have already made the website documents, you can copy the files into the new repository you have made.
  4. Once you are in the correct folder in your terminal, make a branch:

     git checkout -b “first-working-version”

  5. Then add all the documents you want pushed to GitHub:

     git add .

     If there are certain documents that you have added but do not want to push up, you can remove by:

     git rm --cached file_name

     OR by unstaging:

     git restore --staged file_name

  6. Now we are able to commit what we want to do to the branch we are currently working on:

     git commit -m “first working version of website”

  7. After we have committed the change, we want to push it up:

     git push origin first-working-version

  8. On GitHub, we want to:
     • create the pull request
     • merge pull request
     • confirm merge
     • delete branch
  9. Then back to the terminal. Since we are done with the branch, we want to leave the branch and get to main:

     git checkout main

  10. You need to update your local main branch to match the GitHub one:

      git pull origin main

• Changing website domain on GitHub
  1. On your website (username.github.io) repository: go to settings → pages → header “Custom domain”.
  2. Enter the website domain you have (mine is anjawu.com) and click save. It should look like this:
  3. When you are done, go back to your code and you should now see a file called “CNAME”. When you open your CNAME file it should just say your website domain:
  4. Once you have done that, go to the site where you have your DNS (where you bought your domain and created an account to house it). I used GoDaddy, so I will outline the steps for that.
  5. On your domain, go to header “Additional Settings” and click the subheader that says “Manage DNS”.
  6. On the new page, under records, click “add”.
  7. Since my website is an apex domain (because it is just anjawu.com), I need to add an “A” record.
     Here you need to point from Host: “@” to Points to “IP address found on this GitHub page on step 5”: This is what it should look like once inputted: Please note, if you already have something that looks like this on your record, just check to make sure that the IP address it points to is one off of the GitHub list.
  8. Next, we want to add "www”, we can do this by: click “add” → CNAME → Host “www” and Points to “username.github.io”. So it would look like this:
  9. Finally, you should have something that looks like this on GoDaddy’s DNS:
  10. Give your webpage a chance to load and connect and it should work. Sometimes it can take up to 24 hours.
• Automatically Deleting Branch

  In order in speed up merging changes, GitHub allows you to remove having to manually delete branch after each merge confirmation.

  1. Open settings for specific repository (Note: you must do this procedure for each repository you want to remove requirement of deleting branches)
  2. Under General section, scroll until "Merge button" section
  3. Go to section that says:
     "After pull requests are merged, you can have head branches deleted automatically."
     Select the checkbox that says:
     "Automatically delete head branches
     Deleted branches will still be able to be restored."
  
  

  Now you should be good to go about your business without having to delete the merged branches.