In a bash project, two helper files each `source common.sh`, so common.sh is loaded twice in the same shell. What can go wrong, and what does an include guard look like in bash?

## Bash has no module system Languages with imports remember what they have loaded and skip the second request. `source` has no such memory. Each call opens the file and executes it start to finish, and bash neither notices nor cares that it just did. In any project with more than a couple of shared files this happens quickly: `lib/log.sh` and `lib/aws.sh` both source `lib/common.sh`, the entry point sources both, and `common.sh` runs twice. ## What survives a second load and what does not Redefining a function is harmless — the new definition simply replaces the old one, byte-identical in this case. Variable assignment is harmless too, unless the assignment is *derived from the current value*. The damage lives in side effects: - **`readonly` / `declare -r`.** `readonly VERSION=1.2` on the second pass prints `VERSION: readonly variable` and returns non-zero — even with the same value. In a script under `set -e`, that non-zero status aborts the run, and the failure message points at the library rather than at the double include. - **Accumulating assignments.** `PATH="/opt/tools:$PATH"` or `LD_LIBRARY_PATH` grows a duplicate entry each load. Rarely fatal, always confusing when someone debugs which binary is being found. - **Arrays and counters.** `SERVERS+=(web1 web2)` doubles the list. A counter reset to zero at load time loses whatever the caller had accumulated between the two sources. - **`trap`.** Installing a handler replaces the previous one rather than adding to it, so a library that sets `trap cleanup EXIT` at load time silently overwrites a caller's handler when reloaded at the wrong moment. - **Cost.** Anything expensive at load time — querying a cloud metadata endpoint, reading a large file, shelling out for a version string — pays twice. ## The guard The bash idiom mirrors C's header guard: a sentinel variable, checked first, set immediately after. ```bash # common.sh if [[ -n "${_COMMON_SH_LOADED:-}" ]]; then return 0 fi _COMMON_SH_LOADED=1 # ... definitions below ... ``` Three details make it correct. `${_COMMON_SH_LOADED:-}` uses the default-value expansion so the test does not blow up under `set -u`, which would otherwise fail on the first load when the variable does not exist. `return 0` — not `exit` — leaves the sourcing early with a success status and leaves the caller running; `exit` would terminate the caller's shell. And `return` at the top level is legal *only* because the file is sourced, which is correct for a pure library and is one reason libraries should not be marked executable. Name the sentinel after the file with a namespace prefix so two libraries cannot collide, and keep in mind the guard is per shell: a child shell starts with a clean environment (unless the variable is exported, which you should not do) and will load the library again — which is what you want, since it has none of the definitions. ## The better fix A guard is a workaround for a library that does things at load time. The structural answer is to make libraries **idempotent by construction**: define functions, and nothing else. No `readonly`, no `PATH` mutation, no traps, no work. Then a double load costs a few milliseconds of re-parsing and changes nothing observable, and you do not need the guard at all. Where a library genuinely needs one-time setup, put it in an explicit `common_init` function the entry point calls once, rather than in the file body — the caller then controls when and how often it happens, and it is testable. A related habit: source libraries through a single resolved absolute path (a `script_dir` variable computed at the top of the entry point) so the same file is not loaded under two spellings. The guard makes the spelling irrelevant, but consistent paths make the dependency graph readable, and they matter for the naive alternative of tracking loaded files in an array. ## What an interviewer is listening for That you know `source` re-executes unconditionally, that you can name a concrete breakage rather than saying "it might be slow" — the `readonly` abort is the sharpest one — and that you reach for side-effect-free libraries before reaching for the guard.