Console Apps

09:50 Application Name

“You type magic words into the black box with white letters.”

The application itself in most terminals and consoles is the first thing specified on the command line. What can be executed is specified in different ways on different systems. Windows tends to do this by file extension. Extensions like .exe, .bat, .cmd, and .ps1. Unix-based systems tend to do this by setting a flag on the file to indicate that it can be executed.

11:43 Arguments

“These are like parameters going into a function.”

After the application name come the arguments that will be passed into the console app. At the simplest case, these arguments can be simple switches to turn functionality on or off. They can also be several levels deep, as if there were a tree of options. The arguments to an application can include the output from other applications. You can also stream data from a file into an application.

“Is that get with an ‘e’ or an ‘i’?”

It’s unwise to make these arguments require characters that have to be escaped on the commandline. Linux apps tend to use a dash before arguments and windows apps tend to use a slash “/” before arguments.

15:48 Shell

The shell is a common execution environment for console applications. That’s the little black window in windows or DOS if you are old enough to remember it. The shell is essentially the top level process that is orchestrating the other things you are working with.

18:00 Pipes

A pipe is a method of interprocess communication. Essentially what it does is that it takes data in and data comes out of it in a first in first out manner (FIFO). An app can open it to read and another app can open it to write. What is written by the second app is read out by the first in the same order it was sent in. You can stream into and out of files.

“Asyncronous water park slides are not fun.”

In windows, users typically don’t see these, although they are available in the NPFS (named pipe file system). In unix, it’s a core feature that users are expected to interact with, frequently. It may be helpful to think of them the same way you think about streams in your favorite programming language.

22:30 Child Process

A process that is started by another process. Child processes are stopped when the parent process is stopped. This can be done either by the operating system’s API, via its GUI, or by a termination sequence (CTRL + C on windows terminal).

24:53 Standard Streams

Pre-connected input and output channels between a computer program and its execution environment. When using the shell, these are typically connected to the text terminal. Generally, child processes inherit the standard streams of the parent process.

“It’s like this except when it’s not like this.”

StdIn or the standard input is what goes into the program. This input may be sent from the keyboard or directed from a pipe. StdOut or the standard output is what comes out of a program. Typically this goes out to the terminal, but can also be piped to a file or another program. StdErr or standard error is a secondary output stream used to indicate errors. It may be redirected to the same destination as stdout. You’ll see different stream notation on other systems such as VMS.

27:10 Exit Codes

Indicate the result of a process. Typically zero means it was ok. Nonzero means something else. The exit is often an error number.

28:36 Environmental Variables

Dynamic variable that can effect the way a process runs. They tend to be key-value pair and can be system or user level. They might have multiple things in them like windows PATH variable.

30:45 POSIX

The Portable Operating System Interface (POSIX) is a family of standards specified by the IEEE Computer Society for maintaining compatibility between operating systems. POSIX defines the application programming interface (API), along with command line shells and utility interfaces, for software compatibility with variants of Unix and other operating systems.

“These were built when the trust between machines was much higher.”

There are varying levels of compliance in various unixes, MacOS, BSDs, etc. Windows isn’t compliant but it wouldn’t surprise me if they eventually got there.

33:55 Switches

Command line switches vary, but are organized around being capable of being parsed by text libraries. This typically means that switches are delimited in some fashion, usually by spaces.

“I think it was Hexo that I’ve used most recently that did that.”

You typically will have a switch that lets you find out what parameters are supported. It will often be -h(elp), /h(elp) or /?. Additionally, if someone enters incorrect parameters, it’s generally best practice to tell them what is supported. There may/should be both long and short forms of switches, like /h and /help.

35:50 Command Tree

If the app does a lot of different things, there may be a tree of possible commands. So, for instance, in rails, the rails app can generate things for you. So you might do rails generate migration to generate a database migration. Think of chained switches as being analogous to nested controllers in a web application if that helps.

38:39 Arguments

Switches may have their own arguments. The delimiter within a switch tends to be different than the delimiter between switches to make parsing easier. It’s also common to have switches indicating the level/verbosity of output that you want for certain kinds of commands.

40:39 Error Handling

When an app experiences an error, it’s best practice to return an exit code indicating failure. Commandline arguments may or may not be case sensitive, based on the environment. Many commandline apps have commandline switches to do a dry run. In other words, they tell you what would happen if you ran the command with those switches, without actually doing it.

44:05 Other Things To Note

If you are building a GUI application to run on a desktop or server, your app still receives and can use commandline parameters. You can still use stdin, stdout, and stderror in a GUI application.

” In fact, this is an excellent way to figure out what is going wrong in many linux programs when they hang up.”

You can offer commandline autocompletion in some environments. If you have a lot of available parameters, or complex ones, you may wish to offer an options file instead of just commandline parameters.