What is the simplest human readable configuration file format? [closed]

Question

Current configuration file is as follows:

mainwindow.title = 'test'
mainwindow.position.x = 100
mainwindow.position.y = 200

mainwindow.button.label = 'apply'
mainwindow.button.size.x = 100
mainwindow.button.size.y = 30

logger.datarate = 100
logger.enable = True
logger.filename = './test.log'

This is read with python to a nested dictionary:

{
  'mainwindow':{
    'button':{
      'label': {'value':'apply'},
       ...
  },
  'logger':{
     datarate: {'value': 100},
     enable: {'value': True},
     filename: {'value': './test.log'}
  }, 
  ...    
}

Is there a better way of doing this? The idea is to get XML type of behavior and avoid XML as long as possible. The end user is assumed almost totally computer illiterate and basically uses notepad and copy-paste. Thus the python standard "header + variables" type is considered too difficult.

The dummy user edits the config file, able programmers handle the dictionaries. Nested dictionary is chosen for easy splitting (logger does not need or even cannot have/edit mainwindow parameters).

Answer 1

You could use something like YAML. Here is a link to an example:

http://www.yaml.org/start.html

--- !clarkevans.com/^invoice
invoice: 34843
date   : 2001-01-23
bill-to: &id001
    given  : Chris
    family : Dumars
    address:
        lines: |
            458 Walkman Dr.
            Suite #292
        city    : Royal Oak
        state   : MI
        postal  : 48046
ship-to: *id001
product:
    - sku         : BL394D
      quantity    : 4
      description : Basketball
      price       : 450.00
    - sku         : BL4438H
      quantity    : 1
      description : Super Hoop
      price       : 2392.00
tax  : 251.42
total: 4443.52
comments: >
    Late afternoon is best.
    Backup contact is Nancy
    Billsmer @ 338-4338.

You can find Python bindings for it at PyYAML. It's a little more user friendly than JSON (which is what your second example looks like).

Answer 2

The best thing you can do is provide a mockup of your solution, and perhaps a mockup of a couple other solutions, and ask two or three representative users of your system. They will be much better at telling you what they like than the self-selected people who answer questions on this site.

That being said, for "basically computer illiterate" users I think the format you show in your question is probably the best plain text format. If they really are computer illiterate, you might want to consider a simple GUI so they don't have to hand-edit configuration files.

Answer 3

Lose everything you can lose. name.name.name=value, each on a separate line, is about as simple as you can get. You don't need the quotes for parsing, you know when true is a boolean and when true is a string, don't make the "dumb human" tell you that. For strings, if the field shouldn't have leading/trailing blanks, strip them yourself.

Answer 4

Imagine a Chinese person who doesn't know English who's trying to read your configuration file. Alternatively, imagine the configuration file is in Arabic (and that you don't known Arabic). Now ask yourself, is this really human readable?

Even if the reader does know English, they've still got no idea if "logger.datarate = 100" means 100 characters per second, or 100 GiB per hour, or 100 chickens per metric ton.

The most human readable file format, is a binary file with a decent GUI based dialog box/wizard/configurator (with internationalisation, help system, etc).

Answer 5

I'm with Patrick Hughes. Build a simple app for editing configurations. The config file itself could be a little more complex and might contain attributes for the editor to use (display name, help text, value type, min/max value, etc).

Answer 6

I say what you have (properties file) is already the best human readable configuration format. :)

Here are my arguments:

• Properties file is just key/value pair. Easily readable by human.
• Terse syntax, not like xml.
• Easily nest-able, with '.', like in your example.
• Flat structure allows easy diffing in a source controlled environment.

That last point is actually pretty important. Given that projects nowadays are all divided up into branches, configuration file can cause tons of pain when you are merging branches. Flat file format like properties file are easier to merge than tree structure file.