cross-posted from: https://programming.dev/post/1743099

.yaml, .toml, etc?

all 46 comments

sorted by: hot top controversial new old
[–] 33 points 3 years ago
[–] 27 points 3 years ago (2 children)

There is no best. It depends on the application

  • source
  • hideshow 4 child comments
  • [–] 2 points 3 years ago (1 child)
  • [–] 7 points 3 years ago

    Some applications don't have enough config entries to warrant support for nested entries

    Some applications need variable-length data, and some even variable-length lists

    Some applications don't care about having fast read/write times or a small memory footprint and can do with more complex formats that require the use of third-party libraries

    Some embedded applications (e.g. AVR) don't have access to a whole lot of libraries

  • source
  • parent
  • [–] 16 points 3 years ago (1 child)

    The one already being used by the project.

  • source
  • hideshow 2 child comments
  • [–] 8 points 3 years ago (1 child)

    Yup. If I have to pick one for a new project, I'll go with TOML unless there's a reason to pick something else. I like that it's simple, while also having a bunch of features for when the project grows.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 5 points 3 years ago (1 child)

    Pretty much same here. With Spring stuff I still use YAML because TOML doesn't have first class support yet. If TOML is an option I don't have to go too far out of my way for them I go for it.

    YAML has too many foot guns. It's still less annoying to read and write than JSON though. Properties files are okay but there doesn't seem to be an agreed upon spec, so for edge cases it can be confusing.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 3 points 3 years ago* (1 child)

    Yup, YAML is a terrible data format, but for a configuration format that you completely control, it works well. Your parser only needs to be good enough to read the configs you create.

    Likewise, JSON is a pretty bad config format due to strictness in the syntax (no optional commas, excessive quotes, etc), but it's pretty good data format because it's pretty easy to parse.

    TOML is like YAML, but it has fewer corner cases so it's pretty easy to learn completely.

    Though anything is superior when it's already the status quo on a project.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 1 point 3 years ago

    I don't know dude, with YAML treating the word no as a Boolean and having like 6 types of multi line strings I'm really inclined to disagree with the "fewer corner cases" part. It's like waaaaaaaay less corner cases. Imagine pasting the ISO abbreviation for a country as a Boolean value.

  • source
  • parent
  • [–] 13 points 3 years ago* (1 child)
  • [–] 4 points 3 years ago (2 children)

    Agreed. YAML is a pain to edit manually, to ensure that all the tabulation is correct and the parser does not choke. JSON is passable, but you must be mindful about the brackets. XML is too verbose and duplicative. INI files are just good enough.

  • source
  • parent
  • hideshow 4 child comments
  • [–] 12 points 3 years ago

    A well documented one.

  • source
  • [–] 11 points 3 years ago (1 child)

    JSON is overly verbose and doesn't allow comments. Please do not use it for anything that humans frequently need to read or write.

    YAML is a syntactic minefield. Please do not use it for anything ever.

  • source
  • hideshow 2 child comments
  • [–] 1 point 3 years ago (1 child)

    How is it syntatic minefield? I find it at least more reasonable than XML. The comment feature is nice to have.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 9 points 3 years ago (1 child)

    Definitely not yaml. It's spec is horrible.

    Toml is pretty nice though.

  • source
  • hideshow 2 child comments
  • [–] 11 points 3 years ago (1 child)

    I hate table definitions in TOML with a passion.

    I like YAML. I guess that's because I don't need to build parsers for it. What's your worst complain about it?

  • source
  • parent
  • hideshow 2 child comments
  • [–] 13 points 3 years ago (2 children)
  • [–] 4 points 3 years ago (1 child)

    Thie essentially boikls down to "quote yur shit". Yes, it can be frustrating if a language superficially allows you to use unqoted strings with the promise that it will inteligently interprets that. It's like parentheses in arithmetics. If you are not sure or if you are not competent in a language enough to predict the order of operations, use parentheses. The same with strings and quotes in yaml.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 6 points 3 years ago (1 child)

    .ini has never let me down.

  • source
  • hideshow 2 child comments
  • [–] 5 points 3 years ago (1 child)

    I'd say a file that you can open with a simple text editor is convenient, so it can be a simple .conf/.ini, more complex are .xml/.yaml that you can still edit in vim/nano but can be cumbersome.

    But as others say, it all depends on your app...

  • source
  • hideshow 2 child comments
  • [–] 4 points 3 years ago (1 child)

    Not XML. Not binary-only (looking at you, Solaris).

    Personally, I like .ini-style config files, but I'm weird that way.

  • source
  • hideshow 2 child comments
  • [–] 3 points 3 years ago (1 child)

    Toml is kind of ini++, though, isn't it.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 3 points 3 years ago

    I really dislike when indentation is a part of the syntax (like in YAML). Apart from that it depends on the requirements of the project.

  • source
  • How able Lua?

    It's a programming language, so you can do fancy stuff, or you can just use it as a regular key value file. You can also safely enable/disable features so you only need to allow the subset of Lua that you need.

    It works really well for things like editor configuration (see neovim), and it's especially nice if you already use Lua as a plugin language or something.

  • source
  • [–] 1 point 3 years ago

    nix

    This post was sponsored by NixOS gang

    (jokes aside, json is king. Yaml is a pain in the ass)

  • source
  • [–] 1 point 3 years ago
    [–] 1 point 3 years ago

    UCL and HCL are interesting, but YAML is more widely supported.

  • source
  • [–] 1 point 3 years ago*

    If you use protobuf/gRPC anywhere in your application, text format protobuf. Writes like JSON, but with a clear schema, a parser that already exists in most languages, and has comments.

  • source
  • [–] 1 point 3 years ago

    https://nestedtext.org/

    It’s like yaml but simple, consistent, untyped, and you never need to escape any characters, ever.

    Types and validation aren’t going to be great unless they’re in the actual code anyway.

  • source
  • [–] 0 points 3 years ago

    Overall, JSON5 (having comments and end-of-line commas is a big reason I got into YAML).

    I suffer with YAML, but use it pretty heavily. It also has the * and & operators which I use fairly heavily, and it fits well with the Markdown + YAML I use, but I hate that whitespace indenting with a passion.

    Occasionally, I look at Nickle (https://github.com/tweag/nickel) and KDL (https://kdl.dev/) and I get really tempted, just haven't made that jump.

  • source
  • [–] 0 points 3 years ago
    [–] 0 points 3 years ago (1 child)
  • [–] 2 points 3 years ago (1 child)

    Meh, at that point, you may as well use python.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 1 point 3 years ago

    I like Python and use it a lot, but Dhall has several guarantees that Python doesn't. If you hand someone clever a Python interpreter, they can and will find a way to run rm -rf / or what-have-you, no matter what safeguards you put in place. Dhall also guarantees that it will terminate, which is pretty useful if you're embedding it in something else. In Python you could pretty easily accidentally or purposefully get into a while True loop.

  • source
  • parent