It's going to be about Git and GitHub, which are technologies

that you can use to do what's called version control,

keeping track of different versions of your program,

testing out new changes, et cetera.

All right, so before we get started, we'll do a quick introduction into kind

of what Git and GitHub it is all about, and what it can be used for,

and then we'll go more specifically into of the command

line commands that you would use in order to use some of this technology

and leverage it for projects that you're working on,

or projects that you're collaborating on with other people.

So first of all, what is Git?

What can it do?

The first, and one of the most important features for Git,

is that it can keep track of changes to your code.

So if you have code, you create a file, and maybe you're making changes,

Git will keep track of all of the different changes

that you've made to your code such that, at any point,

you can kind of go back and see the history of whatever it

is that you've been working on to see what were your earlier changes

and when did you make those changes.

And that can sometimes help when you're going back, and trying

to debug, and figure out what went wrong at some stage in the code process.

So that's one thing that Git can be useful for.

Another thing that it can be useful for is synchronizing

code between different people.

Especially when you're collaborating with other people,

Git is valuable for trying to make sure that your code potentially

matches the code that someone else is working on.

And at any point, absolutely feel free to interrupt me if you have questions.

If something doesn't make sense, I'd be happy to field questions as we go.

So imagine that you and a collaborator are both

trying to work together on the same piece of code at the same time.

So maybe that code lives somewhere on some server,

and there are a whole bunch of servers that

can host what we call get repositories, just

folders that contain files that are tracked via Git.

GitHub is one example of that.

So maybe both you and your partner need access to the same file.

Maybe you both make changes to that same file.

And what Git allows you to do is Git makes

it very easy to then take those changes that you both have made independently

and then kind of merge them back together when you push them back

online to the same file and then pull those back down to your own computers.

So that you both have the latest changes,

not only what you've changed on your file, but also

what a potential collaborator has made changes to as well.

And you both have the most recent, up to date version of the code.

And so synchronizing code between different people

is another really valuable thing that Git can be used for.

A third valuable thing that get can be fantastic for is to test

changes your code without losing the original.

It's all too common that, before I started using Git,

would try making changes to code to try to make it better

and then suddenly find out that the code no longer works.

And so my original solution to this was to do something

like make a copy of my original file, save the old one

and then make changes so that, if it messed up,

I could go back to the original one and not lose the original.

And that ends up getting very, very messy.

Especially if you get into larger projects, and working

with multiple people, you'll end up with a lot of different old versions

and it might be hard to keep track of.

So Git makes it very easy to save an original version of your code,

test out new changes that you might want to add,

and, only when you're sure that you like these changes, that they

work that you want to what's called merge them

back in with your original file, can you merge them back with the original file

that you were working on in the first place.

And the fourth and very valuable thing that Git can be useful for

is for reverting back changes to older versions of your code.

Say you made a change to your code somewhere along the way

and realized later on that that's not the change that you actually

wanted to make, and that you would want to go back to an older version.

Git makes it very easy.

As long as you know which version you want to go back to,

you can just go back to that old version and kind of start

over from wherever you were previously.

So that's sort of an overview of kind of what Git is

and the things that Git can do for you if you leverage its functionality well.

And now we'll begin to go into the actual commands

that you would need to use and need to type in order

to make all of this kind of work.

Questions Before we go on?

OK, fantastic.

So first command that will be really valuable to know

is what's called git clone.

git clone is a command you would type at the command line,

and I'll show you how this works in a moment.

And essentially, what git clone does is you

type git clone followed by some git URL where

that URL is the address of some GitHub repository-- and remember a repository

is just a collection of files and folders that are being tracked by Git--

and it'll don't make a copy of that repository that lives somewhere

on the internet, potentially on GitHub, but there are also

other services that do similar things.

And it will make a copy of that repository on your computer.

So you can begin to make changes on your own computer.

And side note, you can also do something called

Creating a fork of a repository, where if someone else owns

a repository online somewhere, you can fork it,

which just means you create kind of your own copy of that repository that

also lives online.

But we'll get to that potentially later.

So if this is Github, imagine this being some kind of server,

and this is a file that's being tracked via Git in some Git repository.

If I were to type git clone followed by the URL of that repository, then

this file, I would clone it, and it would

make a copy of the entire repository that is now saved on my own computer.

Make sense?

OK, fantastic.

The next thing that's important to know is a command called git add.

So git add is what you would do after you've cloned a repository

and so now you have a copy of that repository on your computer

and say you're making changes to that repository, changing the files,

changing the code, and now you want to say that the next time that git

saves a change to this repository, you want git

to save the change that you made to that file.

So let's show you what I mean by this.

Let's say that we've just cloned this file.

So this file now exists on your computer.

It's being tracked by a repository.

If I make a change to the code, maybe add a line to that code,

and I want to say that, the next time you save a change to this repository,

I want you to track that change, you would

say git add followed by the name of the file, whatever

that file happens to be named.

And then, it would, say change is to be committed.

And it would track that this is a change that you now want to make to that code.

So let me show you what that looks really quickly.

I have here GitHub repository.

So they usually live at some link, like github.com,

slash some user name-- my user name is [? BrianU28 ?]

slash whatever the name of the GitHub repository.

Is in this case, this repository is just called seminar.

Up in the upper right hand corner, you'll

see a button that says clone or download.

And if you click on that link, it will give you

a link that you can copy in order to clone

this repository to my own computer.

And so I could copy this.

And then I could go in to CS50 IDE.

And then, if I were to type git clone followed by that URL,

it would clone the repository and save it to my computer.

In this case, I've already done it, so I'm not going to do it again.

But you'll see, here, I have this folder called seminar.

And that folder is just my copy of the repository that exists on GitHub.

So we'll take a look at the file that's in here.

There's two files in here.

But [? swap.c ?] is the one that I'm interested in.

You might recognize this file from a previous lecture.

It was just the file where we kind of set

two variables equal to two different numbers in C, and we want to swap them.

But what you'll notice here is that this code is incomplete.

It says swapping right now, but we don't actually swap the values just yet.

So what I'd like to do now is I'm going to change this code

so that it actually swaps the two numbers.

And then I want to git add those changes so

that git knows that this is a new version of the file

that I want to save.

So I'll just quickly add the necessary code,

and those three lines are going to swap the file.

And so now if I cd into the seminar directory, what I can do

is I can add the changes that I just made,

and git will then track those changes so I can save them in the future.

And in fact, one kind of little tip that might be helpful

is that if I ever type [? git dif ?] at the command line,

it will show me all of the changes that I've made that I haven't tracked yet.

So I type git dif, and it shows me down here

that these are the three lines highlighted in green that I've added.

I added this in temp equals x, x equals y, and y equals temp.

And those are now changes that, the next time I add a file,

they're going to be tracked by git.

So I can do something like git add swap.c,

and that will add the swap.c file as a file

that I now want to track the next time I save a change.

So git add swap.c.

And so that now has been added to the changes that I want to track.

So what's the next step?

The next step is called git commit.

Once I've added all the files that I now want to save,

now I need to actually make the Save.

So git commit you might think of as the equivalent of telling git

to save a version of this repository.

So the syntax looks something like this.

You would type git commit followed by -m, and then,

in quotation marks, some message.

And that message is just going to be usually some summary of the changes

that you've made in this particular change

so that if anyone were to go back and look at what we call

the commit history, they would be able to see all the changes,

and when you made those changes, and what changes you made

at any given stage in this program.

So that's what git commit is.

And it saves those new revisions of a repository and kind of records

a message along with it.

And just as a side note, if you'd like to combine the adding

and committing steps together into one step,

this command right here git commit -am, a for all, or a for add,

will automatically add all the files that you've changed,

and also commit it with a commit message.

So you can combine both of these steps together.

So I'll show you what this looks like.

When I type git commit and follow it by kind of a message suggesting

what it is that I've changed, then what git will do is it will take my file,

and it will save kind of a new version of it.

It'll save this version, which says that I've added a line.

It saves the message along with the commit.

But it also still remembers that old version.

Such that if I ever wanted to go back to that old version,

I could still do that.