Qfyilyi

I have startup script line:

pyprogramm >> /dev/null  2>&1 &

Meanings:

>> /dev/null - redirect stdout to null device

2>&1 - redirect stderr to stdout (that is redirected to null device)

but what very last & means?

It means run the command in the background. The calling script continues rather than blocking until the called command completes.

What is the & terminator ?

The trailing & operator at the end of a command is used to put commands into background. This is actually a standard syntax specified by POSIX standard:

Asynchronous Lists

If a command is terminated by the control operator
( '&' ), the shell shall execute the command
asynchronously in a subshell. This means that the shell shall not wait
for the command to finish before executing the next command.

The format for running a command in the background is:

command1 & [command2 & ... ]

From the definition you can see that & also serves as command terminator for lists of commands, much like ; does. In your specific example, pyprogramm >> /dev/null 2>&1 & there is only one command in the list.

Sequential ; lists vs asynchronous & lists

More generally,

echo Hello ; echo World ;

and

echo Hello & echo World &

are two examples of lists terminated by the ; and & operators, with the difference that & terminated list will hide the output by redirecting output to /dev/null if job control is enabled, and in fact that's exactly what the standard also states:

If job control is disabled (see set, -m), the standard input for an
asynchronous list, before any explicit redirections are performed,
shall be considered to be assigned to a file that has the same
properties as /dev/null. This shall not happen if job control is
enabled. In all cases, explicit redirection of standard input shall
override this activity.

Thus, in the specific example redirecting >> /dev/null may be unnecessary, if job control is enabled by the shell.

Note also, that from the definition we mentioned earlier, & executes commands in subshell. By contrast, the ; terminated list is executed in current shell. There's also difference in exit statuses. For & the standard says:

The exit status of an asynchronous list shall be zero.

This is significant when you want to put multiple commands in background. When you write a script or command you will have to chose commands for which you don't care if they failed or not, or you will have to find a way to handle the non-zero ( error ) exit status. In your specific example, pyprogramm >> /dev/null 2>&1 & running in background should have some way of indicating if it failed or not, however judging that you use 2>&1 you are hiding error output by redirecting, and you probably assume the script should not fail.

By contrast, ; exit status is defined as:

The exit status of a sequential list shall be the exit status of the
last command in the list.

Again, this has implications on how you write a sequential list of commands in command-line and how you want things to be handled if some of the commands in the list failed.

The fact that this is POSIX definition means that all Bourne-like shells, meaning bash, dash, and ksh must support it.