Almost every command has an associated manual page. Suppose the command verb is ls, then typing man ls at the command line prompt will give you that command's reference page.

The -t flag has no specific meaning across all commands. You will need to look at the man page for the particular command to find out what it does.

You are right that it is amazingly poorly documented. What documentation that there is is quite simple:

-t      Exit after reading and executing one command.

The bash source code is available here. I looked at version 4.2. The short flags handled by bash are listed in flags.c and in there is the relevant line:

{ 't', &just_one_command },

So, -t on the command line sets the variable just_one_command. This variable is used in just one place: it occurs in an if condition at the end of a loop in eval.c:

  if (just_one_command)
    EOF_Reached = EOF;

In other words, if the -t flag is given, then, after the first command is executed, the end-of-file condition is signaled and bash exits.

MORE DETAIL

From eval.c, command line execution in bash appears to be controlled by the function reader_loop:

reader_loop ()
{
  int our_indirection_level;
  COMMAND * volatile current_command;
  USE_VAR(current_command);
  current_command = (COMMAND *)NULL;
  our_indirection_level = ++indirection_level;
  while (EOF_Reached == 0)
    {
      int code;
      code = setjmp_nosigs (top_level);

      [ ... Much code removed ... ]

      if (just_one_command)
        EOF_Reached = EOF;
    }
  indirection_level--;
  return (last_command_exit_value);
}

The loop inside reader_loop continues until it receives the signal EOF_Reached. The sole effect of the -t option is to set this flag at the end of loop which assures that the loop is executed only once.

What it means is that you should pres Ctrl+t (holding the Ctrl-button whist pressing 't').

(If you actually sometime need to write a single '^' on a keyboard layout with dead-keys, like a German layout, type '^' followed by space.)

The sticky bit is today incredibly confusing. It no longer pins the file into memory, making it actually "sticky", anymore. Sometimes it is called the "tacky" bit because it is represented as a 't' or 'T', but other folks still call it sticky. It only matters in modern linux and unix when applied to a directory, as far as I can tell. It means that people in groups who have the permission to delete a file still can't do it if the sticky bit is set on the directory. But it gets more confusing. It shows up in the last field, which is the execute/search field for "other" users, but acts on "group" users ("other" normal users can never delete files). The reason why it isn't shown in the "group" execute field is because that one changes to an "s" if the SETUID bit is set for group. I think. I am still researching that one.

-s Switch: Squeeze (remove repeated characters)

echo i am a good boy | tr -s good bad

output: i am a bd bdy

There are two things happening behind the scenes that make this happen. Firstly, if the second argument to tr is shorter than the first then the last character in the 2nd arg is repeated to make it the same length as the first. So the equivalent command is:

echo i am a good boy | tr -s good badd

The other thing that is happening is when characters in the first argument are repeated they overwrite any previous occurrence (I'm referring to the two oos in good). This makes the command now equivalent to:

echo i am a good boy | tr -s god bdd

(the second o to d replacement overwrites the previous o to a replacement, making it redundant)

Without the -s switch the output would be

i am a bddd bdy

With the -s switch tr 'squeezes' any repeated characters that are listed in the last argument leaving the final output:

i am a bd bdy

-c Switch: Complement

The -c switch is used to match the complement of the first argument (i.e. all characters not listed in arg 1). As a result, arg 1 will contain many letters (256-3). Now, the same thing happens to arg 2 as in the previous case: Arg 2's final character gets repeated to match the length or Arg 1. So the original statement:

echo i am a good boy | tr -c good bad

is equivalent to:

echo i am a good boy | tr abcefhijklmnp... baddddddddddd...

(note the missing g, o and d in the first set, also note that d will replace every other character in the second set -- including the space character)

This is why i am a good boy turns into dddddddgoodddodd

More info here: http://www.linuxjournal.com/article/2563

The ls man page can help clarify these options.

The -l option controls output format, producing a 'long' listing.

The -t option sorts by modification time. This value is already present in the long format.

The -u option behaves differently based on the options it is used with.

1. On its own, as ls -u, it sorts by access time.
2. With the -l option, it displays the access time, but sorts by name. In this case, it acts as an output modifier rather than a sorting option.
3. With -l and -t, it shows the access time and also sorts by it.

The -c option works the same way with the ctime property.

The complexity comes from the need to modify the long listing format. Several other options work this way: -lo to suppress group information, -lG to suppress owner information, -lh to display sizes in human-readable format, and so on).

The GNU-style options from the ls manual makes this easier to understand.

-l is --format=long.

-t is --sort=time.

-u is --time=atime.

So -lu is --format=long --time=atime. That is, show the long listing, but with atime instead of the default mtime.

And -ltu is --format=long --sort=time --time=atime. In this case, show the atime and sort by it.

Look at the parameters of the os.system call. Notice the /t 1 parameter that specifies a time interval. It means "wait one second before shutting down".

Notice that the subprocess.call command is missing this parameter. Without the /t parameter, the default is 30 seconds before initiating shutdown.

Type shutdown /? at the command prompt for more details.