In this lesson, we will practice using Bash commands in scripts and how to call other scripts within a script. We will practice making two scripts step-by-step.

Bash Scripting In Application

Let’s continue to work on the script that prints the directory structure tree. At the end of the last exercise, our script was able to print all nested subdirectories and files under a parent directory. In this exercise, we will add to the script. We'll use the `grep` command to filter this output to only include subdirectories, not files, and format it to better match a tree-like structure using `sed`.

The left side of the image below shows what our script’s output looks like now. The right side is what it will look like after adding the `grep` and `sed` commands.
![A screenshot showing 2 side-by-side terminal outputs of the tree.sh script. On the left is before the grep and sed commands were added. On the right is the output after those commands were added.](https://static-assets.codecademy.com/Courses/learn-linux/linux-shell-utilities/structure.png)
As you can see, the directory structure is a lot easier to follow after we will use the `sed` command to:
- Remove colons
- Use dashes (`-`) to differentiate between directory and sub-directory
- Indent to the right by three spaces
- Replace the first dash with a vertical bar (`|`)

Let’s make the output look nice!

Print Directory Structure Script II

The script we completed in the last exercise could have been a one-line terminal command run inside the desired working directory:
```bash
ls -R | grep ':$' | sed -e 's/:$//' -e 's/[^-][^\/]*\//--/g' -e 's/^/   /' -e 's/-/|/'
```
But this is a lot to type, and it's easier to edit and reuse a script. With a script, we can also save input arguments and provide additional options to the user. Then, we can share the script with anyone! The `tree.sh` script that we recreated in the last two exercises was [originally written by Dem Pilafian](https://centerkey.com/tree/).

Such powerful open-source scripts are available all over the internet and we should absolutely take advantage of them. We can use scripts inside our scripts as well! For example, a more feature-packed version of the tree script is available [by Steve Baker at Indiana State University](http://mama.indstate.edu/users/ice/tree/). We can install this script via this simple command in our own terminal:
```bash
apt-get install tree
```
Baker’s version features many options and better formatting thanks to several developers who contributed to it. Note the documentation as well!

Some developers have made collections of several handy scripts. One collection, called [Bash-Snippets](https://github.com/alexanderepstein/Bash-Snippets), provides many helpful utilities for the command line such as looking up the weather, converting currency, performing advanced numerical calculations, and even creating memes We can reuse these scripts in our own scripts!

In the next exercise, we will be using one of the scripts from the Bash-Snippets package to create a song-guessing game script.

Using Scripts Inside Scripts

In this lesson, we will explore the potential of Bash scripting. Since we can run any terminal command in a Bash script, there are truly endless possibilities. The ability to execute and link multiple commands with programming logic allows us to easily automate tasks and run configuration services.

Bash scripts are often the backbone of many services and servers! In the industry, scripts are commonly used for:
* Application installation or deployment. A script can contain instructions to compile, configure, and execute an application. Packages downloaded via the terminal with `wget` or `curl` are often installed and configured to the environment using scripts. 
* Automating tasks during a [cron job](https://en.wikipedia.org/wiki/Cron), which essentially schedules scripts to run. For example, a cron job might trigger a script to periodically check the health of a web API and set off an alert if the service is unreachable.


Scripts are great tools that can also be referred to by other scripts! That means we can reuse scripts others write on the internet.

In this lesson, we will practice writing two scripts:
- One that prints a file directory structure in a tree-like format.
- One that prints song lyrics and has the user guess the song name.

Introduction

Good job on making it through another bash scripting lesson! We have discussed how powerful bash scripts can be. Anything we can run on a Linux terminal can be run inside a script and vice versa. 

Here are some main points from this lesson on bash scripting:
- Bash scripts can execute any terminal command and script. The ability to link multiple commands and reuse scripts make them a powerful tool.
- Bash scripts can automate repetitive tasks and are often used in the installation of applications and running of online services.
- Useful scripts are plentiful on the internet. We can simply download a script and execute them with the options built-in. We can also run scripts inside of other scripts.

We have only skimmed the surface of possible applications of Bash scripts. Besides making tasks fly by, other applications for scripts include system administration, data crunching, and web application deployment.

We encourage you to practice these new scripting skills!

Review

Let’s work on a basic script that prints a directory structure in a tree format, which is useful for viewing nested subdirectories. The script takes advantage of the powerful commands that the Linux shell provides for file and folder operations.

We will be using conditional statements as well as the following commands:
- `echo`
- `cd`
- `pwd`
- `ls`
- `grep`
- `sed`
- `wc`

This script will take in an optional string argument: the parent directory that should be the starting point for the tree. If this is not provided, we will use the current working directory. We will print a message if the parent directory has no subfolders to print. If we find there are subfolders to print, we'll use a combination of the commands `ls`, `grep`, and `sed` to print the directory structure tree.

We will be working on the script named `tree.sh`, which is already opened in the editor.

Print Directory Structure Script I

In this exercise, we will be adding script code to build a simple game where the users guess the name of a song when its lyrics are outputted to the terminal. You may be wondering, how do we load in lyrics? We will take advantage of the script we ran in the introduction which fetches lyrics from the Internet. This lyrics script is a modified version of the [lyrics script provided through Bash-Snippets](https://github.com/alexanderepstein/Bash-Snippets/blob/master/lyrics/lyrics).

We have provided a code skeleton for the script we are writing in the file named `song_guesser.sh`, which is already opened in the code editor. As a quick overview, the code contains:
- A `while` loop to continuously run the game until the user wishes to stop.
- A `GenerateRandomArtistAndSong` function that populates the variables `artist_name` and `song_name` with a random song name and its artist.
- Statements to print the lyrics into the terminal and prompt the user to make a guess.
- Statements to tell the user whether they guessed the right song name and if they wish to play again.

To fill in the script, we will pass the song name and the artist to the `lyrics.sh` script, retrieve the lyrics returned from that script, and output it in this `song_guesser.sh` script. Let’s begin!