JSON configuration file format

JSON is a data interchange format. Should it also be used as a configuration file format, a JSON-CF?

Overview
Had to write yet another properties file for configuration info. Started to think that maybe there are better alternatives. Wondered about JSON for this.

Requirements
What are requirements of a configuration file format?

• Simple
• Human readable
• Cross platform
• Multi-language support
• Unicode support

Looks like JSON has all the right qualities.

If all you want to pass around are atomic values or lists or hashes of atomic values, JSON has many of the advantages of XML: it’s straightforwardly usable over the Internet, supports a wide variety of applications, it’s easy to write programs to process JSON, it has few optional features, it’s human-legible and reasonably clear, its design is formal and concise, JSON documents are easy to create, and it uses Unicode.
— Norman Walsh, Deprecating XML

JSON-CF Limitations

• Instead of angle brackets as in XML, we have quotation marks everywhere.

What does it need?

• Inline comments, see for example, json-comments
• Interpolation (property expansion)
• Namespaces
• Inheritance
• Includes
• Date value
• Schema
• Cascading

Example

{
    "_HEADER":{
            "modified":"1 April 2001",
            "dc:author": "John Doe"
    },
    "logger_root":{
            "level":"NOTSET",
            "handlers":"hand01"
     },
    "logger_parser":{
            "level":"DEBUG",
            "handlers":"hand01",
            "propagate":"1",
            "qualname":"compiler.parser"
    },
    "owner":{
             "name":"John Doe",
             "organization":"Acme Widgets Inc."
     },
     "database":{
             "server":"192.0.2.62",     
             "_comment_server":"use IP address in case network name resolution is not working",
             "port":"143",
             "file":"payroll.dat"
      }
}

Programmatic Access using Groovy

Now we can easily read this file in Java. Using Groovy is much easier, of course. Groovy version 1.8 has built-in JSON support, great blog post on this here.

import groovy.json.*;

def result = new JsonSlurper().
                          parseText(new File("config.json").text)

result.each{ section ->
	println "$sectionn"
}

>groovy readConfig.groovy
Resulting in Groovy style data structure, GRON, (look ma, no quotation marks):

logger_parser={qualname=compiler.parser, level=DEBUG, propagate=1, handlers=hand01}

owner={organization=Acme Widgets Inc., name=John Doe}

_HEADER={dc:author=John Doe, modified=1 April 2001}

database={port=143, file=payroll.dat, server=192.0.2.62, _comment_server=use IP address in case network name resolution is not working}

logger_root={level=NOTSET, handlers=hand01}

In Groovy you can access the data with GPath expressions:
println “server: ” + result.database.server

You can also pretty print JSON, for example:
println JsonOutput.prettyPrint(new File(“config.json”).text)

Summary

Raised the question of the use of JSON as a configuration file format.

What I don’t like is the excess quotation marks. YAML is more attractive in this sense. But, the indentation as structure in YAML, similar to Python, may not be wise in configuration files.

Well, what is the answer, should there be a JSON-CF? I don’t know. A very perceptive caution is given by Dare Obasanjo commenting on use of new techniques in general:

So next time you’re evaluating a technology that is being much hyped by the web development blogosphere, take a look to see whether the fundamental assumptions that led to the creation of the technology actually generalize to your use case.

Updates

• After writing and posting this I searched the topic and, of course, this is not a new question. Search. I updated the reading list below with some useful links.
• JSON Activity Streams are an example of how JSON is used in new ways.
• schema.org types and properties as RDFS in the JSON format: schema.rdfs.org/all.json
• Just learned that node.js uses the NPM package manager which uses a JSON config file format.
• Jan 7, 2012: Java JSR 353: Java API for JSON Processing

Further Reading
– Apache Avro 1.7.7 Specification Schemas
– Analysis of JSON use cases compared to XML
– json-schema.org
– JSON Validation Roundup
– A very simple data file metaformat
– GRON
– HAL – Hypertext Application Language
– NPM configuration file format
– XML or YAML for configuration files
– Using JSON for Language-independent Configuration Files
– INI file
– JSON+Comments
– Comparison of data serialization formats
– Data File Formats, in Art of Unix Programming, Eric Steven Raymond.
– ConfigParser – Work with configuration files
– JSON
– Cascading Configuration Pattern
– java.util.Properties
– RFC 4627
– XML-SW,a skunkworks project by Tim Bray. Brings a bunch of XML complex together into one spec.
– YAML
– ISO 8601
– Learning from our Mistakes: The Failure of OpenID, AtomPub and XML on the Web
– Groovy Object Notation (GrON) for Data Interchange
Groovy 1.8 Introduces Groovy to JSON
– JSON-LD ‘JSON for Linking Data
– JSON Schema

 

---

” Sacred Place ” , R.Towner / P. Fresu, live in Innsbruck , Part 4