Suggestions for implementation of a command line interface

Question

I am redesigning a command line application and am looking for a way to make its use more intuitive. Are there any conventions for the format of parameters passed into a command line application? Or any other method that people have found useful?

Answer 1

-operation [parameters] -command [your command] -anotherthings [otherparams]....

For example,

YourApp.exe -file %YourProject.prj% -Secure true

Answer 2

If you are using C# try Mono.GetOptions, it's a very powerful and simple-to-use command-line argument parser. It works in Mono environments and with Microsoft DotNet.

EDIT: Here are a few features

• Each param has 2 CLI representations (1 character and string, e.g. -a or --add)
• Default values
• Strongly typed
• Automagically produces an help screen with instructions
• Automagically produces a version and copyright screen

Answer 3

If you use one of the standard tools for generating command line interfaces, like getopts, then you'll conform automatically.

Answer 4

Best thing to do is don't assume anything if you can. When the operator types in your application name for execution and does not have any parameters either hit them with a USAGE block or in the alternative open a Windows Form and allow them to enter everything you need.

c:\>FOO

FOO

USAGE FOO -{Option}{Value}

-A Do A stuff
-B Do B stuff

c:\>

Parameter delimiting I place under the heading of a religious topic: hyphens(dashes), double hyphens, slashes, nothing, positional, etc.

You didn't indicate your platform, but for the next comment I will assume Windows and .net

You can create a console based application in .net and allow it to interact with the Desktop using Forms just by choosing the console based project then adding the Windows.Forms, System.Drawing, etc DLLs.

We do this all the time. This assures that no one takes a turn down a dark alley.

Answer 5

I always add a /? parameter to get help and I always try to have a default (i.e. most common scenario) implementation.

Otherwise I tend to use the "/x" for switches and "/x:value" for switches that require values to be passed. Makes it pretty easy to parse the parameters using regular expressions.

Answer 6

The conventions that you use for you application would depend on

1) What type of application it is.
2) What operating system you are using. Linux? Windows? They both have different conventions.

What I would suggest is look at other command line interfaces for other commands on your system, paying special attention to the parameters passed. Having incorrect parameters should give the user solution directed error message. An easy to find help screen can aid in usability as well.

Without know what exactly your application will do, it's hard to give specific examples.

Answer 7

One thing I like about certain CLI is the usage of shortcuts.
I.e, all the following lines are doing the same thing

myCli.exe describe someThing
myCli.exe descr someThing
myCli.exe desc someThing

That way, the user may not have to type the all command every time.

Answer 8

Here's a CodeProject article that might help you out...

C#/.NET Command Line Arguments Parser

IF VB is your flavor, here's a separate article (with a bit more guidance related content) to check out...

Parse and Validate Command Line Parameters with VB.NET

Answer 9

The conventions that you use for you application would depend on

1) What type of application it is. 2) What operating system you are using.

This is definitely true. I'm not certain about dos-prompt conventions, but on unix-like systems the general conventions are roughly:

1) Formatting is

appName parameters

2) Single character parameters (such as 'x') are passed as -x 3) Multi character parameters (such as 'add-keys') are passed as --add-keys

Answer 10

Command line conventions vary from OS to OS, but the convention that's probably gotten both the most use, and the most public scrutiny is the one supported by the GNU getopt package. See http://www.gnu.org/software/libc/manual/html_node/Using-Getopt.html for more info.

It allows you to mix single letter commands, such as -nr, with longer, self-documenting options, such as --numeric --reverse. Be nice, and implement a --help (-?) option and then your users will be able to figure out all they need to know.

Answer 11

Complementing @vonc's answer, don't accept ambiguous abbreviations. Eg:

  myCli.exe describe someThing
  myCli.exe destroy someThing
  myCli.exe des someThing ???

In fact, in that case, I probably wouldn't accept an abbreviation for "destroy"...

Answer 12

I see a lot of Windows command line specifics, but if your program is intended for Linux, I find the GNU command line standard to be the most intuitive. Basically, it uses double hyphens for the long form of a command (e.g., --help) and a single hyphen for the short version (e.g., -h). You can also "stack" the short versions together (e.g., tar -zxvf filename) and mix 'n match long and short to your heart's content.

The GNU site also lists standard option names.

The getopt library greatly simplifies parsing these commands. If C's not your bag, Python has a similar library, as does Perl.

Answer 13

If you're using Perl, my CLI::Application framework might be just what you need. It lets you build applications with a SVN/CVS/GIT like user interface easily ("your-command -o --long-opt some-action-to-execute some parameters").