So you can run commands at a prompt.
But what is that prompt?
Where does that come from?
How are your commands going to run and why does it matter?
You will get an answer for these questions in this lecture.
My name is Stephan.
Welcome to another lecture of our course.
Let's get started.
That little prompt is produced by a program called Shell.
Let's actually get our diagram here so we can write things better on screen.
So here so the so the little prompt is produced by a program called Shell.
Shell.
So it's a user interface that sits between you and the Linux interface here.
So here, for example, in the left side is this is you here and here.
This is our famous penguin.
So I can draw Penguin right now, but I will try.
Try here.
So this is our penguin here.
And here, This is our penguin.
Yeah.
Here.
So this is the shell that sits between you and the Linux operating system.
So Linux supplies several shells.
And the most common and the standard for this course is called the bash shell.
So actually, let's actually write this.
So we're going to use that as Oops, yeah, now we're going to use that as a bash shell.
BASH So this is just a standard that while most widely use shell type in Linux here, so Bash and other
shells do much more than simply run commands, for example, for example, actually, let's delete this.
Yeah.
For example.
When a command includes a wild card here.
So this is a wild card.
This is a wild card.
Operator.
Uh, this referred to multiple files at once.
So for example, LHS here, LHS here in let's actually go to bin.
So we have more files on bin here.
So for example, LHS.
Let's find the sea here.
And as you can see, we get sea files.
Not like this, LZ.
Like this.
And as you can see, no such file or directory.
So, for example, the we access the multiple files at once, but in this case we don't have a C file
here.
So let's actually, instead of writing, uh, finding folders, let's go to Python here.
So I think we're going to have Python three point.
Trip.
Python three point.
Yeah, that's.
That's actually fine.
This here.
Let's actually.
Here, here, here.
Open SSL.
So let's go to open SSL.
Open SSL, TLS.
So let's look what we here.
See the open SSL directory?
Yeah.
Open.
Apparently the file.
Yeah, that's it.
So for example, ls something like that you're going to see all of this here.
So the file wild card here, we will use the wild card in the next lectures too.
So the wild card is a handled entirely by the shell, not by the program ls here.
So the shell value is the expression here.
For example, let's actually write this like a clear CD home and Carly.
Oops.
Carly here.
So.
If here, for example, LHS.
Yeah, the R code here.
The wildcard operator, for example, ls the.
Dot py or LZ txt.
We have txt files.
Right?
And as you can see we got on here.
So if we copy this txt files right now and here let's open our text here right now.
Axel txt copy copy here.
Like this.
So now.
Yeah.
Here.
And as you can see, we got all the copies here.
So here.
The wild card.
And as you can see here, the shell evaluates the expression the wild card operator, dot txt and invisible.
Invisible replaces it with a list of matching file names before LHS runs.
So in other words, LHS never sees the wild card here.
So for the perspective of LHS, the type following command is going to be, for example, LHS, the
Oxley.
Oops.
Actually, let's first say yeah, Oxley here, LHS Oxley copy, for example.
Copy one and copy one.
Yes.
Or no, we don't have a copy ten for example.
And after that TXT and then it comes Oxitec's or like Oxley again.
Oxley.
Copy.
Oxley.
Copy.
TXT.
Copy, for example.
Yeah.
8 or 6 here.
Okay, so copy like this.
And here, as you can see, we got an error.
So our this wildcard operator sees like this.
So the shell also handles pipes, as you saw in the first section of our this course.
So it redirects the STD in an STD and transparently so the that the programs involves have no idea they
are communicating with each other.
So every time a command runs, some steps are the responsibility of the invoked programs such as LHS.
So at some there are the responsibility.
Uh, here are the responsible of the shell, so expert users understand which is which.
So that's one reason they create a long, complex command of the top of their head and run them successfully.
So they already know what the command will do before they pass.
Uh, press enter.
So in part because they understand that separation between shell and programs it invokes.
So in this lecture we will launch you understanding of the Linux shell.
I will take the same minimalistic approach I use for commands and pipes in previous lectures rather
than cover dozens of shell features.
And I will hand you just enough information to carry you to the next step of our learning journey.
So in this lecture you will learn about the pattern matching for file names, you will learn redirection
of input and outputs.
You will learn variables to store valuables quoting and escaping to disable certain shell features.
The search path for locating programs to run and you.
Lastly, you will learn how to save changes to your shell environment.
So I'm waiting you in the next lecture.
See you later.