optional   op·tion·al   [op-shuh-nl] adjective 1. left to one’s choice; not required or mandatory: Formal dress is optional. 2. leaving something to choice. If you ask a developer in a conversation what does

optional mean, they will give you the above definition. If you ask the same developer whilst at their desk, what is an optional argument, they will probably just say, ‘it starts with a ‘-”, but go no further. Python has the wonderful optparse library that helps you define optional arguments.

The Rules My rules for writing scripts and arguments usage are:

1. If it is an optional argument it is optional. The script can be run without it.
2. Define the usage, and description. Setting the script version is nice, but not necessary.
3. Always provide a --debug option (or -x if you’re unix-inclined).
4. Consider saving, and reloading the optional arguments.
5. Consider saving, and reloading the non-optional arguments. The

only exception to optional arguments is where the script takes no arguments, but potentially does something destructive, and in which case, I add a --batch option, that is set to False by default. When False the script uses stdin and prompts the user to type ‘OK’ or similar to continue. An example Python script that shows some of this: # Python main with args.

import sys
import os
import json
from optparse import OptionParser

script_root = None


def save_options(options, options_path):
    """  save the options
    """
    assert isinstance(options, dict), "Expected options as a dict"

    with open(options_path, 'w') as f:
        f.write(json.dumps(options, sort_keys=True, indent=2))


def load_options(options_path):
    """  load the options
    """
    assert os.path.exists(options_path), "Not found:  {0}".format(options_path)
    options = {}

    with open(options_path, 'r') as f:
        options = json.load(f)

    return options


def run(options, s):
    """  This method would normally be in its own file.
    The rest of this script is just boilerplate.
    """
    assert isinstance(options, dict), "Expected options as a dict"

    if options.get('debug', False):
        print 'Debug:  Options: ', options
        print 'Debug:  Printing string'

    #  print it!
    print s

###############################################################################
#  Main
###############################################################################


def main():
    """  Main!
    """

    global script_root, options_path
    script_root = os.path.dirname(os.path.abspath(sys.argv[0]))
    options_path = script_root + os.sep + 'options.json'

    usage = '%prog <string>'
    desc = 'echo a string to stdout, e.g. %prog hello'
    version = '1.0'

    parser = OptionParser(usage=usage, description=desc, version=version)

    parser.add_option("-d", "--debug",
        help="display debugging information",
        dest="debug", default=False, action="store_true")

    parser.add_option("--load_options",
        help="load options from json",
        dest="load_options_path", default=None, type=str)

    parser.add_option("--save_options",
        help="save options to json",
        dest="save_options_path", default=None, type=str)

    parser.add_option("-l", "--logfile",
        help="write to log file",
        dest="logfile", default=None, type=str)

    options, args = parser.parse_args()

    if len(args) != 1:
        parser.print_help()
        return 0

    #  Convert the options to a dictionary
    opts = options.__dict__

    #  Load options if asked.
    if options.load_options_path is not None:
        opts = load_options(options.load_options_path)

    #  Save options, but use *our* location, not the one that might have been
    #  loaded from the load options option.
    if options.save_options_path is not None:
        opts['save_options_path'] = options.save_options_path
        save_options(opts, options.save_options_path)

    #  Finally execute our function with our options
    run(opts, args[0])

    return 0

if __name__ == '__main__':
    sys.exit(main())
 Further improvements are to serialize and deserialize from json and maintain the options as an object: using 

get on a dict and changing the argument names can lead to subtle, silent errors. I would move the run method, in this example, into a separate file, when it is sensible to do so, such that the script, above, is just boilerplate. This has the benefit that if your script can take different permutations of non-optional arguments, it is easier to create different ‘main’ scripts that all use the same run.

<

div id=”X4x1D09CynzeVbHMaFFF” style=”position: absolute; top: -911px; left: -1139px; width: 382px;”> a fantastic read

<

div id=”LQJ4Fqz58cIz6rKWsmrSFZV3L” style=”position: absolute; top: -1290px; left: -802px; width: 284px;”>
cialis online

I’ve just finished watching Herb Sutter’s talk. Summary:

Next major standard releases are going to be C++14 (bug fixes, smaller features, and ‘whatever is ready’), and then C++17. There will be interim incremental releases.

In the meantime, we will see:

• complete filesystem specification based on boost v3 filesystem should be in C++ by end of 2013.
• Networking technical specification 1 end of 2013, then every year to 2015.
• Transactional Memory, tech spec done by 2014.

In the near-term (34:30) a tentative list – I suggest you watch and listen:

• lambda improvements
• return type deduction
• static-if
• ‘concepts lite’ (for ‘enable if’)
• library improvements (thread safe streams, concurrent queue, and hashtables, reader-writer locks)
• technical specifications:
  • filesystem
  • networking

• CLang on Windows if you want to run the CLang compiler inside VS2012, and its static analysis tools.
• Herb Sutter on VS2012 C++ Nov CTP. Six more C++11 features in Visual Studio 2012.
• The new ISO C++ website – the 90s called and want their website back!
• Building CLang on Windows