Introduction to Git and GitHub https://www.coursera.org/learn/introduction-git-github/

Introduction to Git and GitHub

https://www.coursera.org/learn/introduction-git-github/

On top of search results, here are some great Git resources available online:

• Pro Git: This book (available online and in print) covers all the fundamentals of how Git works and how to use it. Refer to it if you want to learn more about the subjects that we cover throughout the course.

• Git tutorial: This tutorial includes a very brief reference of all Git commands available. You can use it to quickly review the commands that you need to use.

• 
  

WEEK NO 1 Intro to Module 1: Version Control

First I have to install Git in each computer???????????!!!!!!!!!!!!

https://git-scm.com/download/win

Instead of new coding we must use the previous codes and extend/add  functions/codes because previous codes are alrady tested from bugs and are debugged . 

in VCS/Git there are two main utilities  DIFFand PATCH

After installatin of GIT we can track the changes in codes.

Week 1 What is version control?  video 1

https://www.coursera.org/learn/introduction-git-github/lecture/SxXDq/what-is-version-control

Question

What does a version control system do?

It groups all related code.

It explains why a change was made.

It keeps track of changes we do to our files.

It prevents us from changing files by mistake.

Correct

Spot on! By keeping track of the changes that we make to our files, a VCS lets us know

1. when a file changed,

2. who changed it, and also

3. lets us easily roll back those changes.

Week 1  Version Control and Automation  V2

VCS is needed and valuable is there only One developer in team

It stores and save history of software.

it store history of code and configuration s

As it keeps the history of configuratgion files you  may REVERT back code/configuration

which ever was system/software working in a good state

This will enhance the reiablity of the syste

Question

Why is a version control system useful, even if it's used only by a single person? Check all that apply.

Seeing the history of the changes helps us understand what changed and why.

Correct

You got it! One of the main benefits of a VCS is that you can see the history of how files changed and understand what changed at each step and what motivated the change.

Tracking code in a VCS ensures that it's bug free.

Tracking changes allows for easy rollbacks when a problem is detected.

Correct

Right on! By having each change tracked in the VCS, it's very easy to go back to previous versions when an issue with a change is discovered.

Storing files in a VCS avoids the need for any kind of backups.

Week 1 What is Git?  V3

Question

What characteristics make Git particularly powerful? Check all that apply.

It was created by Linus Torvalds in 2005.

It's a distributed VCS, which means that each developer has a full copy of the repository.

Correct

You nailed it! Because each contributor to a Git repo has a full copy of the repository, they can interact with the tracked files without needing a coordinating server. In turn, this improves collaboration.

It's maintained by a team of distributed developers.

This should not be selected

Not quite. While it’s true that Git is maintained by a team of many developers distributed around the world, the power of Git lies in how it's a distributed version control system that can be used by as many developers as needed.

Repositories can be used by as many developers as needed.

Correct

Right on! Because of the way Git was designed, repositories can be useful for any number of developers, from one to thousands.

$ git config --global core.editor "'C:/Program Files/Notepad++/notepad++.exe' -multiInst -notabbar -nosession -noPlugin"

Week 1  Installing Git

https://www.coursera.org/learn/introduction-git-github/quiz/2kyMm/practice-quiz-version-control-systems/view-attempt

Practice Quiz: Version Control Systems

Question 1

How can a VCS (Version Control System) come in handy when updating your software, even if you’re a solo programmer? Check all that apply.

Git retains local copies of repositories, resulting in fast operations.

Correct

Awesome! Git's distributed architecture means each person contributing to a repository retains a full copy of the repository locally.

If something breaks due to a change, you can fix the problem by reverting to a working version before the change.

Correct

Nice job! With version control, if something goes wrong, we can fix it immediately and figure out what happened later.

Git relies on a centralized server.

Git allows you to review the history of your project.

Correct

Right on!

Question 3 _____ is a feature of a software management system that records changes to a file or set of files over time so that you can recall specific versions later.

A repository

sys.exit()

Version control

IDE

Correct

Right on! A version control system keeps track of the changes that we make to our files.

Week 1 Using Git   Video: VideoFirst Steps with Git

How things are ordgnaised and 

how files are tracked

$ git config command

$ git config --global user.name 'SAEED HASSAN'

$ git config --global user.email 'saeedhisbani@yahoo.co.uk:

--global means set  user anem and email address for ALL REPOSITORORIES

You may also set the user name email address for each repositories separately

There are two ways to start working with repositoryries 

        1.  Making repo from scratch use $ git init command

        2. Or making the copy existing repo use $ git clone command  

$ git init

Reinitialized existing Git repository in C:/Users/AL Abbas/trial/.git/

$ ls -al

$ ls -al .git

do not touch any file directly. Always interact with them through Git commands

This is GIT DIRECTOY  it store changign history

When ever CLONE repo from remote to local computer this .git Dir will copying from remote to your local computer 

when ever you execute commadn $ git init it create the .git dir

The area ouside the .git dir is WORKING TREE

WORING TREE = CURRENT VERSION OF PROJECTY

Question

What are the git directory and the working tree?

The git directory stores configuration settings and the working tree stores the history of the files.

The git directory is copied to the computer and the working tree stays in the remote repository.

The git directory is a sandbox for changing the files and the working tree contains old versions of the files.

The git directory contains all the changes and their history and the working tree contains the current versions of the files.

Correct

Awesome! The git directory acts as a database for all the changes tracked in Git and the working tree acts as a sandbox where we can edit the current versions of the files

first found a file dis_usage.py from internet

$ cp disk_usage.py checks

$ git init 

$ git add disk_usage.py  to  transfer file From untraking to Stage Area 

STAGGING AREA = INDEX  AREA

$ git add disk_usage.py

$ git commit   && this will open editor where we add a line describing why we are committing

Week 1  Using GIT==> Tracking Files

https://www.coursera.org/learn/introduction-git-github/lecture/CO6OR/tracking-files

Each time you $ git commit 

Then 

Git records new snapshot of current state of the project  at that moment

then that snapshot is kept with history of previous  snapshots 

Question

What do we need to do after modifying a file tracked by Git?

We need to stage the file, so that the changes will be included in the next commit.

We need to commit the file, so that the changes will become part of the staging area.

We need to add the file to the Git directory.

We need to change to a different working tree.

Correct

You nailed it! After modifying a file, we need to stage those changes and then commit them afterwards.

Week 1 using git --> The Basic Git Workflow

$ git config -l

diff.astextplain.textconv=astextplain

filter.lfs.clean=git-lfs clean -- %f

filter.lfs.smudge=git-lfs smudge -- %f

filter.lfs.process=git-lfs filter-process

filter.lfs.required=true

http.sslbackend=openssl

http.sslcainfo=C:/Program Files/Git/mingw64/etc/ssl/certs/ca-bundle.crt

core.autocrlf=true

core.fscache=true

core.symlinks=false

pull.rebase=false

credential.helper=manager

credential.https://dev.azure.com.usehttppath=true

init.defaultbranch=master

user.email=saeedhisbani@yahoo.co.uk

user.name=SAEED

use.name=Saeed Hassan

Question

When committing new files or changes with git commit, the user is asked to provide a commit message. What will happen if an empty commit message is entered?

It will make it difficult to track bugs without commit messages.

The info shown with the git log command will show no commit message.

The commit will be aborted.

The commit will ignore untracked files or files that weren't staged.

Correct

Nice work! You can’t commit with an empty commit message.

Week 1 Using Git->Anatomy of a Commit Message

https://www.coursera.org/learn/introduction-git-github/lecture/mhymc/anatomy-of-a-commit-message

Commit message must be very clearly menttioned why code was modified. First line must be perci/short

IInd line must be BLANK  then full description as bellow

After even some years later even any other porgrammer can understand.  It clearly mentioned what were bug and issues were resolved and How?

Question

What should your commit message look like?

A jumble of words

A description of no more than 50 characters

A short description of the change (up to 50 characters), followed by one or more paragraphs giving more details of the change (if needed).

Always write as much as you can about the changes.

Correct

Awesome! You want your message to contain all relevant information without being confusing.

Initial Git Cheat Sheet

Check out the following links for more information:

The Linux kernel documentation itself, as well as impassioned opinions from other developers. 

You can check out "Setting your email in Git" and "Keeping your email address private" on the GitHub help site for how to do this.

5 Useful Tips For A Better Commit Message

https://thoughtbot.com/blog/5-useful-tips-for-a-better-commit-message

Congratulations! You passed!

Grade received 100%

To pass 80% or higher

1.

Question 1

Before changes in new files can be added to the Git directory, what command will tell Git to track our file in the list of changes to be committed?

1 / 1 point

git status

git add

git commit

git init

Correct

Right on! git add will add a file to the staging area and mark it for tracking.

2.

Question 2

Which command would we use to review the commit history for our project?

1 / 1 point

git clone

git status

git config -l

git log

Correct

Awesome! git log will give us information about the author of each commit, its timestamp, and each commit message.

3.

Question 3

What command would we use to make Git track our file?

1 / 1 point

git clone

git status

git add

git log

Correct

Great work! git add is used to make git mark our file as tracked.

4.

Question 4

Which command would we use to look at our config?

1 / 1 point

git clone

git status

git config -l

git log

Correct

Great work! git config -l is used to check the current user configuration.

5.

Question 5

Which command would we use to view pending changes?

1 / 1 point

git clone

git status

git config -l

git log

Correct

WoLAB ohoo! git status is used to retrieve information about changes waiting to be committed.

LAB

Install Git To refresh index of the packages available

$ sudo apt update

$ sudo apt install git

$ git --version

$ mkdir my-git-repo

$ cd my-git-repo

$ git init

$ git config --global user.name 'SAEED HASSAN'

$git config --global user.email 'saeedhisbani@yahoo.co.uk'

$ nano REAME

write in file This is my first repository  then save the file

$ git status

Showing README file is UNTRACKING status

$ git status

$ git commit 

Then automatically nano editor will open  where write 

This is my first commit!

$ nano README

Add another line

        A repository is a location where all the files of a particular                 project  are stored.

$ git status

$ git diff  README

$ git add README

$ git status

$ git commit -m 'This is my second commit'

$ git log

This The End of Lab

=============================================

Week 2  Advanced Git interactio-->Skipping the Staging Area

    Only tracking files can be skipped from staging area.

Whe modify any already Tracking file can skip staging areaby command

$ git commit -a -m 'Skipped stagged area'

$ git commit  -a = $ git add + $ git commit

Question

If we're making a small change and want to skip the staging step, which two flags do we need to add to the git commit command? Check all that apply.

-m

Correct

Right on! The -m flag allows us to directly add the commit message to the command.

-t

-l

-a

Correct

Awesome! The -a flag lets us add and commit in the same step.

HEAD is pointer to current sanpshot (snapshot is taken by $ git commit command)

Week 2 Advanced Git interaction-->Getting More Information About Our Changes

https://www.coursera.org/learn/introduction-git-github/lecture/KLQkB/getting-more-information-about-our-changes

To see in history changes difference

$ git log -p

By using $ git log -p youmay track the changes done history of fles

if you want to see only one commit status

$ git show <commit  id>

$ git show  05e89a3ca954f0fd3c3906406bc168fe5a6f97d7

 

Another command

$ git log  --stat it show how many line added or subtracted 
 

Question

If we want to see a specific commit, which command would we use along with the commit ID?

git log --stat

git show <commit id>

git log -p

git commit -am

Correct

You nailed it! Taking the commit ID, git show will show information about the commit and its associated patch. 

$ git diff

show difference b/w last commit file and newly modified file

$ git add -p 

This command will show difference b/w previous committed file currently modified file like $ git diff and then prompt us to weather to <stage> it or to  <discard> its changes or simply <quit> the command as uder

(1/1) Stage this hunk [y,n,q,a,d,s,e,?]?

If modified files are more then git will ask same question for each file separately

Warning we must not perss <q> it will abord command it means it will NOT  ask question for other files once we abord it by pressing <q>

Remember that above command is about for modified and stage difference 

modified tracked file->stagged-->commit

According to above Question sked we may press <d>  for discard cahnges

After if changes are stagged the command 

$ git diff will not show you anything

To seethe difference of after the changes are Stagged  run

$ git diff --staged

Week 2 Undoing Things-->Undoing Changes Before Committing

Question

What is the purpose of the git checkout command?

It finalizes staged changes.

It reverts changes to modified files before they are staged.

It skips staging and directly commits.

It displays the current status of the commit.

Correct

Right on! git checkout restores files to the latest stored snapshot, reverting any changes before staging.

To restore file in modified area But still these  file s are not staged

Warning: Thsi command will loss the data/codes permanenty this is very dangerous command.

So you must copy the file before running the this command $ git restore <f>

$ git restore  <file >

To restore changes in stage area

$ git restore --staged <file>

see as under

can not understand following command 

$ git rest  HEAD  <file> as unders

ANSWER:

To unstage a file, git reset HEAD <file> and git restore --staged <file> are the same. For the other differences, see the manual git-scm.com/docs/git-reset and git-scm.com/docs/git-restore. 

–

Week 2  Undoing Things-->Rollbacks

$ git revert HEAD to revert last commit

1. Week 2
2. Undoing Things-->Identifying a Commit

$ git show <commit ID> | <6 char of commit ID>

To revert the code at particular commit id  use commadn

$ got revert <commit id>

Question

Which of the following is NOT true about the SHA1 hash numbers that Git uses to identify commits?

They provide the consistency that is critical for distributed systems such as Git.

They are created using the commit message, date, author, and the snapshot taken of the working tree.

Git requires the entire hash ID to identify a commit.

They are composed of 40 characters.

Correct

You nailed it! Git can identify a commit using the first few hash numbers as long as there is only one matching possibility.

1.

Question 1

Let's say we've made a mistake in our latest commit to a public branch. Which of the following commands is the best option for fixing our mistake?

0 / 1 point

git revert

git commit --amend

git reset

git checkout -- <file>

Incorrect

Not quite. Similarly to resetting a commit, this command entirely replaces the commit. In a public repository, this may cause confusion for other developers.

2.

Question 2

If we want to rollback a commit on a public branch that wasn't the most recent one using the revert command, what must we do?

1 / 1 point

Use the git reset HEAD~2 command instead of revert

Use the revert command repeatedly until we've reached the one we want

use the commit ID at the end of the git revert command

Use the git commit --amend command instead

Correct

Nice work! The commit ID is a 40-character hash that identifies each commit.

3.

Question 3

What does Git use cryptographic hash keys for?

1 / 1 point

To secure project backups

To guarantee the consistency of our repository

To encrypt passwords

To identify commits

Correct

Woohoo! Git doesn't really use these hashes for security. Instead, they’re used to guarantee the consistency of our repository.

4.

Question 4

What does the command git commit --amend do?

1 / 1 point

Start a new branch

Create a copy of the previous commit

Delete the previous commit

Overwrite the previous commit

Correct

Awesome! The command git commit --amend will overwrite the previous commit with what is already in the staging area.

5.

Question 5

How can we easily view the log message and diff output the last commit if we don't know the commit ID?

1 / 1 point

git show

git identify

git log

git revert

Correct

Right on! The git show command without an object parameter specified  will default to show us information about the commit pointed to by the HEAD.

1. Week 2
2. What is a branch?

it represents 

an independent line of development in a project. 

Of which the commit it points to is 

the latest link in a chain of developing history. 

Question

What is the purpose of organizing repositories into branches?

To enable changes to be worked on without disrupting the most current working state.

To make it easier to undo commits.

To enable changes to the repository to permanently replace previous commits.

To give users a place to keep notes.

Correct

Awesome! By creating a new branch, we can experiment without breaking what already works (work in main/master branch).

Week 2

Creating New Branches

To chreate new branch

$ git branch newbranch

To switch newbranch

$ git checkout newbranch

means by suing $ git branch <arg according to requirments>

Createing newbranch and switch to that newbranch with cone command

$ git CHECKOUT  -b newbranch2

N.B.  not use $ git branch here

Week 2  Merging

Question

What happens when we merge two branches?

The HEAD points at the master branch.

Both branches are pointed at the same commit.

One of the former branches disappears.

Two independent snapshots will now share the same name.

Correct

Awesome! Merging combines branched data and history together.

if we are currenty in master branch to merge newbranch in master

$ git merge <newbranch>

any branch possession/ownership/preoperty is only commited file  not any file in modified or stagged areaor untracked file

very very hard and gand phar topic

@) you can create any new branch utill and less you  made a new repository

New repo.. is created after first commit on new branch 

 In newly created  git dir first your have to commit a file in master branch then you may add branched i new brancheds  in that master branch

@)when new branch is created  under master branch

then all the commit ed files in  master branch will be committed in new branch you can see the files list  in $ ls -l command

Fast Farworrd Merge:

            A simple merge. When all the commit s in checkout branch (master) same as the branch is being merged (new branch) 1 or more additional committed files mayu occure in newbranch. 

after command  at master arbranch

$ git merge <newBranch>

All the new additional newBranch committed files  will be added in master branch  as committed files. see as under

Week 2 Branching and Merging --> Merge Conflicts

Question

What's the advantage of Git throwing a merge conflict error in cases of overlap?

It prevents loss of work if two lines overlap.

It helps us understand which changes to keep.

It warns us of all potential problems.

It tells us whether the commit is a merge

Correct

Nice job! If two lines have differences Git is unsure about, it's best we decide than risk losing work forever.

$ git merge --abort

This will stop the merge and reset the files in your working tree back to the previous commit before the merge ever happened

Git Branches and Merging Cheat Sheet

Command	Explanation & Link
git branch	Used to manage branches
git branch <name>	Creates the branch
git branch -d <name>	Deletes the branch
git branch -D <name>	Forcibly deletes the branch
git checkout <branch>	Switches to a branch.
git checkout -b <branch>	Creates a new branch and switches to it.
git merge <branch>	Merge joins branches together.
git merge --abort	If there are merge conflicts (meaning files are incompatible), --abort can be used to abort the merge action.
git log --graph --oneline	This shows a summarized view of the commit history for a repo.

Congratulations! You passed!

Grade received 100%

To pass 80% or higher

1.

Question 1

When we merge two branches, one of two algorithms is used. If the branches have diverged, which algorithm is used?

1 / 1 point

three-way merge

fast-forward merge

merge conflict

orphan-creating merge

Correct

Excellent! A three-way-mergeoccurs when the two commits have diverged previously, and a new commit is created.

2.

Question 2

The following code snippet represents the result of a merge conflict. Edit the code to fix the conflict and keep the version represented by the current branch.

1 / 1 point

1

print("Keep me!")

Keep me!

Correct

You got it! No more conflicts here!

3.

Question 3

What command would we use to throw away a merge, and start over?

1 / 1 point

git checkout -b <branch>

git merge --abort

git log --graph --oneline

git branch -D <name>

Correct

Right on! If there are merge conflicts, the --abort flag can be used to abort the merge action.

4.

Question 4

How do we display a summarized view of the commit history for a repo, showing one line per commit?

1 / 1 point

git log --format=short

git branch -D <name>

git log --graph --oneline

git checkout -b <branch>

Correct

Awesome! The commandgit log --graph --oneline shows a summarized view of the commit history for a repo.

5.

Question 5

The following script contains the result of a merge conflict. Edit the code to fix the conflict, so that both versions are included.

1 / 1 point

1

2

3

4

5

def main():

    print("Start of program>>>>>>>")

    print("End of program!")

 

main()

Start of program>>>>>>>
End of program!
Start of program>>>>>>>
End of program!
None

Correct

Great work! Now the code has both versions without any
conflicts!

Week 3 What is GitHub?

Question

Which BEST describes GitHub?

A distributed Version Control System (VCS)

A Software Configuration Management system (SCM)

A remote repository hosting service for Git

A wiki site for Git users

Correct

Nice job! GitHub provides free access to a Git server for public and private repositories.

Week 3 Basic Interaction with GitHub

Question

After making changes to our local repository, how do we update the remote repository to reflect our changes?

Use the git clone command to clone the repository to the server.

Use the $ git push command to send snapshots to the remote repository.

Upload a README.md file with Markdown.

Use the Create a repository form on the website

Correct

Awesome! The git push command gathers all the snapshots we've taken and sends them to the remote repository.

To avoid to enter the password again and again during pull or push  use command

$ git config --global credential.helper cached

I think this command is already enabled

Question 1

When we want to update our local repository to reflect changes made in the remote repository, which command would we use?

git clone <URL>

git push

git pull

git commit -a -m

Correct

Right on! git pull updates the local repository by applying changes made in the remote repository.

Question 2

git config --global credential.helper cache allows us to configure the credential helper, which is used for ...what?

Troubleshooting the login process

Dynamically suggesting commit messages

Allowing configuration of automatic repository pulling

Allowing automated login to GitHub

Correct

Nice work! By configuring the credential helper, we can avoid having to type in our username and password repeatedly.

Question 3

Name two ways to avoid having to enter our password when retrieving and when pushing changes to the repo. (Check all that apply)

Implement a post-receive hook

Use a credential helper

Correct

Awesome! The credential helper caches our credentials for a time window, so that we don't need to enter our password with every interaction.

Create an SSH key-pair

Correct

Great job! We can create an SSH key-pair and store the public key in our profile, so that GitHub recognizes our computer.

Use the git commit -a -m command.

Week 3 What is a remote?

Question

What will happen if the master repository receives a major update since the last local copy was synced?

Git will push your local copy.

Nothing will happen.

Git will let you know it's time for an update.

Git will automatically merge the local copy with the master.

Correct

Great job! If there are pending changes in the master branch, Git will let you know.

Git will not synchronize automatically

Week 3 Working with Remotes

$ git remote -v

$ git remote show origin 

Week 3

Working with Remotes

Question

If we want to make a change to a remote branch, what must we do?

Directly make the change

Use the git branch -r command

Pull the remote branch, merge it with the local branch,

then push it back to its origin.

Use the git remote -v command

Correct

Excellent! We still have to go through the normal workflow to change remote branches.

$ git branch

command is used see list of  local branches in local repository

$ git branch -r 

command is use to see list of REMOTE BRANCHES

Week 3 Fetching New Changes

Question

What’s the main difference between git fetch and git pull?

git fetch fetches remote updates but doesn't merge; git pull fetches remote updates and merges.

git pull fetches remote updates but doesn't merge, while git fetch does.

git fetch clones the entire repository.

git pull requires a password while git fetch doesn't.

Correct

Nice job! git pull instantly merges while git fetch only retrieves remote updates.

See Remote master branch as origin/master and locaal master branch as HEAD-->mastrer

Some chnage made in github.com and in my local home computer and commit both at their plalaces then in local hame computer i give command

$ git push

In keeping view to CHECK is git and github.com allowing me to OVERWRITE MY changes means changes from local repo to remote repo Overwritten or not 

Then I command my local computer

$ git pull

I got CONFICT  message to resolve it my local computer then 

I have $ git push to SYNCHRONIZE local and remote repo means to synchronize my local repo with github.com repo

Week 3

Updating the Local Repository

Question

Assuming no merge conflicts, which type of merge does git pull perform automatically?

Three-way merge

Explicit merge

Fast-forward merge

Half-merge

Correct

Awesome! As long as there are no conflicts, Git will move the current branch tip up to the target branch tip and combine histories of both commits.

Week 3

Git Remotes Cheat-Sheet

Command	Explanation & Links
git remote	Lists remote repos
git remote -v	List remote repos verbosely
git remote show <name>	Describes a single remote repo
git remote update	Fetches the most up-to-date objects
git fetch	Downloads specific objects
git branch -r	Lists remote branches; can be combined with other branch arguments to manage remote branches

s

Question 1

In order to get the contents of a remote branch without automatically merging, which of these commands should we use?

git pull

git remote update

git checkout

git log -p -1

Correct

You got it! git remote update will fetch the contents of all remote branches and allow us to merge the contents ourselves.

2.

Question 2

If we need to find more information about a remote branch, which command will help us?

1 / 1 point

git fetch

git checkout

git remote update

git remote show origin

Correct

Right on! If you want to see more information about a particular remote branch, you can use the git remote show command. Don't forget the commit ID!

3.

Question 3

What command will download remote branches from remote repositories without merging the content with your current workspace automatically?

1 / 1 point

git checkout

git pull

git fetch

git remote update

Correct

Nice work! git fetch will download remote updates, such as objects and refs, from the remote branch.

4.

Question 4

What type of merge creates a new merge commit?

0 / 1 point

Fast-forward merge

Implicit merge

Explicit merge

Squash on merge

Incorrect

Not quite. Fast-forward merges are a type of implicit merge, which do not create new commits.

5.

Question 5

What method of getting remote contents will automatically merge the remote branch with the current local branch?

1 / 1 point

git fetch

git checkout

git remote update

git pull

Correct

Great job! git pull automatically merges the remote branch with the current branch.

---------------------------

To copy file from <refactor> branch to <main> brannch

$ git checkout main

$ git checkout refactor -- <refactorFile>

Ass see below

Week 3  SOLVING CONFICTS->The Pull-Merge-Push Workflow

Do change in any coding file then

$ git add -p

-p = prompt for change or not to change. It sia confirmation either to cahnge or not.

Startegy (Seniaro)

for commadn $ git add -p

Jr programmer do coding and Sr  will execute this command 

then $ git commit -m 'reson for changings madE'

MEAN WHILE and COLLOBRATOR also change same and committe d so will be 

CONFICT situation offure then if 

$ git push

you see the following message of REJECTION 

 PUSHING is rejected  indicating that the changes already occurred in remote repo  are not synchronized with your local repo so fist

$ git pull and MERGE file THEN COMMIT THE FILE THEN 

$ git push    again

$ git log --graph --oneline --all

As we can see in fig that 

                * | df80868 first commit from local repo

is a common ancestor for local repo ( HEAD -> main ) and remote repo  (  origin/main , origin/HEAD) this means we need THREE-WAY-MERGE

(Alai Chha, KHABR!!!??!!)

To do htat we have see the origional changes by

$ git log -p origin/main

$ git log --graph --oneline

Question

What should you do with the <<<<<<<, =======, and >>>>>>> conflict markers when resolving a merge conflict?

Remove all of the conflict markers and only leave the code as it should be after the merge.

Leave the conflict markers surrounding the code that you want to keep.

Remove the <<<<<<< and >>>>>>> markers, and put the ======= marker in front of the lines that you want to keep.

Do nothing.

Correct

Awesome! Conflict markers aren’t required when resolving a merge conflict.

1. Week 3 
2. Solving Conflicts-> Pushing Remote Branches

Theremany advantages of working differnce branches.

    1. During dev if a bug occur in main branch, so will easily able to correct the bug by changing the branch with command  $ gitcheckout main

and then $ checkout previous branch and resume the work

        2. You may maintain difference versions of program  one may be stable  version an dother may be BETA  version

$ git branch newbra

To copy local branch  with its confitectin remote repo

$ git push -u origin newbra

Week 3  Solving Conflicts Rebasing Your Changes

To copy a branch work to main branch one command is 

# git merge command 

as discuss earlier, another is 

REBASE command

Rebasing meaning changing the base commit that is use for our branch

1 .  1 commit on remote repo ogigin/main made some user

2.   Three commit s were done in local branch refactor

then locally we do

$ git chekout main

# git pull

Now position is this all three commit in refactor is wonderning , there is no any role of three commits of refactor 

refactore's 3 commits are  totally out of game as show below

To make all 3 commits of refactor in one straight line we have to  run REBASE command on refactor branch as under

By chance this command is applied successfully 

otherwise it may show some conficts, which we may have to resolve it

Now to see the history of commits we found a LINEAR hisory in one straight line from point (origion/master, origin/HEAD, master)  then 3 commits of (HEAD -> refactor)

Now we have to merge three commits of refactor into master/mainbranch then we to push main branch to remote

Question

What does “git rebase refactor” do?

Move the current branch on top of the refactor branch

Move the refactor branch on top of the current branch

Move the refactor branch on top of the master branch

Move the master branch on top of the refactor branch

Correct

Nailed it! This makes debugging easier and prevents three-way merges by transferring the completed work from one branch to another.

 

Week 3  Solving Conficts Another Rebasing Example

 

1. I created remote repo in githum.com with name REBASE

2. Copy <code> from gitbub.com to uswe it in $ git clone command

3. in local computer 

    $ git clone https://github.com/saeedhisbani/rebase.git 

4. made main function by user 1and commit and pushed

5. User 2 pull 

6. user 2 made func1user2() commit and pushed

7. user 1 made func1user1

While user 1 was made chnages during user 2 also made changes on same and commit and push it to remote repo 

To see the changes  in previous video we use command 

$ git pull to see any CONFICTS alai chha 

it auomatically create THREE-WAY-MERGE video 2:57

Here we use differenct approach to keep the repo log history LINEAR

using REBASE COMMAND 

first we use $ git fetch it fetches latest changes done in origin/main .i.e in remote github.com repo

BUT in this stage we are not applying these changes in local repo master of main branch ref: video 3:14

$ git fetch

No any special information is given  only to show 

$ git log --graph --oneline

No any special information is given 

$ git status

Some information is given about difference of local repo main branch and remote repo origin/main

$ git rebase origin/main

Very very handy/precious information in each and every line must read each and every line

about CONFLICT and its Solution etc etc 

The infomation includes 

        1. what try to do

        2. What is worked 

        3. what it can not do

        4. What/how to do manual solution as in yellow lines

$ git status

Some information is acquired

$ git log --graph --oneline

$ vi mainprog.py

Now we have remove all confict and confict markers by editing file manually

Now we want to keep bother functions from user 1 ie is I myselfand other function of user 2

$ git status

Very handy and usefulful informatiomation and it also firmation about our next command

fix conflicts and then

run "git rebase --continue"
 as it will be our next command $ git addd mainpro.py

$ git add mainprog.py

and then 

$ git log --graph --oneline

Still same position of commits log graph

$ git status

Now git status incdicates that 

(all conficlts fix run "git rebase --continue") so run 

$ git rebase --continue

In our modren latest git version it after rebasing also commit automatically

by  leading me to vi editor to modify the commit where I modified the previous local commit of function 1 of user 1 

$ git log --graph --oneline

Now look the instead to (HEAD -> main ,origin/main, origin/HEAD) in one commit/line

the local  HEAD->main branch is  commit is separated from remote branch commit (origin/main, origin/HAD)

and also see Local HEAD -> main branch is REBASED /refounded on remote repo  (origin/main, origin/HEAD)

It is very similar to what we earlier to merge the changes . But difference is that the commit history ended up LINEAR instead of BRANCHING OUT. videio 7:00 

Again

$ git status 

o  :

-------------------------------

Some problem in QwickLab of Model 3

There is some working TOKEN

A SOLUTION IN DISCUSS FORM WAS GIVEN AS UNDER

solution no 1

Right click wasn't working for me either, but I used the shift + ins shortcut and the classic token worked

SOLUTIONNO 2

i figured it out!!!
delete other tokens, just use classic token
after you copied the classic token, go to qwiklabs, git push 
enter username, but don't ctrl+shift+v
at password, do right mouse click and enter
it will work!

SOLUTION NO 3

I first copied the personal access token and then right-clicked in the console (you don't see the personal access token or anything) then pressed enter and it worked.

SOUTION NO 4

When asking for username and password in the Putty Command screen, after git clone command, paste this same tocken as username and password.

SOLUTION NO 5

For verifying password for git hub it says that services were suspended in  august of 2021. we can, however, create a token on our github account and just paste it. although it does not show any text it is already printed there so all you have to do is click enter and it works. To create a token  go to your github profile, then go to settings>developer settings>Personal access token. from there just create a token and accept all the boxes given and click create. after this it will give you a code. MAKE SURE TO COPY THE CODE and save it somewhere because you will reuse that code various times through out the lab

==========================

Week 4

Intro to Module 4: Collaboration vid 1

In this model we keep exploring the collaboration tools used by Git.

In simple English craeting a copy of repo in your/my/saeedhisbani login usernameFor example

repo then we change in this fake copy commit then send tis epsitory

Then we pull request to its origional owner of the repo . either he reject or accept our pull request.

no no this is not way to explain but you say theat

so that the owner of origional repo incorporate it into hsi actual/origional repo

This is way of simple explanantion BHAOOOOO

week 4 A Simple Pull Request on GitHub Vid 2

Week 4 The Typical Pull Request Workflow on GitHub Vid 3

github.com

blake-kale/rearrange

<Fork>

saeedhisgani/rearrrange

<Code>

Go to local computer

$ git clone <paste copied url>

$ cd rarrange

$ ls -l

We find there is no readme file

so to create readme file we new branch as named add-reame

$ git checkout -b add-readme

$ vi REAME.md

add some text in the file and save it

Question 1 What is the difference between using squash and fixup when rebasing?

Squash deletes previous commits.

Squash combines the commit messages into one. Fixup discards the new commit message.

Squash only works on Apple operating systems.

Fixup combines the commit messages into one. Squash discards the commit message.

Correct

Awesome! The fixup operation will keep the original message and discard the message from the fixup commit, while squash combines them.

2.

Question 2

What is a pull request?

1 / 1 point

The owner of the target repository requesting you to add your changes.

A request sent to the owner and collaborators of the target repository to pull your recent changes.

A request to delete previous changes.

A request for a specific feature in the next version.

Correct

Right on! You send a pull request to the owner of the repository in order for them to incorporate it into their tree.

3.

Question 3

Under what circumstances is a new fork created?

1 / 1 point

When you want to experiment with changes without affecting the main repository.

When you clone a remote repository to your local machine.

During a merge conflict.

When there are too many branches.

Correct

Nice work! For instance, when you want to propose changes to someone else's project, or base your own project off of theirs.

4.

Question 4

What combination of command and flags will force Git to push the current snapshot to the repo as it is, possibly resulting in permanent data loss?

1 / 1 point

git push -f

git log --graph --oneline --all

git status

git rebase -i

Correct

Awesome! git push with the -f flag forcibly replaces the old commits with the new one and forces Git to push the current snapshot to the repo as it is. This can be dangerous as it can lead to remote changes being permanently lost and is not recommended unless you're pushing fixes to your own fork (nobody else is using it) such as in the case after doing interactive rebasing to squash multiple commits into one as demonstrated.

5.

Question 5

When using interactive rebase, which option is the default, and takes the commits and rebases them against the branch we selected?

1 / 1 point

squash

edit

reword

pick

Correct

Great job! The pick keyword takes the commits and rebases them against the branch we have chosen.

Week 4 What are code reviews? Vid 1

Github have a TOOL for coding review

Question 1 When should we respond to comments from collaborators and reviewers?

When their comments address software-breaking bugs

No need, just resolve the concerns and be done with it

Always

Only when a code correction is necessary

Correct

Excellent! It is good manners and proper conduct to respond, even when it's simply an acknowledgement.

2.

Question 2

What is a nit?

1 / 1 point

A trivial comment or suggestion

A couple lines of code

A repository that is no longer maintained

An orphaned branch

Correct

Good work! In git jargon (and elsewhere in the tech world), a nit is a minor “nitpick” about a piece of code.

3.

Question 3

Select common code issues that might be addressed in a code review. (Check all that apply)

1 / 1 point

Using unclear names

Correct

Excellent! Unclear names can make our code hard to understand.

Following PEP8 guidelines

Forgetting to handle a specific condition

Correct

Alright! If there is a specific condition that could cause a problem and we don't address it, the result could be catastrophic.

Forgetting to add tests

Correct

Woohoo! Tests are an important addition to our code to ensure it runs smoothly.

4.

Question 4

If we've pushed a new version since we've made a recent change, what might our comment be flagged as?

1 / 1 point

Accepted

Resolved

Outdated

Merged

Correct

Nice job! If we push a new version after making a change, old comments are marked with the "Outdated" flag.

5.

Question 5

What are the goals of code review? (Check all that apply)

0 / 1 point

Make sure that the contents are easy to understand

Ensure consistent style

Correct

Awesome! By comparing our code to style guidelines, we can keep our style consistent and readable.

Build perfect code

This should not be selected

Not quite. We can never expect to build perfect code. But code review can help us keep our code clean and understandable, and reduce the most obvious bugs.

Ensure we don't forget any important cases

Correct

Good job. Code review can reveal cases or conditions we need to handle in our code.

Week 4 Managing Collaboration Vid 1  

1. There must very documentation of coding

2. Coding must be a very clear and easy must not be complex

So that another teeam member rectify the problem easily

During group Project Management you need Internet COLLABORATION Tools . TWO are very famous and the best collaboration tools

        1. Issue Tranker

        2. Continous Integration

Week 4 Continuous Integration    Vd 3

AUTOMATICALLY

Human can not remember every time to TEST CODE.

sO WE MAKE AUTOMATIC TESTING PROGRAMS TO TEST THE CODES EVERY TIME WE MADE CHANGES

Continuous Deployment

See at video 2:47
Step No 1:

Step No 2:

Step No 3:

Step No 4:

Additional Tools

Check out the following links for more information:

• https://arp242.net/diy.html 

• https://help.github.com/en/articles/closing-issues-using-keywords

• https://help.github.com/en/articles/setting-guidelines-for-repository-contributors 

• https://www.infoworld.com/article/3271126/what-is-cicd-continuous-integration-and-continuous-delivery-explained.html

• https://stackify.com/what-is-cicd-whats-important-and-how-to-get-it-right/

• https://docs.travis-ci.com/user/tutorial/

• https://docs.travis-ci.com/user/build-stages/

 

===========================================----==============

Repeated up to here now start from here  1st Oct 2023

Viedeo No2 Keeping Historical Copies 
(Programming Scripts like python codes copies)
To track changes occur in program. Also to track ,
Who change the code, Why changing was needed.

Question

What’s the goal of a version control system?

To make sure that our code has no bugs

To keep track of changes made to our files

To have backup copies of our code

To store code, images, configuration, and videos

Correct

Right on! A version control system allows us to keep track of

1. when and

2. who did

3. what changes to our files.

Those can be code, configuration, images, or whatever else we

To differenciate two files we use following os commands.

1. Diff

Following are Some Graphical Tools to compare two files 

    2, WDiff

    3. meld

    4.Kdiff3

    5. vimdiff

diff -u old_file new_file > chang.diff

Question

What does the patch command do?

It generates a file with the differences between two files.

It shows the changes made in a directory of files.

It redirects the contents of a file into standard input.

It applies the changes contained in a diff file to another file.

Correct

Right on! While diff is the command that generates the difference between two files, patch is the command that applies those differences to the original file.

Command is patch disk_usage.py < disk_usage.diff.

Question

We've prepared a diff file with the changes that need to be applied to the script. What does our colleague need to do now?

Look at the changes in the diff file and manually modify the original file with those same changes.

Run diff disk_usage.diff disk_usage.py.

Ask us to send them the full file, not just the diff file.

Run patch disk_usage.py < disk_usage.diff.

Correct

You nailed it! To automatically apply changes to a file, we need to run the patch command on the file that we want to modify with the diff file as input.

diff and patch Cheat Sheet

diff

diff is used to find differences between two files. On its own, it’s a bit hard to use; instead, use it with diff -u to find lines which differ in two files:

diff -u

diff -u is used to compare two files, line by line, and have the differing lines compared side-by-side in the same output. See below:

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

1

2

3

Apples

Bananas

Oranges

Pears

 

~$ cat menu2.txt 

Menu:

 

Apples

Bananas

Grapes

Strawberries

 

~$ diff -u menu1.txt menu2.txt 

--- menu1.txt   2019-12-16 18:46:13.794879924 +0900

+++ menu2.txt   2019-12-16 18:46:42.090995670 +0900

@@ -1,6 +1,6 @@

-Menu1:

+Menu:

 

 Apples

 Bananas

-Oranges

-Pears

+Grapes

+Strawberries

 

~$ cat menu1.txt 

Menu1:

 

Patch

Patch is useful for applying file differences. See the below example, which compares two files. The comparison is saved as a .diff file, which is then patched to the original file!

21

20

17

18

19

14

15

16

10

11

12

13

7

8

9

4

5

6

1

2

3

 

It's a wonderful day!

~$ cat hello_world.txt 

Hello World

 

~$ diff -u hello_world.txt hello_world_long.txt > hello_world.diff

~$ patch hello_world.txt < hello_world.diff 

patching file hello_world.txt

@@ -1 +1,3 @@

 Hello World

+

+It's a wonderful day!

~$ diff -u hello_world.txt hello_world_long.txt 

--- hello_world.txt     2019-12-16 19:24:12.556102821 +0900

+++ hello_world_long.txt        2019-12-16 19:24:38.944207773 +0900

Hello World

 

It's a wonderful day!

~$ cat hello_world.txt 

Hello World

~$ cat hello_world_long.txt 

Patch

Patch is useful for applying file differences. See the below example, which compares two files. The comparison is saved as a .diff file, which is then patched to the original file!

21

20

17

18

19

14

15

16

10

11

12

13

7

8

9

4

5

6

1

2

3

 

It's a wonderful day!

~$ cat hello_world.txt 

Hello World

 

~$ diff -u hello_world.txt hello_world_long.txt > hello_world.diff

~$ patch hello_world.txt < hello_world.diff 

patching file hello_world.txt

@@ -1 +1,3 @@

 Hello World

+

+It's a wonderful day!

~$ diff -u hello_world.txt hello_world_long.txt 

--- hello_world.txt     2019-12-16 19:24:12.556102821 +0900

+++ hello_world_long.txt        2019-12-16 19:24:38.944207773 +0900

Hello World

 

It's a wonderful day!

~$ cat hello_world.txt 

Hello World

~$ cat hello_world_long.txt 

Question

What does a version control system do?

It groups all related code.

It explains why a change was made.

It keeps track of changes we do to our files.

It prevents us from changing files by mistake.

Correct

Spot on! By keeping track of the changes that we make to our files, a VCS lets us know when a file changed, who changed it, and also lets us easily roll back those changes.

Question

Why is a version control system useful, even if it's used only by a single person? Check all that apply.

Seeing the history of the changes helps us understand what changed and why.

Correct

You got it! One of the main benefits of a VCS is that you can see the history of how files changed and understand what changed at each step and what motivated the change.

Tracking code in a VCS ensures that it's bug free.

Tracking changes allows for easy rollbacks when a problem is detected.

Correct

Right on! By having each change tracked in the VCS, it's very easy to go back to previous versions when an issue with a change is discovered.

Storing files in a VCS avoids the need for any kind of backups.

Question

What characteristics make Git particularly powerful? Check all that apply.

It was created by Linus Torvalds in 2005.

It's a distributed VCS, which means that each developer has a full copy of the repository.

Correct

You nailed it! Because each contributor to a Git repo has a full copy of the repository, they can interact with the tracked files without needing a coordinating server. In turn, this improves collaboration.

It's maintained by a team of distributed developers.

Repositories can be used by as many developers as needed.

Correct

Right on! Because of the way Git was designed, repositories can be useful for any number of developers, from one to thousands.

Official website of Git  https://git-scm.com

More Information About Git

Check out the following links for more information:

• https://git-scm.com/doc

• https://www.mercurial-scm.org/

• https://subversion.apache.org/

• https://en.wikipedia.org/wiki/Version_control

Now windows oprating systems have Linux command support using MINGW64

 

Question: How VCS is handy when updating the software , even for solo programmer

Git retains local copies of repositories, resulting in fast operations.

Correct

Awesome! Git's distributed architecture means each person contributing to a repository retains a full copy of the repository locally.

If something breaks due to a change, you can fix the problem by reverting to a working version before the change.

Correct

Nice job! With version control, if something goes wrong, we can fix it immediately and figure out what happened later.

Git relies on a centralized server.

Git allows you to review the history of your project.

Correct

Right on!

------------------------------------------------------------------------------------

Q:Who invented Git

Linus Torvalds he is also creatro and originator of Linux as well

Correct

Nailed it! Linus Torvalds developed Git in 2005 to better facilitate the process of developing the Linux kernel with developers across the globe.

---------------------------------------------

Version control

Correct

Right on! A version control system keeps track of the changes that we make to our files.

--------------------------------------------------------------------

commit

Correct

Awesome! We call the collection of edits we are making at one time a commit.

---------------------------------------------------------------------------------------------------------------------------------------------------------------

repositories

IDE

yum

Correct

Excellent. A repository is a central location in which data is stored and managed.

-----------------------------------------------------

What are the git directory and the working tree?

Incorrect

Not quite. While the git directory stores some configuration settings, it also stores the history of the changes. The working tree acts as a sandbox where we can edit the current versions of the files.

Incorrect

Not quite. The git directory acts as a database for all the changes tracked in Git and the working tree acts as a sandbox where we can edit the current versions of the files.

The git directory contains all the changes and their history and the working tree contains the

current versions of the files.

Correct

Awesome! The git directory acts as a database for all the changes tracked in Git and the working tree acts as a sandbox where we can edit the current versions of the files.

Advanced Git Cheat Sheet

Command	Explanation & Link
git commit -a	Stages files automatically
git log -p	Produces patch text
git show	Shows various objects
git diff	Is similar to the Linux `diff` command, and can show the differences in various commits
git diff --staged	An alias to --cached, this will show all staged files compared to the named commit
git add -p	Allows a user to interactively review patches to add to the current commit
git mv	Similar to the Linux `mv` command, this moves a file
git rm	Similar to the Linux `rm` command, this deletes, or removes a file

There are many useful git cheatsheets online as well. Please take some time to research and study a few, such as this one.

.gitignore files

.gitignore files are used to tell the git tool to intentionally ignore some files in a given Git repository. For example, this can be useful for configuration files or metadata files that a user may not want to check into the master branch. Check out more at: https://git-scm.com/docs/gitignore.

A few common examples of file patterns to exclude can be found here.

Practice Quiz: Advanced Git Interaction

Which one command/method is not for viewing or comparing the files in git repository?

 

git log -p

git diff --staged

git add -p

git mv

Correct

Nice job! git mv won't give you any information on changes. Instead, it is used to move or rename a file or directory in Git.

Q2: What is gitignore file??

A file containing a list of files or filename patterns for Git to skip for the current repo.

Correct

Awesome! The gitignore file is a text file that tells Git which files or folders to ignore in a project.

New files

Old files

Staged files

Correct

Right on! Files that are new and untracked will not be committed before being added.

Question

What is the purpose of the git checkout command?

It finalizes staged changes.

It reverts changes to modified files before they are staged.

It skips staging and directly commits.

It displays the current status of the commit.

Correct

Right on! git checkout restores files to the latest stored snapshot, reverting any changes before staging.

Week 2 video 1 Undoing Changes Before Committing

Undo changing by $git checkout command

first I change .py file cpu_usage.py and insert a buggy command

and save it and run it

$ git status

On branch master

Changes not staged for commit:

  (use "git add <file>..." to update what will be committed)

  (use "git restore <file>..." to discard changes in working directory)

        modified:   cpu_usage.py

no changes added to commit (use "git add" and/or "git commit -a")

Note that in video it mentioned (use "git checkout  <file> ...) before stagging of file

 "git restore <file>"   restore is during the stagging 

$ git checkout cpu_usage.py

Updated 1 path from the index

S.A COMPUTER@DESKTOP-3E67FB9 MINGW64 ~/check (master)

$ git status

On branch master

nothing to commit, working tree clean

The changes have revitted . 

$ cat cpu_usage.py

#!/usr/bin/env python

import psutil

def check_cpu_usage(percent):

    usage = psutil.cpu_percent()

    return usage < percent

if not check_cpu_usage(75):

    print('ERROR: CPU is overloaded.')

else:

    print('Everything is OK.')

$ ./cpu_usage.py > any.txt    to create a new file to work

$ git status

On branch master

Untracked files:

  (use "git add <file>..." to include in what will be committed)

        any.txt

nothing added to commit but untracked files present (use "git add" to track)

$ git add *

$ git status

On branch master

Changes to be committed:

  (use "git restore --staged <file>..." to unstage)

        new file:   any.txt

Note only showing any.txt file not showing cpu_usage.py file if amend the file then it will also be shown

$ vi cpu_usage.py   to make some changing in the file  and save it

$ git status

On branch master

Changes to be committed:

  (use "git restore --staged <file>..." to unstage)

        new file:   any.txt

Changes not staged for commit:

  (use "git add <file>..." to update what will be committed)

  (use "git restore <file>..." to discard changes in working directory)

        modified:   cpu_usage.py

$ git add *   to add all files in stage area stagging

$ git status

On branch master

Changes to be committed:

  (use "git restore --staged <file>..." to unstage)

        new file:   any.txt

        modified:   cpu_usage.py

$ git reset HEAD any.txt  to unstage any.txt file only means to untrack the any.txt file

Head means to reset the file to current snapshot 

$ git status

On branch master

Changes to be committed:

  (use "git restore --staged <file>..." to unstage)

        modified:   cpu_usage.py

Untracked files:

  (use "git add <file>..." to include in what will be committed)

        any.txt

$ git reset -p which specific change you want to reset

===========================================

Week 2 Video 2 Amending files after Commits

but you realize that your commit message 

just wasn't descriptive enough. 

So you want to fix the description 

to add a link to the bug 

that you're solving with that commit. What can you do? 

We can solve problems like these using 

the --amend option of the git commit command. 

When we run git commit --amend, 

git will take whatever is 

currently in our staging area and 

run the git commit 

workflow to overwrite the previous commit.

$ touch file1.txt

$ touch file2.txt

$ git commit HEAD file1.txt -m 'committed just 2 files'   we forget to add file2.txt

This command will only commit one file ie file1.txt

to add another file in same comitt message we have to revert it by using command 

$ git commit --amend 

This command will delete/revert last committed command and overwrite it .

New commit file will come infornt of you which includes both two now you may also change message as well 

e.g. Really 2 files are commiteed togather  

================================================================================

Week 2 Video 3 RollBacks

First we add following errorous code in all_checks.py

    if disk_full():

        print('Disk is Full')

        sys.exit(1)

save the script  then

$ git commit -a -m 'Disk_full function is added in the script'

$ ./all_checks.py

Traceback (most recent call last):

  File "C:\Users\AL Abbas\check\all_checks.py", line 18, in <module>

    main()

  File "C:\Users\AL Abbas\check\all_checks.py", line 13, in main

    if disk_full():

NameError: name 'disk_full' is not defined

We got error so want to RollBack / Revert the previous changes  for 

$ git revert HEAD

out put will come with nano editor / vi editor come 

Revert "Disk_full function is added in the script"

This reverts commit 6442d795d3849a57b45a08a8a07081e7999c808e.

# Please enter the commit message for your changes. Lines starting

# with '#' will be ignored, and an empty message aborts the commit.

#

# On branch master

# Changes to be committed:

#       modified:   all_checks.py

#

In the third line we add

The reason for Revert: An error due to Disk_full function was undefined.

$ git log -p -2  && 2 means show last to commit entries

Question

Which of the following is true about the git revert command?

It undoes a commit as though it never happened.

It creates a new commit with inverse changes.

The output of git revert is not the same as a regular commit.

It does not include the ID of the commit that was reverted.

Correct

Awesome! With git revert, a new commit is created with inverse changes. This cancels previous changes instead of making it as though the original commit never happened.

================================================

Week No 3 Video 4 Identifying a Commit

Commit ID is 40 character Hash code created through SHA1 security digestive code  Crypography Allaee Chha

This 40 char Hash commit is made from author name, date time of commit, commit message etc, there are very very lesser chance

this it would be identical with other commit ID.

Question

Which of the following is NOT true about the SHA1 hash numbers that Git uses to identify commits?

They provide the consistency that is critical for distributed systems such as Git.

They are created using the commit message, date, author, and the snapshot taken of the working tree.

Git requires the entire hash ID to identify a commit.

They are composed of 40 characters.

Correct

You nailed it! Git can identify a commit using the first few hash numbers as long as there is only one matching possibility.

Week 2 What is a branch? video No1

                Branch is pointer of particular commit  

        Default branch is made with name of "MASTER" It represent the known good state of a project

Question

What is the purpose of organizing repositories into branches?

To enable changes to be worked on without disrupting the most current working state.

To make it easier to undo commits.

To enable changes to the repository to permanently replace previous commits.

To give users a place to keep notes.

Correct

Awesome! By creating a new branch, we can experiment without breaking what already works.

git revert

git commit --amend

git reset

git checkout -- <file>

Correct

Nice job! git revert will create a new commit to reverse the previous one, and is the best option for undoing commits on public branches.

Use the git reset HEAD~2 command instead of revert

Use the revert command repeatedly until we've reached the one we want

use the commit ID at the end of the git revert command

Use the git commit --amend command instead

Correct

Nice work! The commit ID is a 40-character hash that identifies each commit.

To secure project backups

To guarantee the consistency of our repository

To encrypt passwords

To identify commits

Correct

Woohoo! Git doesn't really use these hashes for security. Instead, they’re used to guarantee the consistency of our repository.

Start a new branch

Create a copy of the previous commit

Delete the previous commit

Overwrite the previous commit

Correct

Awesome! The command git commit --amend will overwrite the previous commit with what is already in the staging area.

$ git branch       && to see list o branches

$ git branch

  master

* new-feature

$ git checkout -b newbranch   && creates new branch and  switched to that branch

Switched to a new branch 'newbranch'

S.A COMPUTER@DESKTOP-3E67FB9 MINGW64 ~/check (newbranch)

$ git branch

  master

  new-feature

* newbranch

To change branch 

$ git checkout <branchname>

Question

What does the git checkout -b new branch command do?

Switches to another branch and immediately commits.

Checks if the new branch is ahead of the main branch.

Merges two branches.

Creates a new branch and switches to it.

Correct

Nice job! It's very handy to be able to start a new branch, and switch to it in a single command.

Question

How does git checkout switch branches?

By creating a new commit on a new branch.

By updating the working tree to match the selected branch.

By moving the HEAD to the previous commit.

By amending the commit with the provided ID.

Correct

Right on! The HEAD is moved to the relevant commit on the specified branch.

Question

What happens when we merge two branches?

The HEAD points at the master branch.

Both branches are pointed at the same commit.

One of the former branches disappears.

Two independent snapshots will now share the same name.

Correct

Awesome! Merging combines branched data and history together.

Question

What does the git checkout -b new branch command do?

Switches to another branch and immediately commits.

Checks if the new branch is ahead of the main branch.

Merges two branches.

Creates a new branch and switches to it.

Correct

Nice job! It's very handy to be able to start a new branch, and switch to it in a single command.

There two command to create NEW Branch

$ git branch withBranch 

other is 

$ git checkout -b withCheckout  && also select that as working area I mean Working Tree

Question

What's the advantage of Git throwing a merge conflict error in cases of overlap?

It prevents loss of work if two lines overlap.

It helps us understand which changes to keep.

It warns us of all potential problems.

It tells us whether the commit is a merge

Correct

Nice job! If two lines have differences Git is unsure about, it's best we decide than risk losing work forever.

To undo confict / you want reverse change and you want files in same state/condition as it was

$ git merge --abort

Git Branches and Merging Cheat Sheet

Command	Explanation & Link
git branch	Used to manage branches
git branch <name>	Creates the branch
git branch -d <name>	Deletes the branch
git branch -D <name>	Forcibly deletes the branch
git checkout <branch>	Switches to a branch.
git checkout -b <branch>	Creates a new branch and switches to it.
git merge <branch>	Merge joins branches together.
git merge --abort	If there are merge conflicts (meaning files are incompatible), --abort can be used to abort the merge action.
git log --graph --oneline	This shows a summarized view of the commit history for a repo.

three-way merge

fast-forward merge

merge conflict

orphan-creating merge

Incorrect

Not quite. A fast-forward merge occurs when all the commits in the checked-out branch are also in the branch to be merged, in which case the pointers are simply updated.

Question 2

git checkout -b <branch>

git merge --abort

git log --graph --oneline

git branch -D <name>

Correct

Right on! If there are merge conflicts, the --abort flag can be used to abort the merge action.

git log --format=short

git branch -D <name>

git log --graph --oneline

git checkout -b <branch>

Correct

Awesome! The commandgit $ log --graph --oneline hows a summarized view of the commit history for a repo.

WEEK 3  GITHUB.com

Week 3  video 1 The Pull-Merge-Push Workflow

Question

Which BEST describes GitHub?

A distributed Version Control System (VCS)

A Software Configuration Management system (SCM)

A remote repository hosting service for Git

A wiki site for Git users

Correct

Nice job! GitHub provides free access to a Git server for public and private repositories.

Made user account in github.com

Add a new repository with health-check as Private not Public.

In my local computer start MINGW64 

Now I want to copy the my remote repository in local computers local hard disk, which I just created in github.com as health-check 

$ git clone https://github.com/saeedhisbani/health-checks.git   this url I copied from my github.com account <CODE> option 

in green color 

This will copy remote repo in my local disk . health-check dir ,  auto made by clone commanmd

 

Then a t local computer we add line in README.md file save it.

$ git commit -a -m 'Add one more line in README.md'

Now there is diff b/w local and remote repo 

To copy loca repo to remote repo we only execute folloing command 

$ git push

Question

After making changes to our local repository, how do we update the remote repository to reflect our changes?

Use the git clone command to clone the repository to the server.

Use the git push command to send snapshots to the remote repository.

Upload a README.md file with Markdown.

Use the Create a repository form on the website

Correct

Awesome! The git push command gathers all the snapshots we've taken and sends them to the remote repository.

Basic Interaction with GitHub Cheat-Sheet

There are various remote repository hosting sites:

• GitHub

• BitBucket

• Gitlab.

Follow the workflow at https://github.com/join to set up a free account, username, and password. After that, these steps will help you create a brand new repository on GitHub.

Some useful commands for getting started:

Command	Explanation & Link
git clone URL	Git clone is used to clone a remote repository into a local workspace
git push	Git push is used to push commits from your local repo to a remote repo
git pull	Git pull is used to fetch the newest updates from a remote repository

This can be useful for keeping your local workspace up to date.

• https://help.github.com/en/articles/caching-your-github-password-in-git

• https://help.github.com/en/articles/generating-an-ssh-key  

Question 1 When we want to update our local repository to reflect changes made in the remote repository, which command would we use?

git clone <URL>

git push

git pull

git commit -a -m

Correct

Right on! git pull updates the local repository by applying changes made in the remote repository.

Question 2

git config --global credential.helper cache allows us to configure the credential helper, 

which is used for ...what?

Troubleshooting the login process

Dynamically suggesting commit messages

Allowing configuration of automatic repository pulling

Allowing automated login to GitHub

Correct

Nice work! By configuring the credential helper, we can avoid having to type in our username and password repeatedly.

Question 3

Name two ways to avoid having to enter our password when retrieving and when pushing changes to the repo. (Check all that apply)

Implement a post-receive hook

Use a credential helper

Correct

Awesome! The credential helper caches our credentials for a time window, so that we don't need to enter our password with every interaction.

Create an SSH key-pair

Correct

Great job! We can create an SSH key-pair and store the public key in our profile, so that GitHub recognizes our computer.

Use the git commit -a -m command.

Question 4

Name the command that gathers all the snapshots we've taken and sends them to the remote repository.

git commit -a -m

git push

git pull

git clone <URL>

Correct

Excellent! git push is used to update the remote repository with our local changes.

Question

What will happen if the master repository receives a major update since the last local copy was synced?

Git will push your local copy.

Nothing will happen.

Git will let you know it's time for an update.

Git will automatically merge the local copy with the master.

Correct

Great job! If there are pending changes in the master branch, Git will let you know.

Git supports a variety of ways to connect to a remote repository. Some of the most common are using the HTTP, HTTPS and SSH protocols and their corresponding URLs. 

HTTP is generally used to allow read only access to a repository. In other words, it lets people clone the contents of your repo without letting them push new contents to it. 

Conversely HTTPS and SSH, both provide methods of authenticating users so you can control who gets permission to push.

1. Week 3
2. Working with Remotes  video 2

Saeed Hassan Hisbani@sad MINGW64 ~/health-checks (main)

$ git remote -v

origin  https://github.com/saeedhisbani/health-checks.git (fetch/pull)

origin  https://github.com/saeedhisbani/health-checks.git (push)

But in some cases, you can have the fetch/pull URL use HTTP for read only access, and the push URL use HTTPS or SSH for access control.

Remote repositories have a name assigned to them, by default, the assigned name is origin. This lets us track more than one remote in the same Git directory.

$ git remote show origin

* remote origin

  Fetch URL: https://github.com/saeedhisbani/health-checks.git

  Push  URL: https://github.com/saeedhisbani/health-checks.git

  HEAD branch: main

  Remote branch:

    main tracked

  Local branch configured for 'git pull':

    main merges with remote main

  Local ref configured for 'git push':

    main pushes to main (up to date)

To look at the remote branches

$ git branch -r  r means remote 

  origin/HEAD -> origin/main

  origin/main

Question

If we want to make a change to a remote branch, what must we do?

Directly make the change

Use the git branch -r command

Pull the remote branch, merge it with the local branch, then push it back to its origin.

Use the git remote -v command

Correct

Excellent! We still have to go through the normal workflow to change remote branches.

$ git status

On branch main   |<=====  This is local status

Your branch is up to date with 'origin/main'.  <=== This is remote repo status

nothing to commit, working tree clean

$ git remote show origin    To see if some one team did some update

* remote origin

  Fetch URL: https://github.com/saeedhisbani/health-checks.git

  Push  URL: https://github.com/saeedhisbani/health-checks.git

  HEAD branch: main

  Remote branch:

    main tracked

  Local branch configured for 'git pull':

    main merges with remote main

  Local ref configured for 'git push':

    main pushes to main (local out of date)

$ git fetch      to update local repo according to remote repo

remote: Enumerating objects: 5, done.

remote: Counting objects: 100% (5/5), done.

remote: Compressing objects: 100% (2/2), done.

remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0

Unpacking objects: 100% (3/3), 769 bytes | 10.00 KiB/s, done.

From https://github.com/saeedhisbani/health-checks

   2c2ba87..ca29b7e  main       -> origin/main

$ git merge origin/main to update local repo according to remote repo

Updating 2c2ba87..ca29b7e

Fast-forward

 README.md | 5 +++++

 1 file changed, 5 insertions(+)

After $ git merge origin/main commad change made in README.md in remote repo  was sync with local repo 

 

$ git pull it  fetcher data from remote repo and also merge2  

remote: Enumerating objects: 5, done.

remote: Counting objects: 100% (5/5), done.

remote: Compressing objects: 100% (2/2), done.

remote: Total 3 (delta 1), reused 0 (delta 0), pack-reused 0

Unpacking objects: 100% (3/3), 700 bytes | 16.00 KiB/s, done.

From https://github.com/saeedhisbani/health-checks

   ca29b7e..532ea0c  main       -> origin/main

Updating ca29b7e..532ea0c

Fast-forward

 README.md | 1 +

 1 file changed, 1 insertion(+)

Question

What’s the main difference between git fetch and git pull?

git fetch fetches remote updates but doesn't merge; git pull fetches remote updates and merges.

git pull fetches remote updates but doesn't merge, while git fetch does.

git fetch clones the entire repository.

git pull requires a password while git fetch doesn't.

Correct

Nice job! git pull instantly merges while git fetch only retrieves remote updates.

$ git pull = $git fetch + $git merge

Question

Assuming no merge conflicts, which type of merge does git pull perform automatically?

Three-way merge

Explicit merge

Fast-forward merge

Half-merge

Correct

Awesome! As long as there are no conflicts, Git will move the current branch tip up to the target branch tip and combine histories of both commits.

Git Remotes Cheat-Sheet

Command	Explanation & Links
git remote	Lists remote repos
git remote -v	List remote repos verbosely
git remote show <name>	Describes a single remote repo
git remote update	Fetches the most up-to-date objects
git fetch	Downloads specific objects
git branch -r	Lists remote branches; can be combined with other branch arguments to manage remote branches

Question 1

In order to get the contents of a remote branch without automatically merging, which of these commands should we use?

git pull

git remote update

git checkout

git log -p -1

Correct

You got it! git remote update will fetch the contents of all remote branches and allow us to merge the contents ourselves.

Question 2

If we need to find more information about a remote branch, which command will help us?

git fetch

git checkout

git remote update

git remote show origin

Correct

Right on! If you want to see more information about a particular remote branch, you can use the

git remote show command. Don't forget the commit ID!

Question 3

What command will download remote branches from remote repositories without merging the content with your current workspace automatically?

git checkout

git pull

git fetch

git remote update

Correct

Nice work! git fetch will download remote updates, such as objects and refs, from the remote branch.

4.

Question 4

What type of merge creates a new merge commit?

Fast-forward merge

Implicit merge

Explicit merge

Squash on merge

Incorrect

Not quite. Fast-forward merges are a type of implicit merge, which do not create new commits.

5.

Question 5

What method of getting remote contents will automatically merge the remote branch with the current local branch?

git fetch

git checkout

git remote update

git pull

Correct

Great job! git pull automatically merges the remote branch with the current branch.

----------------------------all_cheks.py------------------

#!/usr/bin/env python3.7

# -*- coding: utf-8 -*-

import os

import sys

def check_reboot():

    """Returns true if a computer has a pending reboot"""

    return os.path.exists("/run/reboot-required")

def main():

    if check_reboot():

        print("pending reboot.")

        sys.exit(1)

    print("everythin ok")

    sys.exit(0)

main()

Question

What should you do with the <<<<<<<, =======, and >>>>>>> conflict markers when resolving a merge conflict?

Remove all of the conflict markers and only leave the code as it should be after the merge.

Leave the conflict markers surrounding the code that you want to keep.

Remove the <<<<<<< and >>>>>>> markers, and put the ======= marker in front of the lines that you want to keep.

Do nothing.

Correct

Awesome! Conflict markers aren’t required when resolving a merge conflict.

WEEK NO 3 

Video 2 

Pushing Remote Branches

Question

How do you switch to a new local branch?

git checkout -b <branch name>

git branch b

git pull origin branch

git merge branch

Correct

Great job! The command git checkout -b <branch name> will first create a new branch and then switch to it.

Week 3 Video 3  

Rebasing Your Changes

 Rebasing mean some thing like commit

There is one master, main branch which is final branch . Usually developer work / test the code in these rough/working

branches after debugging and reviewing and finalizing codes, this rough branch will be a genuine work.

Then this branch will be MERGED  with master/main branch. This is the folow of work/

this is done with 

$ git merge  command 

and other option is to use 

$ git rebase command 

Fast-Farward means commit automatically 

ffffff