:(){ :|:& };:

The command shown in the heading is known as a Bash “Fork Bomb.”

A fork bomb is a denial-of-service attack where a process continuously creates child processes at an exponential rate, consuming system resources like CPU, memory, and process slots, ultimately causing the system to crash. //

To set limits for the current bash session:

Run ulimit -u to check the maximum number of processes you can have (e.g., 30593).
Run ulimit -u NUM, where NUM is significantly lower than your maximum (e.g., 1024).

Setting persistent user limits
The above method works unless the user reopens their terminal and runs the fork bomb again.

To set persistent user limits, add the same ulimit command to your ~/.bashrc or ~/.bash_profile file.

ulimit -u 1024 # Example for my system 

Setting persistent user limits
Configuring system-wide limits is similar to setting user limits, but involves editing a different file that manages system-wide process rules.

Typically, you would run sudo nano /etc/security/limits.conf and add the following user limits:
username hard nproc 1024
Remember to replace “username” with the user you wish to limit.

# let days=$(date --date=yesterday +%s)/86400 "even = days % 2" && [ $even -gt 0 ] && echo $days
19967

# let days=$(date --date=today +%s)/86400 "even = days % 2" && [ $even -gt 0 ] && echo $days || echo NOT
NOT

Bash let is a built-in command in Linux systems used for evaluating arithmetic expressions. Unlike other arithmetic evaluation and expansion commands, let is a simple command with its own environment. The let command also allows for arithmetic expansion.

Those variables are shell variables. To expand them as parameters to another program (ie expr), you need to use the $ prefix:

 expr $x / $y

The reason it complained is because it thought you were trying to operate on alphabetic characters (ie non-integer)

If you are using the Bash shell, you can achieve the same result using expression syntax:

echo $((x / y))

Or:

z=$((x / y))
echo $z

Why not use let; I find it much easier. Here's an example you may find useful:

start=`date +%s`
# ... do something that takes a while ...
sleep 71

end=`date +%s`
let deltatime=end-start
let hours=deltatime/3600
let minutes=(deltatime/60)%60
let seconds=deltatime%60
printf "Time spent: %d:%02d:%02d\n" $hours $minutes $seconds

Another simple example - calculate number of days since 1970:

 let days=$(date +%s)/86400

Infinite for Loops

You can also use this format of for loop to create an infinite loop. All you need do is remove all of the elements from the loop header, like this. This is "infinite.sh."

#!/bin/bash
for (( ; ; ))
do
 echo "Press Ctrl+C to stop..."
 sleep 1
done

You'll need to hit Ctrl+C to stop the loop.

 # loop through the indices and print elements
 for position in ${!bd_bands[@]};
 do
 echo "band ${bd_bands[$position]} is at index: $position"
 done

In the third part of the Bash Beginner Series, you'll learn to pass arguments to a bash shell script. You'll also learn about special bash shell variables.

An A-Z Index of the Linux command line: bash + utilities.

A here document is a block of text or code which is redirected to an interactive program or a command.

 #!/bin/bash
 Command <<MyUniqueLimitString
 some text
 some more text
 MyUniqueLimitString

The above is equivalent to Command < tempfile.txt where the tempfile contains the text required.

EOF and END are often chosen as the MyUniqueLimitString but any string can be used as long as it does not appear within the here document text.

The - option to mark a here document limit string (<<-LimitString) will suppress leading tabs (but not spaces) in the output. This allows the use of indentation (with tabs) when writing here-documents in shell scripts making them more readable.

Here documents can also be used to supply values to variables or functions.

These are called shell operators and yes, there are more of them. I will give a brief overview of the most common among the two major classes, control operators and redirection operators, and how they work with respect to the bash shell.