Gain insights into the command-line interface, delve into navigating file systems, creating scripts, and automating tasks to enhance productivity and control your computer efficiently.

Small, Sharp Software Tools by The Pragmatic Programmer_ .png

ubuntu.tar.gz

Python job

ncjob

In this course, you will get the chance to explore the command-line interface (CLI), starting with basics like navigating file systems and working with directories and files. Then, you will use those building blocks to tackle more advanced features and tasks within the CLI. You will also learn to turn basic commands into executable scripts and easily automate common tasks. This course will empower you to put the interface to work, take complete control of your computer, and hack your way to productivity.

Harnessing the Power of the Command-Line Interface

# Appending and prepending 
As we learned in the earlier lessons, the `PATH` environment variable determines where the shell looks for executable programs. We may want to add additional directories to the list.

One common approach is to create a local bin folder in the home directory to hold executable scripts we create ourselves. This way, we don’t have to move executable scripts to a directory like `/usr/local/bin`.

When modifying the `PATH` variable, we usually want to append or prepend a directory to the list. Rather than setting the entire `PATH` value, we use the existing value. Let’s add the following line to the `~/.bashrc` file to prepend the `~/bin` directory to the `PATH` variable’s value:

```bash
export PATH="~/bin:$PATH"
```

We use double quotes around the value to ensure that any spaces in existing path names are preserved.

A colon separates each directory in the PATH value. In this case, we put
`~/bin` first, followed by a colon, followed by the current value of `PATH`.

When we execute commands, the shell searches through directories in the `PATH` variable one at a time, executing the first command it finds. By prepending `~/bin`, it’s now possible to add our own commands in the `~/bin` directory that override any built-in commands.

Let’s try it out. First, we save the file with `Ctrl+o`, followed by “Enter.” The settings we added to this file won’t be applied to the current shell session, and we want to keep the text editor open since we’re not done changing this file yet. We want to open a new shell session instead.

In the new session, we create the `~/bin` directory:

```bash
$ mkdir ~/bin
```

Now, we create a new executable script in that directory. In [Locating Executables with PATH](https://www.educative.io/courses/harnessing-power-command-line-interface/locating-executables-with-path), we created a simple greetings script which we copied to `/usr/local/bin`. Let’s create a new version of that script that displays a different message:

```bash
$ cat << 'EOF' > ~/bin/greetings
> #!/usr/bin/env bash
> echo Hi there
> EOF
```
# Executable scripts
Let’s make the new script executable:

```
$ chmod +x ~/bin/greetings
```

We use the `which` command to verify that we’re using the new file:

```
$ which greetings
```

Because the `~/bin` directory is the first entry in `PATH`, this will be the command executed rather than the one in `/usr/local/bin`:

```
$ greetings
```

Run the complete code on the terminal below for practice.

```bash
cat << "EOF" > /.bashrc
# START:return
[ -z "$PS1" ] && return
# END:return

# START:histcontrol
HISTCONTROL=ignoreboth
# END:histcontrol

# START:histappend
shopt -s histappend
# END:histappend

# START:histsize
HISTSIZE=1000
HISTFILESIZE=2000
# END:histsize

# START:histignore
HISTIGNORE="exit:clear"
# END:histignore

# START:editor
export EDITOR=nano
export VISUAL=nano
# END:editor

# START:path
export PATH="/bin:$PATH"
# END:path
EOF
mkdir /bin
cat << 'EOF' > /bin/greetings 
#!/usr/bin/env bash
echo Hi there
EOF
chmod +x /bin/greetings
which greetings
greetings
```

Learn how to modify the PATH variable in a shell session.

Introduction

Creating an Ubuntu Virtual Machine with VirtualBox

Navigating the Filesystem

Working with Files and Directories

Streams Of Text

The Shell and Environment

Running and Managing Programs

Networking Tools

Automation

Additional Programs

Conclusion

Modifying the PATH

Appending and prepending