It calls the isatty() libc function on its stdout file descriptor to determine whether the output goes to a terminal or not.

Internally, isatty() attempts to use one of the ioctl() calls that are specific to tty devices – most likely ioctl(TCGETS) (which retrieves the generic tty settings that the stty command shows); if it succeeds, then the file is a tty device.

$ python
>>> sys.stdout.isatty()
True

This affects both whether ls will columnate its output by default, and whether it will use colors by default, and some other things such as whether file names will be quoted.

If stdout is indeed a terminal, then ls uses another tty-specific ioctl(TIOCGWINSZ) to retrieve its dimensions (which on modern systems have been stored there by the terminal emulator) to find out how many columns it can fit. The stty size command also gets those; try running it under strace.

Full-screen programs additionally react to the SIGWINCH signal which the kernel sends every time the terminal emulator updates the dimensions of the tty, as an indication that they need to redraw everything in the new size.

It's because * doesn't match files starting with a . by default. Consider the following directory:

$ ls -la 
total 8404
drwxrwxrwx   2 terdon terdon 8105984 Dec 31 13:14 .
drwxr-xr-x 153 terdon terdon  491520 Dec 30 22:32 ..
-rw-r--r--   1 terdon terdon       0 Dec 31 13:14 .dotfile
-rw-r--r--   1 terdon terdon       0 Dec 31 13:14 file1
-rw-r--r--   1 terdon terdon       0 Dec 31 13:14 file2
-rw-r--r--   1 terdon terdon       0 Dec 31 13:14 file3.

Let's see what each of the globs you used expands to:

$ echo .*
. .. .dotfile

$ echo *.
file3.

$ echo *
file1 file2 file3.

As you can see, the * does not include files or directories starting with . so both ./ and ../ are ignored. The same thing happens with your ls example. In bash, you can change this with the dotglob parameter, which will cause * to expand to dotfiles as well (but not to . or .., those are still ignored):

$ shopt -s dotglob
$ echo *
.dotfile

Other shells behave differently. For example zsh also ignores the . and .. when using .*:

% echo .*
.dotfile

You've changed your script to use Model=Report and ${Model} and you've said you have typeset -u Model in your script. The -u option to the typeset command (instead of declare — they're synonyms) means "convert the strings assigned to all upper-case".

-u When the variable is assigned a value, all lower-case characters are converted to upper-case. The lower-case attribute is disabled.

That explains the upper-case REPORT in the variable expansion. You can demonstrate by writing:

Model=Report
echo "Model=[${Model}]"

It would echo Model=[REPORT] because of the typeset -u Model.

• Don't use the -u option if you don't want it.

You should probably fix your glob expression too:

file={Model}_execution_*${DATE}*.pdf)

Using $(…) instead of backticks is generally a good idea.

And, as a general point, learn how to Debug a Bash Script and always provide an MCVE (How to create a Minimal, Complete, and Verifiable Example?) so that we can see what your problem is more easily.

What you see is what you get, really. Everything that was printed after running ls was printed by the 'ls' command itself – there was no intermediate return value that had to be reformatted.

Shell commands aren't exactly like functions in programming languages – they cannot return anything but a single integer: the "exit status". Most shells allow inspecting this value through the $? variable. (The convention is to return 0 on success; 1 or greater on failure.)

So literally all output you're seeing is produced not through a return value, but by writing ordinary text to the special files called "stdout" and "stderr" during the execution of the command (the former is meant for regular output, the latter for notices and error messages).

Of course, inside the 'ls' program you would find calls to libc functions such as readdir() which returns a struct dirent, or stat() which returns a struct stat. However, none of those are returned to the outside world.

So can you use the output of 'ls'? In a sense yes, in fact much of the traditional "Unix" user interface is built upon the idea using one program's output as another program's input – that's what the | pipe operator is for. However, keep in mind that the 'ls' output is specifically formatted for human consumption and is not easily machine-parseable. In other words, you shouldn't use the output of 'ls' in scripts even if you can.

(Piping works best when the initial program was actually written to produce somewhat structured output. For this reason, many tools can actually be run with options to output either pretty formatted text or machine-parseable text. Compare lsblk vs lsblk --raw vs lsblk --json.)

There are exceptions – there have been shells which attempt to support flexible return types, but PowerShell is the only widely known example. PowerShell cmdlets can return arbitrary .NET Runtime types.

It's the number of (by default, 1K) blocks. From the description of -ls in the texinfo documentation (info find -n 'Print File Information'):

 -- Action: -ls
     True; list the current file in 'ls -dils' format on the standard
     output.  The output looks like this:

          204744   17 -rw-r--r--   1 djm      staff       17337 Nov  2  1992 ./lwall-quotes

     The fields are:

       1. The inode number of the file.  *Note Hard Links::, for how to
          find files based on their inode number.

       2. the number of blocks in the file.  The block counts are of 1K
          blocks, unless the environment variable 'POSIXLY_CORRECT' is
          set, in which case 512-byte blocks are used.  *Note Size::,
          for how to find files based on their size.

       3. The file's type and file mode bits.  The type is shown as a
          dash for a regular file; for other file types, a letter like
          for '-type' is used (*note Type::).  The file mode bits are
          read, write, and execute/search for the file's owner, its
          group, and other users, respectively; a dash means the
          permission is not granted.  *Note File Permissions::, for more
          details about file permissions.  *Note Mode Bits::, for how to
          find files based on their file mode bits.

        ...

The option '-l' tells the command to use a long list format. It gives back several columns wich correspond to:

• Permissions
• Number of hardlinks
• File owner
• File group
• File size
• Modification time
• Filename

The first letter in the permissions column show the file's type. A 'd' means a directory and a '-' means a normal file (there are other characters, but those are the basic ones). The next nine characters are divided into 3 groups, each one a permission. Each letter in a group correspond to the read, write and execute permission, and each group correspond to the owner of the file, the group of the file and then for everyone else.

• [ File type ][ Owner permissions ][ Group permissions ][ Everyone permissions ]

The characters can be one of four options:

• r = read permission
• w = write permission
• x = execute permission
• - = no permission

Finally, the "+" at the end means some extended permissions.