Best Config File Format

Question

I'm starting a new multi-language project completely without cruft. I have to choose a format for config files. These will be:

• Written by humans (developers, not end users)
• Read by machines
• Maintained by humans
• Worked with by text editors (not a tool)

I have many different uses, like:

• List of modules to run
• Module execution order
• Parameters for algorithms
• General configuration (job name, project version, etc)

Some candidates I've thought of:

• XML
  • Hard to get right in a text editor
• INI
  • Can only do section-key-value
• Makefile
  • yikes!
• JSON
  • Have to escape " but syntax is widely known
• YAML
  • People have to learn the syntax and error messages aren't really good but its nice to have references

What would you use and why? Is there a panacea or are some better suited than others?

Answer 1

I'd suggest YAML. YAML is human friendly and readable.

If keys and values are all that you need, I'd go with INI or similar.

Answer 2

I would tend towards XML. Why ?

1. it's widely used and understood. Most technical people can understand what's going on
2. it's hierarchical. For all but the simplest cases you'll need to be able to specify some sort of nesting
3. there's a wide site of tools available to parse and manipulate XML (command line, APIs etc.)
4. it supports character encodings (important for I18N)
5. Can be validated against a schema

XML has it's shortcomings (e.g. angle-bracket tax) but given all the above I would go for XML for all but the simplest scenarios.

Answer 3

I'd say that answer depends on who is going to be using it.

JSON or YAML are probably a little nice to look at but as you have pointed out the parsing is a bit harder (but hey you're going to use a library anyway right?).

XML has the advantage that pretty much every developer is going to know how to use it without much fuss.

I'd probably tend towards YAML or JSON though because you don't go cross eyed looking at it.

Answer 4

For very many programs the section/key layout of an INI file is all that is needed. If you can get away with this, I suggest you do. People seem to like INI files (and it worked for Samba and PHP), but often violently dislike very structured formats such as XML - can't think why!

Answer 5

I understand the desirability of a single configuration file, but are you unnecessarily restricting yourself? Is it necessary to keep all configuration in one file? Would one format suit one subset of configuration more than another? You listed several different "categories" of configuration data, and it seems likely that they're not all similar in content or layout.

Hmm, I just answer your question with three more but I think they're all things I would take into consideration when making the choice, myself.

Answer 6

I'm a fan of using a simple programming language rather than a config format. Typically I'd suggest Lua.

I think variables and expressions is a fantastic way of removing redundancy and increasing the expressiveness in a configuration system (check out the examples in this post)

I understand there may be compatibility issues if it's a multi language project, but I think it should be considered at least.

Answer 7

I use and recommend Lua. It's easy to learn, easy to embed, is lightweight and has a liberal license. It was originally designed with rich, flexible configuration files in mind.

Answer 8

In your scenario I'd go for an ini file.

Other formats such as XML provide schema validation and the like. However you still need to validate (and possibly convert) any values read into your program regardless of the config file format used.

Most importantly the ini format is completely self explanatory and increases the signal to noise ratio to the point there is almost no noise, almost the opposite of XML.

• A list of modules to run
• Module execution order, as above.

These 2 uses can easily be represented in a non-hierarchical ini format. Ordering can be taken from physical ordering in ini file (just add a comment to state this).

• Parameters for algorithms
• General configuration (job name, project version, etc)

These 2 uses can be represented as key value pairs. It's what ini files do best.

You also mention that they will be created by Developers, but do not say who will be maintaining them. If maintenance is ever done by non-developers, ini files are so simple they reduce the likelihood of introducing errors.

Answer 9

I'd suggest Lua, even if it requires some time to set up. (Their API is really well done, but an API for a scripting language is always at least a bit complex)