pkl VS rcl

Pkl solves the "bad config in production" problem:

The other deserving a mention is Pkl. Common denominator of being backed by a FAANG and having a lot of real world use.

https://github.com/apple/pkl

Apple has a similar project called Pkl which they use for their internal cloud configuration. http://pkl-lang.org/

It can be converted to JSON, yaml, and a bunch of other formats, and whilst it looks a bit like JSON it's actually a full blown functional programming language designed for creating config trees. The nice thing about Pkl is that it's got full IDE support and the standard library is patterned after Kotlin. So all the method names are very obvious and intuitive especially if you know Java or Kotlin. It has lots of features for validation like range types and so on, so you can get a lot of semantic checking before any config is emitted. It's the first config-as-language language I've seen that is actually good.

KSON looks more like an alternate syntax than a language, which is fine, but because JSON/YAML are just data structures sometimes you really want to do a for loop.

When I manage a project and have the freedom to choose my configuration structure, then I always use typescript. I never understood the desire to have configuration be in ini/json/jsonnet/yaml. A strongly typed configuration with code completion seems so much more robust. Except of course your usecase is to load or change the config via an API.

I like what apple is doing with https://pkl-lang.org/ though.

I was first turned onto Pkl during my Dhall Trough of Disillusionment phase (Dhall is cool, but man is it hard) by James Ward. It looked to be a language that had enough types to compile YAML/JSON configuration files wayyyy more safely. I’ve had enough YAML/JSON misconfigurations break production, that I started looking into ways to compile those problems away, and Dhall helped a lot, but the learning curve and compiler errors are brutal to work through, and I never got excitement amongst peers. Hoping Pkl makes in-roads here.

https://github.com/apple/pkl-go/blob/v0.6.0/.circleci/config... seems to imply it's "curl && chmod" so maybe you're thinking of developing pkl itself?

I happened to have a container that I am certain contains no Java and it fired right up

  $ docker run -it --rm --entrypoint=/usr/bin/env public.ecr.aws/aws-cli/aws-cli:2.15.38 bash -c 'curl -fsSLO https://github.com/apple/pkl/releases/download/0.25.3/pkl-linux-aarch64; chmod a+x pkl-linux-aarch64; ./pkl-linux-aarch64 --help'

Pkl Official Documentation

Very cool!

You might want to consider also publishing a schema for it too, as a Pkl package. The package can simply be published as a GitHub release (see details in this post here: https://github.com/apple/pkl/discussions/85#discussioncommen...)

RCL (https://github.com/ruuda/rcl) pretty-prints its output by default. Pipe to `rcl e` to pretty-print RCL (which has slightly lighter key-value syntax, good if you only want to inspect it), while `rcl je` produces json output.

It doesn’t align tables like FracturedJson, but it does format values on a single line where possible. The pretty printer is based on the classic A Prettier Printer by Philip Wadler; the algorithm is quite elegant. Any value will be formatted wide if it fits the target width, otherwise tall.

The author of this article created RDL:

> RCL is a domain-specific language for generating configuration files and querying json documents. It extends json into a simple, gradually typed, functional programming language that resembles Python and Nix.

https://github.com/ruuda/rcl

https://rcl-lang.org

If like me you can do basic queries in jq, but as soon as it gets slightly more complex (e.g. filter objects where some nested property that may not exist has a particular value), you wish you could do it with familiar Python/Rust/Javascript-like expressions and map/filter, try https://rcl-lang.org/#intuitive-json-queries.

If you have to deal with tools that need to be configured with yaml, give https://rcl-lang.org/ a try! It can be "coded" to avoid duplication, with real variables, functions, and loops. It can show you the result that it evaluates to. It can do debug tracing, and it has a built-in build command to generate files like GitHub Actions workflows from an RCL file.

Cue and RCL are both json supersets, though in very different ways. Cue is based on graph unification, while RCL is a more traditional functional language. Both are typed, though the type systems are very different. Like RCL, Cue can be used to query json documents, but in RCL this is a first-class feature with similar ergonomics to jq.

Jsonnet is quite similar to RCL: both are json supersets that add variables and functions in similar ways. Jsonnet is dynamically typed, while RCL features an optional gradual type system. Where Jsonnet draws inspiration from Go, RCL draws inspiration from Python and Rust.

Like Nickel, RCL is a gradually typed functional configuration language. Where Nickel has Haskell-like syntax, RCL has C/Rust/Javascript-like syntax with inspiration from Python.