? music playing? [Deep Dive] [Console]

We've seen that our programs and commands can take arguments

and options as the input that affects the behavior of the program.

But there is another thing that a program can use to change

the options around--

the environment.

Specifically, environment variables.

Environment variables are just like variables in any

programming language in that they store

a value associated with a name.

When it comes to the console,

our environment variables will be written in all upper case

and the values they hold will be strings.

We can create our own environment variables,

but there are many that the system uses and expects to be defined.

Some of these are home, path, and PS1.

Home is the path to your home directory,

and the path variable is a list of locations where programs are stored.

The PS1 variable defines the format of your command line prompt.

Changing any of these variables will change how the system behaves.

Let's take a look at how to work with environment variables.

Our console session has many environment variables already set.

If we want to explore what those variables are,

we can use the command env for environment.

Now by running this,

it will print out all of the environment variables.

You'll notice that each line takes the format of a name, equals, and then some value.

The names are the names of our environment variables,

and you'll notice that they're all capitalized.

This is a convention for environment variables to be in all caps.

On the right hand side of the equal sign is the value that

that variable currently holds.

Now many of these are set by different configurations files on our system,

but if we take a look at a few of them they might seem familiar.

For instance, you'll notice our home variable,

which currently has the value of /home/treehouse.

Another interesting one is our PS1.

This defines what our prompt is.

Right now it holds the value of /u /w and the dollar sign.

These backslash characters are special sequences that allow us to

insert dynamic information into our prompt,

and it's used by bash to dynamically create this prompt.

So our prompt isn't defined to literally say treehouse or literally have the tilde.

Instead when the prompt is actually printed,

this /u is replaced with our user name

and the /w is replaced with our current working directory.

This is what allows our prompt to change as we move around.

You'll notice our prompt just changed.

Now many of these we don't have to worry about.

For instance, this long one here is set by

some configuration file and it actually

defines the colors that are used when we

use the ls command.

If we were to change this particular string,

we would get different colors based on the different file types.

Some of this is set by the environment that we are logging in with.

But this nth command isn't really what we use the environment variables for.

This is just a useful command for seeing what our current environment is.

Let me clear out the screen.

We can actually retrieve the values stored in our environment variables

from our command line.

The way we do this is with the dollar sign

and the name of the environment variable.

When we use such a thing,

it will be replaced as though the value

was placed into the command, not the variable itself.

I'm going to use a command called echo.

Let me show you how it works.

It literally just echoes back the arguments that we give it.

So for instance if I said echo hello,

the command will print out hello.

But if we use an environment variable,

echo $HOME,

the command line will expand $HOME into the actual value

before evaluating and passing to to echo,

which means echo won't receive the characters $HOME,

instead it will receive the actual value.

So if we do echo $HOME,

it's going to print out what it got,

which is /home /treehouse,

which means any time we use an environment variable like this

it allows us to use the value of that variable.

So if we were to do cd $HOME,

what would happen?

Well this is equivalent to calling cd /home /treehouse.

So it would take us home.

Let's clear this out again.

We remember there is another variable called PS1.

If we want to see the current value,

we can use the echo command again.

PS1.

We can see the value printed out.

Now this variable is set in the configuration file

that's run whenever we start a new session.

But we can actually change PS1.

The way we do that is by typing the name of the variable

PS1.

This is without the dollar sign.

When we're setting it, we do not use the dollar sign.

However, when we are expanding it, we do use the dollar sign.

So the dollar sign is not part of the variable name itself.

Its actually what specifies that we want to expand it out.

So when we're setting it, we give it the name

without any spaces.

We put an equal sign,

and now we can give it a value.

Now we can use quotes around it,

which will make it slightly easier for us to use.

Quotes on the command line allow us to use some characters

that would normally be expanded differently,

but allow us to use multiple words and some other special characters.

So if I were to simply put /w

and maybe we didn't want a dollar sign--

we wanted a greater than sign--

we could do this.

Now as soon as I change this,

you'll notice our prompt change.

That's because the prompt is always using the value of PS1

to determine how the prompt will be set.

We could change it to whatever we want.

Now our prompt is changed.

Now if we wanted to see if this was really set,

we can echo PS1,

which would of course give us the prompt.

This prints out the value of PS1.

Then this is our actual prompt

Because they're the same thing,

it appears that it printed out twice.

But this one is the output of the echo command,

and this one is our actual prompt.

If we were to do env and find PS1,

we can see that the value has been updated.

Let me go ahead and clear the screen.

Now here's something interesting.

We talked about how bash is the program we're interacting with.

It's the thing that is actually interpreting the prompt

and printing it out and handling our keystrokes

and things like our tab completion.

Bash is actually a program that's started for you

when you connect to the machine.

You don't start it yourself.

However, you can start a new session.

If I type in bash, it looks like it changed our prompt back.

But what's actually happened is we've started a new instance of bash.

Our old one is still running with our old prompt.

However, inside of it we're now running a new version, and

because our prompt is set in a script that is run as soon as

we start up our bash script,

our changes to PS1 have been erased,

at least in our session.

If we take a look at the environment,

we can see PS1 has been reverted.

Now I'm in a bash right now,

and if I were to exit it by using the exit command,

this is going to stop the instance of bash that I started a moment ago

and take up back to the original one we connected with,

which is still running.

You'll notice our prompt changed.

Now exit will take you out of your prompt.

Now we're kind of at the top level now.

We're at the bash that was started for us when we connected to our machine.

If we were to type it again,

it's actually going to stop that,

which will actually disconnect us.

You'll notice our tab disappeared because our connection is gone.

If that ever happens,

just go ahead and click plus there to create a new tab

and give it a moment to connect.

Now we've created a whole new session,

and of course our PS1 has been updated.

We can set any variables that we want.

For instance, if I wanted to create an environment variable

called message,

all I have to do is set message equals hello world, and

I can use this however I want.

I could do echo $MESSAGE,

and our message would be printed out.

Now here's something--

what if I start up a new bash session?

In this one, I've set message to hello world.

If I open up a new bash,

it appears nothing has changed,

but now we're in a new copy of bash.

If I were to echo $MESSAGE,

we get nothing.

Now this is interesting.

We created an environment variable.

However, when we started a new process--

a new bash--

it went away.

This is not because it was overwritten in some file like our PS1 is.

It's because our message variable by default will stay in its own session

or its own process.

Now the bash that I created on this line is

a new process that is a child of our original one.

However, the message was not passed down to it in the environment.

We can, however, do that.

So I'm going to go ahead and exit the new bash that I created

just a moment ago.

Now we're back at our original bash session.

So if I were to do echo message,

we'll see it's still there.

It's actually a very important feature to allow our variables to be

passed down to processes that are created by our current session

or our current process.

The mechanism that we do this with is called exporting.

Right now, message is a local environment variable,

which means it's only visible to us.

If we run another program,

programs have access to our environment.

But it only has access to the environment variables that are exported

from the session that created it.

Since message isn't exported,

it's not going to show up as we saw when we created our bash.

So if we wanted to make message export

to any processes that we run

we can do export MESSAGE equals "Hi world."

Now we can still access it the same way--

echo MESSAGE,

and we see "Hi world."

However, if I start a new bash process from this bash process,

where before we lost our message.

If we take a look at echo MESSAGE,

we'll see that the environment variable

has been transferred down to us.

It's been communicated down to the new bash that we created.

So environment variables or custom environment variables

that aren't set by the system

are particularly useful for controlling programs.

Programs we write and other people write

have access to the environment variables of its own process,

which means any environment variable exported will be available to that program.

This provides us a mechanism for communicating

and configuring our programs.

For example, the LS command

uses the environment variable LS colors

to determine how things are colored.

You'll notice that our current configuration

has directories colored blue.

But different file extensions will have different colors.

This is what we see here.

The colors that we see here aren't hard-coded into LS.

Instead, it's configured by our environment.

These variables are often used in all sorts of programs that we write.

For instance, to configure port numbers or environments

or even credentials to data bases--

you can store in the environment,

which allows you to store information

not in a configuration file

but in your computer's environment itself.

One last environment variable that is very important for you to understand

because it's the one you'll probably be modifying the most

is called the path.

Let me clear the screen.

If I echo an environment variable called path,

we're going to see this string.

This is a list of directories separated by colons.

What this represents is the list of directories to search for

when we run an executable.

For instance, when we run echo,

this is a command.

It's a program that actually exists as a file on our computer.

We can find out by typing which echo

exactly where it exists.

It exists as a file in /bin/echo.

Now we can run that by typing /bin/echo

and give it some information.

This is a way we would run our programs with absolute paths.

However, nobody wants to type the full path

to every command that they want to run.

Instead, we simply want to type the name of the command.

Well the way we do that is by using the path.

If we type a command

and it's not the full path to a command,

our computer will search in order of all of these directories,

looking for the echo executable.

It will first look in /user /local /sbin.

If there is no echo there,

it would go to this directory

looking for echo until it finally finds it.

As we see, bin is actually in /bin,

which is in our path.

Now the reason we use this is because sometimes we install executables

that are not in any of these directories.

However, we want them to be available to us.

We went them to be in our path.

So we can update this fairly easily.

From left to right is the search order.

So if we wanted to set a high priority.

For instance, we created a new folder

called bin in our home directory.

If we wanted to put files in here,

which will be programs that we could run without giving the full path,

we would have to add this to our path.

So we would do export PATH equals,

and we want to modify it.

So one way we can do that is by giving our path--

we'll say /home/treehouse/bin.

This is the directory we want at the front of our list.

Each entry is separated by a colon.

Then we can tack on the rest of our list,

which is still in dollar path.

So what we are doing is we're saying

we're going to give path a new value.

It's going to be this path--a colon.

Then we are going to just put in the rest of the path.

So we don't have to type in the old one to modify it.

So if we run that and we check our path

by typing echo path,

we'll see our path has been updated now

If we were to put executables in this bin directory, it would be accessible

just like any other executable.

You'll notice if we type in bash and start a new process,

or we were to log in again,

and take a look at our path,

you'll notice it's been transferred down.

However, this isn't how we want to do this

because usually we have a start-up script

that will set the path itself.

Instead, what we want to do is place it in a file that will run.

If we were to close this session and start a new one

and we were to check out our path.

Now we wouldn't want to normally just export the path from our command line

because if the computer restarted

we would lose all of that--

it's not stored anywhere.

Instead, there is a file that exists

that will run every time we start up bash.

If we do ls - la,

we'll notice that there is a file called bashrc.

Now depending on your system,

this might be a different file

and you'll have to look up specifically which one you need to edit.

On some systems it's .bash profile.

If you're using a shell that is not bash,

it's going to be a completely different file.

But we can actually edit it.

So if I type in nano .bashrc,

this is a file that runs every time we start up.

Now most of this we don't have to worry about.

If I scroll down to the very bottom,

you'll notice our PS1 is exported.

Generally what you will do whenever you want to add something to your path

is type export PATH equals /home/treehouse/bin and path like that.

Usually you're doing this because a program you're installing

has asked you to update the path,

so you will update the path as needed.

But when you save this out,

the next time you log in that will run

and it will update your path for you.