What's the one skill that turns a Linux user from someone who types commands one at a time into someone who can automate whole tasks in seconds? That's shell scripting. For the XK0-006 exam, you need to understand how to create and execute basic shell scripts because it's the foundation for system administration, automation, and troubleshooting — and it's a topic the exam loves to test.
Jump to a section
A simple way to picture Basic Shell Scripting
Ever watched a friend cook the same pasta dish over and over, but each time they have to dig through the cupboard, check the pasta box for timing, and taste-test the sauce six times because they keep forgetting if they added oregano?
What if they wrote down every step on a single card: 'Boil 500ml water, add 200g pasta, cook 11 minutes. While pasta cooks, heat 1 tbsp olive oil, add 3 cloves garlic, fry 1 minute, add 400g chopped tomatoes and 1 tsp dried oregano, simmer 10 minutes. Drain pasta, mix with sauce, serve'.
That recipe card is a shell script. It's a file that stores a sequence of commands exactly the way a person would type them into a terminal. The computer reads the script and executes each line in order, just like a cook follows a recipe step by step. But here's the important part: the computer doesn't get distracted, doesn't forget the oregano, and doesn't accidentally boil the pasta for 25 minutes. It does exactly what's written, every single time.
In IT, a shell script does the same thing. Instead of an IT person manually typing 'check disk space', 'delete old log files', 'restart the web server', and 'send a confirmation email' every day, they write those commands into a script file. The computer runs that script, making the process fast, consistent, and mistake-proof. Just like making dinner without the chaos.
A shell script is a plain-text file that contains a series of Linux commands. The 'shell' is the program that interprets and runs those commands — think of it as the translator between you and the operating system's kernel (the core of Linux). The most common shell on Linux is called Bash (Bourne Again SHell), and for the XK0-006 exam, Bash is the one you need to know.
Every shell script needs two things: a shebang line and executable permissions. The shebang is the first line of the script, and it looks like this: #!/bin/bash. That '#!' symbol tells the system which interpreter to use. If you write #!/bin/bash, the system knows to run the script using the Bash shell. Without the shebang, the system might try to use a different shell or just fail. For the exam, always start your scripts with #!/bin/bash.
The second requirement is making the script executable. In Linux, every file has permissions that control who can read, write, or execute it. By default, a new script file has read and write permissions but not execute. You add execute permission with the command: chmod +x scriptname.sh. The 'chmod' stands for 'change mode', and '+x' adds execute permission. Without this step, running the script will give you a 'Permission denied' error, which is a common exam trap.
Now, what goes inside the script? Any command you can type at the shell prompt can go into a script. For example:
echo 'Hello, world!' prints text to the screen.
ls lists files in the directory.
cd changes directory.
pwd prints the current working directory.
grep searches text for patterns.
mkdir creates a new directory.
But the real power of scripting comes from variables, conditionals, and loops. A variable stores data. In Bash, you create a variable by assigning it a value: NAME='Linux'. To use that variable later, you put a dollar sign in front: echo $NAME prints 'Linux'. Variables are case-sensitive, so $name and $NAME are different. By convention, environment variables (like PATH) are uppercase, and script variables are often lowercase.
Conditionals let your script make decisions. The basic structure is:
if [ condition ] then commands fi
For example:
if [ $AGE -ge 18 ] then echo 'You are an adult.' fi
The '-ge' stands for 'greater than or equal to'. Other common operators are '-eq' (equal), '-ne' (not equal), '-lt' (less than), '-le' (less than or equal to), and '-gt' (greater than). The spaces around the brackets are mandatory — omitting them is a classic exam mistake.
Loops repeat commands. The two main types are 'for' loops and 'while' loops. A 'for' loop iterates over a list:
for fruit in apple banana cherry do echo 'I like $fruit' done
A 'while' loop runs as long as a condition is true:
count=1 while [ $count -le 5 ] do echo 'Count is $count' count=$((count + 1)) done
The $(( )) syntax performs arithmetic. Without it, Bash treats numbers as text.
To run a script, you have several options. The most common is: ./scriptname.sh. The './' tells the shell to look in the current directory. You can also run it with: bash scriptname.sh, which explicitly invokes the Bash interpreter and doesn't require the script to have execute permission. For the exam, know both methods.
Shell scripts often include comments — lines that start with '#'. Comments are ignored by the shell and are only for humans reading the code. Good scripts include comments explaining what each section does.
Why does this exist? Before shell scripts, system administrators had to type every command by hand, every time. A simple daily task like backing up logs meant remembering and typing a dozen commands. Scripting packages those commands into a single file that can be run with one command, run automatically via cron (a scheduling tool), and shared with other team members. It replaces manual repetition with automated consistency.
Create the Script File
Use a text editor like nano, vim, or a simple echo command to create a file. For example: nano myscript.sh. The .sh extension is a convention that helps humans identify script files, but Linux doesn't require it.
Add the Shebang Line
Write #!/bin/bash as the first line of the file. This is not a comment — it's a special marker that tells the kernel to use the Bash interpreter. Without this, the script might run in a different shell or fail.
Write Your Commands
Add the Linux commands you want to automate, one per line. You can use variables, conditionals, and loops to make the script flexible. For example: echo 'Starting backup'; tar -czf backup.tar.gz /home/user/data.
Make the Script Executable
Run chmod +x myscript.sh to add execute permission. This allows you to run the script with ./myscript.sh. Without this step, the system will refuse to run it, showing 'Permission denied'.
Execute the Script
Run the script by typing ./myscript.sh if you're in the same directory, or provide the full path like /home/user/myscript.sh. Alternatively, run it with bash myscript.sh, which doesn't require execute permission.
Test and Debug
Check the output. If something goes wrong, use echo statements to print variable values at different points, or run bash -x myscript.sh to see each command before it executes — this is called a 'debug mode' and is very useful for the exam.
Sarah is a junior Linux administrator at a medium-sized e-commerce company. Every morning at 3 AM, the company's web server rotates its log files — it closes the current log, compresses the old one, and starts a fresh log for the new day. If Sarah had to do this manually, she'd need to log in at 3 AM, type a series of commands, and hope she didn't make a typo. Instead, she writes a shell script.
Here's what Sarah's script does step by step:
It checks the current time to make sure it's running during the maintenance window.
It finds all log files older than 24 hours.
It compresses those files using gzip to save disk space.
It moves the compressed files to an archive directory.
It deletes any archived logs older than 30 days.
It sends a confirmation email to Sarah with a summary of what was done.
It logs the execution to a separate audit file.
Sarah writes this script once, tests it on a development server, and then schedules it using cron. The cron entry looks like this: 0 3 * * * /home/sarah/scripts/rotate-logs.sh. That line means 'run the script at 3 AM every day'.
Now, every morning at 3 AM, the script runs automatically. Sarah checks the audit log when she arrives at work. If the script encountered an error — for example, if the disk was too full to compress the logs — the script is written to catch that error and send an alert to Sarah's phone.
In a real business context, this automation does three critical things:
It saves time. Sarah doesn't spend 20 minutes every day performing a repetitive task. That's over 120 hours per year saved.
It eliminates human error. A tired administrator at 3 AM might accidentally delete the wrong files. The script follows the exact same steps every time.
It provides a clear audit trail. The script logs every action, so if something goes wrong, Sarah can review exactly what happened.
Sarah also uses scripts for other tasks: checking server health (disk usage, memory, CPU), deploying software updates across multiple servers, resetting user passwords, and generating reports. Each script starts as a simple set of commands and grows as she adds error handling, logging, and flexibility.
For the XK0-006 exam, the real-world scenario questions will ask you to read a script and identify what it does, what's wrong with it, or what output it produces. You might see a script that checks if a user exists before adding them, or a script that loops through a list of servers to test network connectivity. The exam expects you to understand how the pieces fit together, not just memorise individual commands.
The XK0-006 exam tests your ability to create, read, and debug basic shell scripts. This isn't about writing complex programs — it's about demonstrating that you understand the structure and syntax of a script.
Here are the exact concepts the exam targets:
Shebang line: You must know that #!/bin/bash is the standard shebang for Bash scripts. The exam may show you a script without a shebang or with a wrong shebang (like #!/bin/csh) and ask what happens when you run it.
Making scripts executable: Understand chmod +x and the difference between running ./script.sh and bash script.sh. The exam loves to present a script that produces 'Permission denied' and ask why.
Variables: Assignment (name=value), referencing ($name), and the fact that spaces around the equals sign cause errors. A common question: 'What is the value of the variable after this assignment? name = John' — the answer is that it's an error because of the spaces.
Special variables: $0 (script name), $1, $2 (first, second arguments), $# (number of arguments), $? (exit status of the last command). These appear in exam questions regularly.
Conditionals: The if/then/else/fi structure. Know that the spaces inside the square brackets are mandatory. The exam will give you a snippet like 'if [$x -eq 5]' and ask what's wrong — the answer is missing spaces.
Comparison operators: -eq, -ne, -lt, -le, -gt, -ge for numbers; = and != for strings (in Bash, the string comparison operator inside brackets is a single equals sign, not ==).
Loops: for loops over a list, while loops with a condition. The exam might show a loop that counts or iterates through files and ask what the output will be.
Exit codes: Every command returns a number (0 for success, non-zero for failure). Scripts often use 'exit 0' for success and 'exit 1' for a generic error. The $? variable captures the last exit code.
Comments: Lines starting with # are ignored. The exam may include commented-out code and ask whether it executes.
Command substitution: Using $(command) or command to capture output into a variable. Modern exam questions prefer the $( ) syntax.
Arithmetic: $(( expression )) for integer maths. The exam will test that you know this syntax exists.
Exam traps to watch out for:
The 'test' command vs. square brackets: In Bash, [ is an alias for the test command. So 'if test 5 -eq 5' is the same as 'if [ 5 -eq 5 ]'. The exam might use either, and you must recognise both.
Variable quoting: If you don't put double quotes around a variable, the shell may split it into multiple words. For example, if filename='my file.txt', then 'rm $filename' tries to remove two files ('my' and 'file.txt'), while 'rm "$filename"' removes the one file. This is a classic exam trap.
Missing 'then' or 'do': The 'if' keyword must be followed by 'then' on a new line (or on the same line separated by a semicolon). The 'for' keyword must be followed by 'do'. Questions that show 'if [ ... ] echo hi' are missing 'then' and will fail.
The dollar sign in if statements: When testing variable values in an if condition, you must use the dollar sign: 'if [ $age -eq 18 ]'. But in the assignment, no dollar sign: 'age=18'. Mixing these up is a common error.
To prepare, practise reading scripts line by line and predicting the output. Focus on scripts that combine variables, conditionals, and loops in a short space. The exam will not ask you to write a full script from scratch — instead, you'll debug or analyse existing scripts, choose the correct command to complete a script, or interpret what a script will do.
A shell script is a plain-text file containing a sequence of Linux commands, saved with a .sh extension by convention.
Every Bash script must start with the shebang line #!/bin/bash to tell the system which interpreter to use.
To run a script as a program, you must make it executable with chmod +x scriptname.sh.
Variables in Bash are assigned with no spaces around the equals sign: name=value, and referenced with a dollar sign: $name.
Conditionals use if [ condition ]; then commands; fi and the spaces inside the square brackets are mandatory.
The $? variable holds the exit status of the last command, where 0 means success and any non-zero value means an error.
Always quote variables with double quotes ("$var") to prevent word splitting when the variable contains spaces.
Use $((expression)) for integer arithmetic, not regular command syntax.
These come up on the exam all the time. Here's how to tell them apart.
Running ./script.sh
Requires execute permission (chmod +x)
Uses interpreter from the shebang line
If shebang is missing or wrong, may fail or use wrong shell
Running bash script.sh
Does not require execute permission
Always uses Bash interpreter regardless of shebang
Can run scripts without a shebang line
Variable assignment: name=value
No dollar sign
No spaces around equals sign
Placed in script to store a value
Variable reference: $name
Has a dollar sign prefix
Can be used inside double quotes: "$name"
Retrieves the stored value for use
if [ $x -eq 5 ] (correct)
Spaces after [ and before ]
Works correctly
The [ is treated as a separate command
if [$x -eq 5] (incorrect)
No spaces around brackets
Causes a syntax error
Bash sees [$x as a single token and fails
exit 0
Indicates success
Convention for successful script completion
$? becomes 0 after this command
exit 1
Indicates failure or error
Convention for abnormal script termination
$? becomes 1 after this command
for loop
Iterates over a fixed list of items
Runs a known number of times based on the list
Syntax: for var in list; do ... done
while loop
Runs while a condition is true
Can be infinite if condition never becomes false
Syntax: while [ condition ]; do ... done
Mistake
You need to be a programmer to write shell scripts.
Correct
Shell scripting is more like writing a to-do list for the computer. You don't need to know programming theory — just understand the commands you already use, and learn a few rules about how to organise them in a file.
Many beginners come from zero IT background and feel intimidated by the word 'scripting'. They assume it's like Java or Python, but shell scripting is fundamentally about automating command-line tasks.
Mistake
Spaces don't matter in shell scripts; the computer figures out what you mean.
Correct
Spaces are critical. For example, 'if [ $x -eq 5 ]' works, but 'if [$x -eq 5]' or 'if[ $x -eq 5 ]' fails. The space after the opening bracket and before the closing bracket is mandatory.
In everyday language, extra spaces don't matter. But the shell is extremely literal. The square bracket is actually a command, and the shell expects spaces to separate the command from its arguments.
Mistake
A script always runs in the same directory where it's saved.
Correct
A script runs in the current working directory of the user who executes it, not where the script file is located. If Sarah is in /home/sarah and runs /scripts/log.sh, the script's working directory is /home/sarah, not /scripts.
This confuses beginners because they assume the script's location determines where file operations happen. They often write scripts that create files or refer to relative paths, then get surprised when files appear in unexpected places.
Mistake
You can use the same variable names as Linux commands without any issue.
Correct
It's a bad idea to use variable names like 'ls', 'cd', or 'echo' because they shadow (override) the actual commands. If you write 'ls=5', then later use 'ls' in the script hoping to list files, the shell will try to run '5' instead.
Beginners see variable assignment as harmless storage. They don't realise that the shell checks for command names in a specific order, and a variable with the same name as a command can interfere with command resolution.
Mistake
If a script has an error, it will stop and show a clear error message explaining how to fix it.
Correct
The shell often continues running past an error, producing unpredictable results or no output at all. A missing quote might cause the rest of the script to be treated as part of a string, with no error message shown.
New users are used to modern applications that give friendly pop-ups. The shell is old-school; it was designed for experienced users who could spot syntax issues. It often fails silently or with cryptic messages.
Mistake
You can run any text file as a script just by typing its name.
Correct
To run a script by name (like ./myscript), the file must have the execute permission set. Without chmod +x, you get 'Permission denied'. You can still run it using 'bash myscript' even without execute permission.
This mistake comes from a misunderstanding of Linux file permissions. New users see that they can open and read the file, and think that's enough to execute it. They don't realise that read and execute are separate permissions.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
The file has read permission but not execute permission. Run chmod +x scriptname.sh to add execute permission, then try again.
./script.sh requires the script to have execute permission and uses the interpreter specified in the shebang line. bash script.sh explicitly runs the script using the Bash interpreter and does not require the script to be executable.
You probably forgot the dollar sign when referencing the variable. Use if [ $myvar -eq 5 ] not if [ myvar -eq 5 ]. Also check that there are no spaces around the equals sign in the variable assignment.
Arguments are accessed using $1, $2, etc. $0 is the script name, $# is the number of arguments, and $@ is all arguments as a list. For example, to use the first argument: echo 'Hello, $1'.
It tells the operating system which interpreter to use to run the script. In this case, it says to use the Bash shell located at /bin/bash. Without it, the system may use a different shell or fail.
Yes, by using the bash command: bash scriptname.sh. This invokes the Bash interpreter directly and does not require the file to have execute permission set.
Check that you used the correct syntax: for var in list; do commands; done. Common mistakes are missing the semicolon before 'do', missing 'do', or missing 'done'. Also ensure the list items are separated by spaces.
You've finished Basic Shell Scripting. Continue through the XK0-006 study guide to build a complete picture of the exam.
Done with this chapter?