So, we saw how to run a basic command.

Now, let's learn a few more.

In the command line, you're always somewhere in the filesystem of the computer.

Much like how you navigate through folders using Windows Explorer or Mac OS Finder,

there are multiple levels of folders that you can navigate through in the console.

Folders contain other folders, often nested several levels deep.

You've probably seen this represented as the file tree

with each level of depth indented another level

representing the file system as a whole.

When using Linux or other POSIX operating systems,

what you call a folder is usually called a directory.

This is because they were called directories long before the desktop

was invented, and metaphors to real items like desktops, windows,

and folders were used.

Folders and directories are the same thing, but we'll be referring to them as directories.

So, let's find out where we are.

In order to find out the directory you are in, there's a command called "pwd."

Pwd stands for print working directory.

Again, like any other command, we can type in "pwd" and then hit enter.

The output of this command is the path to where we currently are in the file system.

Right now, we are in the default location that we were placed when we logged in to the computer.

This is /home/treehouse, and this is something called our home directory.

In most operating systems, you have a special directory called your home directory.

This is where directories like my documents and pictures exist.

There's a different home directory for each user on the computer.

On Linux, this directory is in /home/username.

In our case, our username is treehouse, so our home directory is in /home/treehouse.

On the Mac, the home directories are in /users/username.

This directory is so special that it has it's own shortcut name--tilde.

This means "my home directory."

In fact, that's why there's a tilde on your prompt.

Instead of showing you the full path, it's showing you the abbreviated path.

So, the tilde just means that you're at home.

Now, let's move around.

So, we see where we are--we're in our home directory--and we can move around.

Now, we saw LS before, so we can get our bearings a little bit more.

Pwd tells us where we are, and LS tells us what's available in the directory we're currently in.

We're currently in our home directory, which contains a documents directory that we could move into,

and a hello.txt file.

So, let's move into the documents file.

So, how do we do that? We use the "cd" command.

Cd stands for change directory, and like it would imply, it changes the current directory we are in.

So, the way we use that is type in "cd" and then wherever we want to go.

In our case, we want to move into the documents folder,

so we can type in "documents."

Now, here's a cool tip: In most environments, not all--again, this is a luxury not a necessity--

there is something called tab completion.

The console that we're interacting with or something we call the shell

that is actually handling our keystrokes, can actually do some pretty cool things

with tab completion. Since it knows all about the files and folders on our computer,

It can fill in things for us.

For instance, after we type in "cd" if we type in "do" and we could just hit tab,

it's going to fill in the rest for us.

If there's multiple options, we may be able to tab through it using multiple tab presses,

or it may tell us what our options are so we can type in a little bit more of our option.

This tab completion is really nice because it allows us to move around fairly quickly.

You'll notice the trailing slash.

It doesn't matter in this case. The slashes separate multiple levels of directories

that we want to move through.

So, if there was another directory inside of documents, we could type in another directory.

However, I only want to move into documents, so this is fine.

The trailing slash could be there or it could just do without.

So, now that we see, though, there's something a little bit different.

Our prompt has changed.

It still has our username, but now our current directory has changed a little bit.

Instead of being the shortened home path of just tilde, it's now tilde/documents,

which means it's our home directory,

and inside of that we're currently in our documents directory.

And this is where our prompt is very useful.

It's telling us where we are, which gives us some context as to what we can do.

So, now if I were to type in "pwd" or print working directory,

it's now /home/treehouse/documents.

And if I type in "ls," we can see that there's a file here called "How to go home.txt."

Now, we'll learn about how to actually read and edit that document in a little bit.

But, let's keep learning how to move around.

What we did in this command here is type in "cd documents,"

and this is what we call a relative path.

Because we were currently at the time in /home/treehouse which had a documents folder,

we're able to specify in relative terms where we wanted to go

because the documents existed in our current directory.

However, we can use an absolute path as well.

But, let me show you something.

If you type in "os," you see that there's only that one file.

So if I were to type in "cd documents" again, it wouldn't make sense

because there's not a documents folder in our current directory,

and so we can't go into documents through a relative command like this

because relative to where we are now, there is no documents folder

because we're in it and there's no extra folder called documents inside.

So, if we run into it, we're going to get a different output.

In this case, it says "-bash."

Now, bash is a program which we're actually interacting with right now.

It's called our shell.

Now, there are different shells, but bash is going to be the one you're going to probably

be interacting with the most.

Others are ZSH, CSH, TCSH, and pretty much anything that ends with "sh."

Now, most of them are similar; however, there are differences.

But when you see "bash," it just means the program that's taking our input

and handling things like coloring, as well as tab completion,

so it's something we can configure, but it's just the program that's really handling our input and output.

And because we typed in "cd documents," there's an error,

and so it's saying that cd had an error

that documents--there's no such file or directory,

so we can't just use the same relative path if the relative path doesn't exist.

However, we can move around with absolute paths.

Now, an absolute path differs in that it starts with one of a couple of characters.

One of those characters is a slash and the other is a tilde.

Now, there's some other ways to specify an absolute path,

but the idea is the absolute path starts with some point.

In the case of a slash, it means that we're specifying the full path of the directory

from the root or the top of our document tree.

You'll notice that in our pwd, the full path starts with a slash--

which means the top of our directory--and then there's a home folder

and then there's a treehouse folder, so we can use that exact same format

to move around with cd.

For instance, if we wanted to move home, we could do a cd/home/treehouse.

And you can see we're home.

Again, in our prompt we see the tilde which is the shortened version of our home directory,

but if we type in pwd, we can see we are exactly where we wanted to be.

And so that was an absolute path, because it began with a slash meaning our root.

There's also another one we can use, our tilde as our starting point

which means that we want to give a full path starting at our home directory.

For instance, if I was in the /home directory by going to cd/home,

we could type in "pwd," and we see our home directory.

Now, I'm going to clear it to bring our prompt a little bit higher,

so we can see everything, so I'm going to type in "clear."

And the only thing this does is it just moves our prompt to the top.

We could still scroll up to see our previous inputs.

So, if we type in "pwd" we can see we're at /home,

but if we wanted to go to the documents directory inside of our home directory,

we could use cd/home/treehouse/documents.

But remember, /home/treehouse is the same as our tilde.

So, instead we could use a different absolute path by starting with our tilde

and then typing in "/documents."

And this is really useful, because a lot of the files we want to get to are often

relative to our home directory, so the tilde is a nice shortcut.

No matter where we are in the file system, we can move to a directory

relative to our home directory by using the tilde.

So, if I go to cd ~ /documents, we can now see we are in ~/documents,

and typing in "pwd" prints out /home/treehouse which is our home directory,

and then we're in the documents directory.

Now, what if we want to go back to our home directory?

We saw a couple ways we could do that.

Another is to just type in "cd ~."

Because that's our home directory.

That should be pretty expected.

So, if I move back into documents,

we're going down into our documents directory from our home directory,

but what if we want to go back up?

We can use another type of relative URL,

and this is a special thing called the ".." which represents going up a directory.

So, right now we're currently in /home/treehouse/documents,

if we wanted to go back up a directory, and let's ignore the fact that's the home directory,

so there are a ton of different ways we could get there.

If we wanted to get there by going up, then we can use the ".."

So, if we type in "cd.." we've actually gone up a directory,

and now we're in /home/treehouse.

And this works just like any other path name, so we could go ".." going up a directory,

but we can also separate it with slashes and maybe use another ".."

to go up another directory.

And now we can see we're at the root directory,

and if we typed in "pwd," we're at the very top of our tree.

So, we actually can't go up any higher.

If we type that, we're just going to end up at the same place.

Now, it's interesting to note that the ".." can be used as part of any file path.

So, for instance, if we type in "cd/home/treehouse--our home directory--

if we were to type in ".." that means we want to go to the home/treehouse but then up a level.

So, we're actually saying "home."

And that's exactly where we end up.

So, if we were to do something like that again,

we could actually make a pretty complicated path by going up and down and around

and you can just use it as any other folder name.

I'm going to show you something cool. Another thing that bash provides us,

along with tab completion, is history.

So, if you use the up arrow key, in most situations it should give you the last command.

If you continue going up, you can scroll through your history,

and use down to go either direction.

So, if I want to recall the last cd command I did, I just scroll up until I find it,

So, this says we want to go to /home/treehouse, back up to home,

we can go to treehouse again, and that would have the effect of going to our home directory.

That's pretty convoluted, but if you're in a directory and you need to go up some levels

and then back down, you can use the ".." just like that.

So, now we know where we are.

Next, let's actually manipulate some of the files.