Abstraction, not syntax

The specific problems in the example could be solved by changing how the data is represented. Consider the following alternative representation, written in edn:

    {:aws.s3/buckets
     {:aws.region/eu-west
      {:alpha-hourly  {:lifecycle/policy {:delete-after #interval/days 4}}
       :alpha-daily   {:lifecycle/policy {:delete-after #interval/days 30}}
       :alpha-monthly {:lifecycle/policy {:delete-after #interval/days 365}}

       :bravo-hourly  {:lifecycle/policy {:delete-after #interval/days 4}}
       :bravo-daily   {:lifecycle/policy {:delete-after #interval/days 30}}
       :bravo-monthly {:lifecycle/policy {:delete-after #interval/days 365}}}}}

Obviously this doesn't prevent all errors, but it does prevent the specific errors that the RCL example solves, all without introducing a Turing-complete language.

YAML has a merge key The merge key is a clever little trick, but it depends of the special hash key, so lists can’t be merged.

Syntax does matter, which is why YAML matters — even if imperfect.

Finding the "right" representation for a given set of data is an interesting problem, but most (all) of the time the representation is specified by someone/something else.

In the past I've written a [preprocessor][1] that adds some power to the representation while avoiding general purpose computation. For example,

    (buckets
      (let ([(regional region (name policy) ...)
             ((['name name] ['region region] ['lifecycle_policy policy]) ...)])
        (regional us-west
          (alpha-hourly (delete_after_seconds 345600))
          (alpha-daily (delete_after_seconds 2592000))
          (alpha-monthly (delete_after_seconds 31536000))
          (bravo-hourly (delete_after_seconds 345600))
          (bravo-daily (delete_after_seconds 259200))
          (bravo-monthly (delete_after_seconds 31536000)))))

[1]: https://github.com/dgoffredo/llama

Instead, there’s a another software in the configuration of sample projects, instead of just using good code organization and sensible conventions.

  def say(message):
    o = dict(f=say, v=message))
    call(yaml.dumps(o))

  def eval(request):
    o = yaml.loads(request.body)
    match o[“f”]:
      case “say”:
        print(o[“v”])

As this article gets at, config files are one of those things, and they benefit hugely from the rampant abstraction violation of skipping an intermediary text format between the program doing the configuration and the program doing the work.

*or have internal versions of their APIs available in matching languages.