health_check.sh already exists, but it carries the disk threshold written by hand in the body and the server IP just above it. The day Marta asks you to watch the test server too you will have to duplicate the file, and from that moment on you will have two scripts that drift apart little by little until one of them is lying. The cure is to take the values out of the body and put them into well-thought-out variables.

This lesson is about that, but above all it is about something deeper: in Bash everything is a string of text, and that single sentence explains 90% of the surprises coming your way. In exchange, Bash gives you an arsenal of string manipulation — parameter expansion — so powerful that it replaces basename, dirname, cut, tr and a good part of sed without launching a single process.

1. Bash has no types: everything is a string
2. Assignment: the three rules that catch everybody out
3. Scope: script, subshell and environment
4. declare and its attributes
5. Parameter expansion in depth
6. Arithmetic, and why Bash knows nothing about decimals
7. Indexed arrays
8. Associative arrays: bookings per house
9. Strings and printf
10. Application: a configurable health_check.sh

In Python or Java you declare the type and the language protects you. In Bash there are no types: every variable holds a string of bytes, and the "type" only appears when you use it, according to the context.

The same variable is a number inside $(( )) and text outside it. Nobody warned you when you assigned 42abc; the error arrived when you tried to add. Three consequences worth internalising today:

• Nothing validates what you store. Validating is your job, and we will formalise it in 04-04 with [[ $v =~ ^[0-9]+$ ]].
• Comparing numbers and comparing strings are different operations. "10" < "9" is true as text and false as a number; hence -lt and < existing separately.
• There are no decimals. $(( 7842 / 25 )) gives 313, not 313.70 (section 6). The only partial exceptions to the rule are declare's attributes and arrays, which really are a genuine data structure.

• No spaces around the =. version = 3.2.1 is not an assignment: Bash reads it as the command version with the arguments = and 3.2.1. It is the rule most often broken by people coming from other languages, and the error message is no help at all.
• Quotes if there are spaces. Without them the assignment ends at the first space. Working rule: always quote the value, whether it has spaces or not.
• To use it, $; to assign it, no $. name=value to write, "$name" to read.

The last two lines of the example show something else: putting a variable in front of a command makes it exist only for that one execution, which is exactly what the course's LC_ALL=C convention does. On names: letters, digits and _, not starting with a digit; UPPERCASE for constants and the environment, lowercase for working variables. And avoid trampling on PATH, HOME, IFS, PWD, RANDOM or SECONDS, which already have an owner.

Picking up 03-01 again, now from inside a script:

Three lessons in six lines. The child does not see HOUSE because it is not exported, but it does see RELEASE. The subshell — the parentheses — does see everything from the parent because it is a copy of it, but its changes do not come back: the same wall you met with cd, and the one that will make a while read inside a pipeline lose its variables (04-03). As for local, it can only be used inside a function and it is a preview of 04-05, but the rule is so important that we state it now: every variable created inside a function must be local; without it, it is global, and one function can silently trample another one's counter.

declare (or its synonym typeset) creates variables with attributes, the closest thing to a type that Bash has.

Look at errors+=14: with the -i attribute it adds, whereas without it, it would concatenate and leave 014. That different behaviour depending on an invisible attribute is why many people prefer explicit arithmetic with $(( )); we will use -i only for obvious counters. readonly we will use a lot: it turns a logic error — reassigning a constant by accident — into an immediate, noisy error, always better than a silent one.

This is where Bash stops looking like a toy language. Everything that follows happens inside the shell, without launching processes. We start from a real name from our backups:

That is basename and dirname without basename or dirname. The mnemonic is visual: on a keyboard, # is to the left of $ and strips from the left; % is to the right and strips from the right. Doubling the symbol makes the pattern greedy, like the greediness from 03-02. Careful: these are globbing patterns (*, ?, [...]), not regular expressions.

The first four are the basis of default configuration, and :+ is the least known: it adds something only if there is something to add.

The ${filepath//í/i} resolves, without calling sed, the accent the application puts into the links to /houses/el-molí and which causes the four 404s in access.log. The ${verbose:+-v} adds the option only if the variable has content, which is how conditional command lines are built. And ${VAR:?message}, already seen in 03-01, is the cheapest way to demand a mandatory value.

Bash has two ways of doing sums and both work only with signed 64-bit integers.

$(( )) substitutes the result, so you use it wherever you want the value. (( )) evaluates and prints nothing: it is for modifying variables or for use as a condition, returning 0 (success) if the result is non-zero. Inside both, variables go without $ and you have + - * / % **, comparisons, && || !, ++ --, += and the ternary a ? b : c.

Two warnings: a number with a leading zero is interpreted as octal: $(( 08 )) is a syntax error, which ruins any calculation involving months (08, 09); force it with $(( 10#08 )). And (( i++ )) with i at 0 returns 1, because the value of the expression is the one before the increment, and with set -e that aborts the script; it is a trap from 04-06, and for now use (( ++i )) or i=$(( i + 1 )).

For decimals you have to leave Bash:

Tramontana's average amount per booking is 313.70 €. You have to tell bc the scale (scale=2) because by default it truncates to zero decimals when dividing; bc -l loads the maths library and raises it to 20. But look at the second example: if the data is already in a file, awk does the reading and the sums at once. The course's rule: bc for a one-off calculation, awk as soon as there is a file. And the LC_ALL=C is not decorative: under a locale that uses the comma, printf '%.2f' would print 313,70, and that comma breaks any later comparison.

An array is an ordered list of strings with a numeric index starting at 0. It solves "storing several things in one variable" without resorting to space-separated strings, which break as soon as an element contains one.

It is created with parentheses, extended with +=(...), [-1] is the last one, ${#array[@]} counts elements and ${array[@]:1:2} is a slice. The last command reveals something important: unset leaves a hole, the indices are not renumbered; that is why ${!array[@]} exists, giving you the indices and not the values.

The difference that causes the most bugs, and it only shows up inside double quotes:

"${array[@]}" produces one argument per element, respecting spaces: it is what you want 99% of the time. "${array[*]}" produces a single argument with the elements joined by the first character of IFS, useful only for printing. And without quotes Bash splits on spaces, and "august report.pdf" becomes two files that do not exist. Burn it in: arrays always with "${array[@]}".

An associative array indexes by string instead of by number: it is what awk gave you in 03-05, now inside Bash. It has to be declared with declare -A before use; otherwise Bash treats it as indexed and all the keys collapse into index 0.

The 70 known nights, distributed (shown here in two columns to save space). Two new pieces: < <(tail -n +2 "$CSV") is a process substitution that stops the while running in a subshell and losing the arrays when it finishes — 04-03 details it — and _id, _date, _guest are the convention for "I read this field but I do not use it", which also keeps shellcheck quiet. An honest note: this report fits in one line of awk. Associative arrays shine when what you accumulate is not tabular text — exit codes per service, paths already processed, a cache; with a CSV, awk still wins. The rule is formalised in 04-04.

Concatenating means writing one thing after another, and += appends at the end:

The braces in ${host} are not optional: without them $host: would work by luck, but $portX would look for a variable called portX. Use braces whenever the variable touches adjoining text. For output, printf replaces echo in everything serious: echo varies between shells and does odd things with -n and backslashes, whereas printf is precisely defined and reuses the format while arguments remain, which turns it into a table generator.

A single call, three rows: the format was reused three times. That is the table for Marta's report, and the reason echo is now left only for one-line messages with no formatting.

The underlying change: no value is nailed into the body any more. They are all constants at the top, and the ones it makes sense to adjust from outside are read from the environment with ${VAR:-default}.

Without touching the file, the script points at another port. That is the first step of the precedence chain arguments > environment > configuration file > defaults that we will complete in 04-03 and close in 04-07. It still compares nothing against DISK_THRESHOLD: that arrives in 04-04.

• Spaces around the =. VAR = value assigns nothing: it is error number one. Number two is using $VAR without quotes: if the value contains spaces or a *, Bash splits it or expands it against the disk. SC2086 is exactly this, and it is not a pedantic warning: it is a failure waiting for its file with a space in the name.
• Forgetting declare -A. Without it, data[mas-figueres]=1 evaluates the key as arithmetic, turns it into 0 and all the houses trample each other, with no error whatsoever. And do not confuse ${VAR:-x} with ${VAR:=x}: the first does not modify the variable, the second does.
• ${array[*]} in a loop. It iterates over a single gigantic element; always use "${array[@]}". And beware of leading zeros: $(( 08 + 1 )) fails because of octal, so write 10#$month.
• Expecting decimals from $(( )). $(( 7842 / 25 )) gives 313 and the remainder is lost without warning. For money, awk or bc with LC_ALL=C.
• Tip: declare -p VAR tells you what a variable really is — array, integer, exported — when something does not add up. It is the stat of variables.
• Tip: prefer parameter expansion to basename, dirname, cut or tr for simple things: in a loop of a thousand iterations that is a thousand processes you save. And declare every constant readonly.

Exercise 1. Given f="/srv/tramontana/backups/pre-deploy/app-3.2.1-2026-08-11.tar.gz", obtain using parameter expansion only (no basename, no cut, no sed): the directory, the file name, the name without the extension, the version 3.2.1 and the date 2026-08-11. Explain each expansion.

Exercise 2. Write ~/scripts/bookings_summary.sh which, reading bookings.csv, prints an aligned table with house, bookings, nights and amount, plus a totals line. Use an associative array and printf. It must match the known data: 25 bookings, 70 nights, 7,842.50 €.

Exercise 3. Luis proposes this to calculate the percentage of POST requests out of the 412 in access.log. Explain the three flaws and rewrite it.

Solution 1.

• ${f%/*} removes the shortest suffix starting with /: that is dirname. ${f##*/} removes the longest prefix ending in /: that is basename.
• ${base%%.tar.gz} trims the compound extension. Here %% and % give the same result because the pattern is literal, but %%.* would have been dangerous: it would also cut at the dot in 3.2.1, leaving app-3.
• The version comes out in two steps: #app- removes the prefix and %%-* trims from the first remaining hyphen, the one before the date. For the date, ##*-[0-9].[0-9].[0-9]- uses a globbing pattern — not a regex — that consumes everything up to just past the version number.

Solution 2.

It matches the known data. The sum function is a preview of 04-05, but it illustrates why functions are inevitable: the same awk line is used in two places.

Solution 3. The three flaws:

1. Spaces around the =. posts = 114 tries to run the command posts and the script dies on the first line.
2. The order of operations truncates the result. $posts/$total*100 first calculates 114/412, which in integer arithmetic is 0, and then 0*100 = 0. Always multiply before dividing.
3. The $ signs are unnecessary inside $(( )) — noise, not an error — and above all a percentage calls for a decimal that Bash cannot give.

Notice the %% in the format: inside printf, a literal % is written doubled.

You no longer depend on values nailed into the code, and along the way you have picked up the part of Bash that gives the most productivity per line written.

• You know that in Bash everything is a string and that the "type" is supplied by the context: nothing is validated, comparing numbers is not comparing text, and there are no decimals. You assign with no spaces around the =, you always quote the value, you distinguish the shell, environment and subshell scopes knowing that the child's changes never come back to the parent, and you use declare with its -r, -i, -a, -A, -x and -p attributes.
• You have mastered the whole of parameter expansion: :-, :=, :? and :+, lengths, substrings, trims with #, ##, %, %%, replacements with / and //, and case changes. You no longer need basename or cut for the simple things.
• You do integer arithmetic with $(( )) and (( )), you know the octal trap and the (( i++ )) one, and you go out to bc or awk with LC_ALL=C as soon as a decimal appears: Tramontana's average amount is 313.70 €.
• You handle indexed arrays — always "${array[@]}", never ${array[*]} — you count by key with associative arrays after the indispensable declare -A, you format with printf (which already produces the table for Marta's report), and health_check.sh reads its configuration from the environment with default values.

But the script is still mute: you cannot ask it for help, you cannot tell it "use threshold 60" without exporting a variable, and there is no way for it to read the month for a report. In the next lesson, Script Input, Output and Arguments, we give it a real interface: positional parameters and the critical difference between $@ and $*, a help function, getopts for short options, the -h, -v, --dry-run and -- conventions that make a script look professional, read in all its variants and the canonical pattern for reading a file line by line, the golden rule of stdout for results and stderr for humans, and exit codes with meaning. By the end of it, health_check.sh will accept options and bookings_report.sh will be born.