Launch School - Guide to Git and Github (2023)

Record

Gonnahttps://github.comand create an account. Be sure to choose a username that is professional and recognizable, as this will be your username even if you change jobs.

You can choose a free plan for this book. It allows you to create an unlimited number of public and private repositories. The steps and processes are the same for public and private repositories.

If you choose to set up your account with alternative security mechanisms, such as 2-factor authentication (2FA), you can authenticate yourself withlocoDomain. This book covers basic username/password authentication only. For more information about authenticating with GitHub, seeGitHub documentation.

Some of the images in this chapter are from GitHub pages. The GitHub interface may have changed since we created these images, so the content may look slightly different. Some of these images may show the name of the repository branch asmaestroinsteadprincipal; this is not critical for our purposes.

Create a repository

Now that you've set up your GitHub account, it's time to learn how to use it. Every time you sign in to the GitHub website, you'll see a plus icon in the upper right corner. If you click on it, you will see a menu with anew repositorycoupling. Click on the link.

Choosing a repository name is as follows. There are two general rules to follow:

1. The repository name must be unique for your account.

   This means that someone else may have mentioned a repository on GitHub.my-big-repoand you can have it too. However, you cannot have two repositories with the same name in your account.

2. Choose a descriptive name based on your project.

   When it comes to naming conventions, some people separate words with hyphens and others use underscores. This is a personal preference and you can separate your words with any character other than a space or tab.

In this guide we are going toremote repositoryon GitHub.com, where we can push the local repository we created in the previous chapter.

As you'll see in this example, your local and remote repositories don't need to have the same name. we will usemy-first-repositoryas the name of our remote repository on GitHub.

You'll notice that GitHub has added a green check mark to the text box where we entered our repository name. This tells us that our repository name is safe and usable. If there are spaces in the repository name, GitHub will automatically replace them with hyphens.

The next thing to keep in mind is the callInitialize this repository with the README filebox. This isergioan important step in creating a remote repository.

• If you check the box, it will automatically create the fileFilefile in your remote repository. Before you can push commits to the newly created remote repository, you mustbitchcode from the remote repository to the local repository. You can read more about this later in this chapter.

• However, if you leave this box unchecked, you will receive instructions on how to create and connect your local repository to the newly created remote repository.

You usually create a local repository first, so you'll rarely check this box. Whether you initialize a GitHub repository with a README file or not, you need to conceptually understand the implications.

For our example, do thisNOstart oneFilefile, then click on itCreate a repositoryto create a remote repository on GitHub.com.

Connect to the GitHub repository

You should now see instructions on how to link your local repository to the remote repository you just created on GitHub. Just looking at the first option, the git command set should look very familiar. We've already done the first four or five commands, albeit with some differences. We just need to run the last two commands to mount our local repository using the remote.

Make sure you are at the command line in your project directory and then run the following command. You need to enter your GitHub username and the name of the remote repository:

# Replace your GitHub username and repository name where $ git remote add origin is specified https://github.com/GITHUBUSERNAME/REPONAME.git

For example:

$ git add origin remotely https://github.com/xyzzyfixlet/this-is-my-repo.git

What did we just do?

Before we continue, let's look at the command we just ran.

$ git remote add source url_to_remote_git_repo.git

from basiclocothe command we issueremote git. Use this command to work with remote repositories. how much are you going to spendremote gitOn my own,locolists all remote repositories known to your local repository. If you pass additional subcommands toremote gitcommand, you can add, remove, and modify the remote repositories that your local repository is linked to. Knowing this, it can be guessed that we have the so-calledaddsub command to add the remote repository to your local repository.

that explainsadd remote gitpart of the command, but what's the pointorigenWurl_to_remote_git_repo? Both things point to a remote repository. The last one, calledurl_to_remote_git_repo, it's obvious: it's the URL of the remote git repository, which should end in a.gitenlargement.

Zorigenis what we call oneAlias. The alias is the name that you will use locally to communicate with the remote repository. You can link any number of remote repositories to your local repository, but they must all have unique aliases. Instructions generated by GitHub always useorigenas a pseudonym. Any interaction between the local repository and the remote repository must include this alias. You can name it anything you want, but you must follow git's naming conventions (for example, no spaces). Most programmers useorigenkeep in minda central repository where we keep an official copy of our codebase. In most cases this means a remote hosted repositorygithub.com.

if you open~/git_basics/.git/configin the text editor you will see how git stores the information we just added. Remember that.git/configthe file is where all the configuration settings for your local repository are stored and overrides all the global settings. Please note that your.git/configIt doesn't necessarily look like the following, which already contains a sample remote repository called "origin".

[core] repositoryformatversion = 0 filemode = true bare = false logallrefupdates = true ignorecase = true precomposeunicode = true [remote „Origin”] url = https://github.com/joesmith2444/my-first-repository.git fetch = +refs /heads/*:remote/refs/source/*["main" branch] remote = source combination = refs/heads/main

Entries below[remote "source"]are specific settings for this remote control. settings below[branch head"]set tracking. For example,remote = sourcetells the local repository to check out the fileorigenremote as the default remote for localprincipalbranch to push and pull.

Github authentication

When interacting with GitHub through the CLI, you'll notice that some form of authentication is required to modify and access resources on GitHub. Starting August 13, 2021, GitHub will switch from password-based authentication to usingtoken-based authentication. Token-based authentication can be achieved in a number of ways, the simplest of which is to use aA personal access token(PAT). PAT is a kind ofencrypted passwordwhich means that the plain text password is not stored on the server. When the client (you) provides the token to the server, the token is hashed using the same algorithm that hashed the stored version of the password, and these values ​​are compared to determine if they match. If you're participating in Launch School, learn more about encrypted passwords in the Web Apps course.

The main benefits of PAT are two:

• PATs are limited in scope; if someone is at risk, limit the damage that can be done.
• PAT can be revoked individually; if one is compromised, just create a new one and delete the old one without having to trace every place you might have used a particular password.

The following steps will help you create a PAT. Please note that these steps and menu options are subject to change and may require troubleshooting on your part. Please provide feedback if you notice that any of the information below is no longer up to date.

1. Verify your email address if you haven't already.

2. accessGitHub.comand go toInstitutions'.

   

3. Choose 'developer settings'I'personal access tokens' in the left sidebar.

   

   

4. click on 'Generate a new token' and give it a name (for example, for personal use)

   

   By default, the PAT expires after 7 days. You can change it if you want.

   As of October 2022, this dialog no longer has a fileGenerate a new tokenchoice. Instead, you have 2 options:thin chips(now identified as Beta) andTokens (classic). If you see these two options, we recommend usingTokens (classic). Don't mess with beta products while you're learning if you can help it.

   And use itTokens (classic), clickGenerate a new tokenon the page that appears, then selectGenerate a new token (classic).

   You may need to verify your account at this point, but after that you should be able to proceed with the instructions below.

5. Select the ranks to which you want to assign the token.achievesthey are a way to set permissions for users who can access the token.

   Since this token should only be used for your purposes, we recommend not limiting the scopes and checking all the checkboxes as shown below. If you work with other people or organizations and want to give them different levels of access to your repositories, you can generate new, separate tokens and set the appropriate scopes.

   

6. Click "Generate Token".

   

7. Copy the token ikeep it for future use. You should treat this token like any other password. Consider using a password manager like LastPass or another secure way to store your token. It is also recommended to cache the token in Git usingcache help. This allows you to enter the token as a password when you first authenticate and retain your credentials, so you won't be prompted again until the specified timeout expires. If you are working in a Cloud9 environment, please follow the "Linux" instructions in the link above.

   Note: GitHub's credential caching in Git does thisNOstore your token permanently and therefore should not be used as the only way to secure your token.

8. You should now test that the token works as intended by using it in the "password" field when signing in to GitHub in the next section.

   If you choose to set up your account with alternative security mechanisms such asTwo-factor authentication (2FA), you can now use this PAT as a starting point for authentication from the command line.

git push

You can create a branch in your local repository (note that each repository starts with aprincipalindustry standard) totoo muchbranch in your remote repository. If you use a command that interacts with a remote repository and you don't specify which branch to interact with, the tracked branch will be used.

Now that we've laid all the foundations we need to push our code to GitHub, let's get to it!

Type the following command at the command line:

$ git push -u principal principal

Z-tuflag tells Git to set the default valueupstreamrepo - which is the external repository you want to use by defaultGod,bitchand similar operations. In this case, we use the so-calledprincipalbranch inorigenrepository, which is short for default remote repository. (Nameorigenis conventional in most cases, although other names are sometimes used). After running this command, you can usegit pushWdraw gitwithout specifying a repository or branch name.

If you've never uploaded anything to GitHub before, you should now see a login prompt:

$ git push -u origin mainUsername dla „https://github.com”:

After successfully logging in, you should see a message that your objects have been saved. You will also see a message that you have set up your localprincipalfollow the pilotprincipalbranch, thank you-tubandera.

$ git push -u origin main Username for "https://github.com": joesmith2444 Password for "https://joesmith2444@example.com": Count objects: 5, done. Delta compression with up to 8 threads. Compress objects: 100% (2/2), done. Object write: 100% (5/5), 368 bytes | 0 bytes/s, done. Total 5 (delta 0), reused 0 (delta 0) To https://github.com/joesmith2444/my-first-repository.git *[new branch] main -> main branch root configuration follow remote main branch from the origin.

Again, here's the task breakdown.

Video review: git push

draw git

Sometimes the code in your remote repository contains commits that you don't have in your local repository. In these situations, you must download commits from the remote repository to your local repository. There are four basic scenarios when you run into this:

1. You work as a team and several people have uploaded code to a remote repository.
2. You uploaded it to a remote repository from another computer.
3. Your project is public on GitHub, and someone contributed to it.
4. You made a change to a file directly on GitHub.com.

github.comIt allows you to edit files directly on the website, but behind the scenes, this container is edited directly on the commit to the remote repository. This is not a good habit and is only recommended in very rare circumstances.

The first two scenarios are by far the most likely scenarios, while scenarios 3 and 4 are quite rare.

While making changes using the GitHub editor is not recommended, we'll use this method to simulate and walk through this workflow.

The first thing we need to do is check the remote repository. To do this, visithttps://github.com. At the bottom right of the screen, you'll see a list of the repositories you currently host on GitHub.com.

Note: The GitHub interface can change over time, so these images may be out of date. If you see something else on the screen, don't panic. You should still be able to find the information you need, although you may have to do some searching.

Clickmy-first-repositoryrepo and you will see the files we uploaded earlier in this chapter.

Please note that the content ofLEESMIJ.mdthe files are listed below the file list. It allows you to easily create documentation for your project, which GitHub displays automatically.

Now we need to make a change to the file. ClickLEESMIJ.mdthen click the pencil icon above the file contents.

Edit the content of the file with the editor and scroll down. You will see two input fields. These fields allow you to create commit messages for the remote repository, just as you dogit cometer -mcommissioned our local repository. Write your approval message, then click the buttonMake changescommand.

While GitHub gives us a nice UI for editing files, making changes to its UI has the same effect on a remote repository as modifying a file locally and then using it.add gitWgit capturedoes in our local repository. Again, for the purposes of this book, we're only editing files directly on GitHub, because that's something you rarely want to do in real-world projects.

Then we go back to our terminal and work with our local repository. We need to monitor our remote repository for changes. The first thing we must do isto recoverrepository which will get the commit data for each branch that contains the remote repository. Because we are currently working with our localprincipalramaget gitthe command will get the commits from the remote repository that contains the tracked remote branch.

On the command line, enter:

get $git

You should see some messages related to git remotely fetching changes. If you don't see any messages, your remote repository has no changes.

$ git fetchremote: Count functions: 3, done.remote: Compress functions: 100% (2/2), done.remote: Total 3 (delta 1), reused 0 (delta 0) Extract functions: 100% (3/ 3 ), made. From https://github.com/joesmith2444/my-first-repository 5afaf12..9389be5 main -> origin/main

The next thing we need to do is look at what has changed. we do it usingdifferenceDomain. On the command line, enter:

$ git diff home main/main

This gives the following result:

$ git diff source main/maindiff --git a/README.md b/README.mdindex 0647d92..56289ec 100644--- a/README.md+++ b/README.md@@ -1.0 +2.4 @@ ++This is my first GitHub repository!++Here's more text.

Salidagit differencethe command shows some changes in oursLEESMIJ.mdarchive. Let's take a closer look at the output.

First we run this command:

$ git diff home main/main

This command tells git to runprincipalbranch in your local repository toprincipalbranch in remote repository (origin/head). In other words, we compare the last commit in the local repository with the last commit in the remote repository. This chain treats the local repository as original content and the remote repository as updated content.

$ git diff prop/main main

Zgit differencethe command compares all files in the first repository (local here) with the corresponding files in the second repository (remote here). Individual differences start with a line that looks like this:

diff --git a/LÉAME.md b/LÉAME.md

This shows that we are doing git diff on a file namedLEESMIJ.md. A file name starting withA/comes from the first repository ingit difference(local) command, whileB/refers to the second (remote) repository.

Then there's some cryptic output that you can ignore for now:

indices 0647d92..56289ec 100644

Now we see the following:

--- a/LÉAME.md+++ b/LÉAME.md

This means that the output will use a-at the beginning of a line that only appears inAfile (local repository) i+it shows lines that are only present on the remote control. you can think+as added lines and-as deleted lines. If the rule is different on both the local and remote repository, you will see both files+W-output rules If some lines have not been changed, they start with a space if they appear.

The following line shows where the specific difference occurred:

@@ -1,0 +2,4 @@

They're a bit hard to read, but they do represent the line numbers in the file.-W+files. In this case, we're looking at a single line starting with line 1 of the local repository.LEESMIJ.mdand 4 lines starting with line 2 of the remote repository version.

Finally we see the differences:

++This is my first GitHub repository!++Here is more text.

Here we see the differences as four additional rows from the remote repository, each with the prefix+indicates a new line.

Reading the differences can be a bit tricky at first. However, with practice, you can learn to read them. The most important thing to remember is this+represents lines added from the repository specified second on the command line, while-represents lines deleted from the first specified repository.

After making sure that you want to download the changes to your local repository, type:

$git pull --ff-solo

from a localprincipalthe branch is configured to useorigin/headbranch, you do not need to specify which branch you want to search for.

Remember that you can also writegit pull --ff-solo origen principalif you want to specify exactly which remote repository (using an alias) and which remote branch you want to search from. The commits are retrieved and merged with the current branch you are on in your local repository.

$ git pull --ff-onlyUpdating 5afaf12..9389be5Fast forward README.md | 4 ++++ 1 modified file, 4 inserts (+)

Now if we open our placeLEESMIJ.mdin the text editor, we'll see the changes we made to our remote repository using the GitHub editor.

#README #This is my first GitHub repository! Here is more text.

Your local repository is now identical to the remote repository and you can start working on your files locally again. You can make changes to the README file, commit the changes, and upload them back to GitHub.

some things to remember

1. Z--ff-ampart of this task ischoicethis is passed to the command. SpeakslocoExactlyAswe want to try to connect the remote changes to our local branch. In this case, it tells git to get the file toforward quickly to combinecombine the changesfHello). You don't need to understand exactly what it means or how it works, but it conveys the story of a local establishment in simple words.nextto match the history obtained from the remote branch. He-FairHolajust ffmeans yesloco Can'tcombine changes with fast forwardto combineshould stop merging.

2. There are other options you can go throughdraw gitcombine changes in different ways, but that is beyond the scope of this book. Until you start collaborating and/or with several different branches,git pull --ff-soloshould suffice in most situations where you needbitchchanges from the remote repository.

3. And use itdraw gitno options for example--ff-am,locodecide for yourself how best to combine the changes. In general, though, it's good practice to be specific about what you want.locoDo. Of the version2.26.0vanloco, If youdraw gitWith no options, you will see this message:

   note: it is not recommended to draw without specifying how to reconcile diverging branches. You can suppress this message by running one of the following commands some time before the next lookup: git config pull.rebase false # merge (default strategy) git config pull.rebase true # rebasegit config pull.ff only # fast-forward onlyYou can replace "git config" to "git config --global" to set the default preference for all repositories. You can also pass --rebase, --no-rebase, or --ff-only on the command line to override the default value configured for the call.

4. can you onegit pull --ff-solono prior useget gitand checking the changes withgit difference. You should only do this when you areSurelythat you want to remotely bind the changes to your local branch without having to check them out first.

5. if you already have itget git, thatable toto usegit merge --ff-onlyinsteadgit pull --ff-solo. Actually,git pull --ff-solocombinaget gitWgit merge --ff-onlyin a single command.

Video review: git pull and git fetch

This first review video describes how to use it.get gitWdraw gitseparately, while the other is about how to simply usedraw gitOn my own:

go to clone

What is a git clone?

So far we've talked about merging an existing remote repository with an existing local repository. But what if we don't have an existing local repository and just want to get all the content from a remote repository? That's truego to cloneenter Creates an exact clone of an existing remote repository and copies it to the local machine. The cloned local repository contains all the files, commit history, branches, and everything else related to that git repository.

Zgo to clonethe command has several options, but most of the time it only needs basic usage. This is what it looks like:

$ git clone 

This is what it looks like in action:

$ git clone https://github.com/bob/example.git my_amazing_project Clone to "my_amazing_project"...remote: Feature count: 218, done.remote: Total 218 (delta 0), reused 0 (delta 0) Items received: 100% (218/218), 180.21KB | 0 bytes/s, done. Delta solution: 100% (54/54), done. Checking connectivity... Done. $ lsmy_awesome_project/

Several things happened in the above command:

1. A new local git repository has been created in a directory namedmy_big_project.
2. All content in the remote repositoryhttps://github.com/bob/ejemplo.githave been downloaded to the newly created local repository.
3. Added a remote to the local repository config that points to the remote repository URL, with an aliasorigen. is the same as expensesgit add origin remotely https://github.com/bob/example.gitfrom your local repository directory.

This means that it is now possiblegit pushzdraw gitfrom the newly created local repository to/from the remote repository.

When to use "git clone"

go to cloneIt is mainly used when you need to work with a remote repository and you don't have a local repository created yet. For example, if you've just joined a new project, the first thing you'll probably do isgo to cloneproject to start working on it locally.

Another common use case is to tear down an open source project. For example, to view the source code for the popular open source web development platform, Ruby on Rails, you can run this command:

$ git clone https://github.com/rails/rails.git

Note that we don't specify the second parameter, the directory name. If you don't specify a folder name as we did here, the default behavior is to create a new folder with the same name as the cloned repository. In this case, the directory is calledrails.

After running this command, you should have a folder calledrails, a local git repository that contains all code and content from the official Rails repository. Also, this local repository will have a remoteorigenwhich points to the official Rails repository. Unfortunately, this doesn't mean that you can send commits to the official Rails codebase now. While you can set it up as a remote repository to your local repository, you still need permission to upload to the actual remote repository which you don't have. However, you can dig in and make changes to your local repository.

Video Review: Git Clone and Fork

Call theme git init i git remote

Of dry commands,begin,go to cloneWgit add source remotelythey're very similar to begin with, so let's see when you should use them.

To restore

Let's recap what just happened in this chapter:

• First, we create a repository ingithub.comand chose not to initialize it with files, leaving a blank tab.
• We then notify our local repository of our newly created remote repositoryremote git add source REMOTEURL.
• We then push some commits from our local repository to our remote GitHub repository usinggit push.
• So we made a changegithub.comdirectly, simulating a coworker pushing commits on our pilotgithub.comrepository
• Finally, we push these commits to our local repository withdraw git, sync our local repository with our remote repository.
• We also learned a bit.go to cloneit is and how you would use it to work on an existing git repository.

As you can see in the steps above, working with git requires very detailed orchestration to keep all repositories in sync: your local, team members, other machines, and finally the central repository.

You may already see that there are a lot of potential problems lurking around, but don't worry about it just yet. Over time, you'll learn how to handle conflicts and how to work with advanced git workflows. For now, focus on working with git and GitHub on a one-man project.