jsonnet
babashka
Our great sponsors
jsonnet | babashka | |
---|---|---|
48 | 112 | |
6,753 | 3,798 | |
1.0% | 1.0% | |
8.4 | 9.2 | |
8 days ago | 9 days ago | |
Jsonnet | Clojure | |
Apache License 2.0 | Eclipse Public License 1.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
jsonnet
-
A Reasonable Configuration Language
jsonnet[1] and kapitan[2] are the tools I currently use. Their learning curve is not optimal (and I tried to contribute to smoothen it with a jsonnet course[3] and a 'get started wit kapitan' blog post[4]), but once used to it it's hard to do without, and their combination makes them even more useful (esp. if you deploy K8s).
In Ruud's case, Jsonnet might have been worth looking at as Hashicorp tools can be configured with json in addition to HCL. But that would have been less fun I guess ;-)
I hope for Ruud it finds its niche, there's quite some competition in this field!
1: https://jsonnet.org/
-
Pkl, a Programming Language for Configuration
Kubernetes config is a decent example. I had ChatGPT generate a representative silly example -- the content doesn't matter so much as the structure:
https://gist.github.com/cstrahan/528b00cd5c3a22e3d8f057bb1a7...
Now consider 100s (if not 1000s) of such files.
I haven't given Pkl an in depth look yet, but I can say that the Industry Standard™ of "simple YAML" + string substitution (with delicate, error prone indentation -- since YAML is indentation sensitive) is easily beat by any of:
- https://jsonnet.org/
- https://nickel-lang.org/
- https://nixos.org/manual/nix/stable/language/index.html
- https://dhall-lang.org/
- (insert many more here, probably including Pkl)
-
Introduction to Jsonnet: The YAML/JSON templating language
jsonnet cli: link
-
10 Ways for Kubernetes Declarative Configuration Management
Jsonnet: A data template language implemented in C++, suitable for application and tool developers, can generate configuration data and organize, simplify and manage large configurations without side effects.
-
-❄️- 2023 Day 4 Solutions -❄️-
[Language: Jsonnet] (on GitHub)
-
What Is Wrong with TOML?
Maybe you'd like jsonnet: https://jsonnet.org/
I find it particularly useful for configurations that often have repeated boilerplate, like ansible playbooks or deploying a bunch of "similar-but" services to kubernetes (with https://tanka.dev).
Dhall is also quite interesting, with some tradeoffs: https://dhall-lang.org/
A few years ago I did a small comparison by re-implementing one of my simpler ansible playbooks: https://github.com/retzkek/ansible-dhall-jsonnet
- Show HN: Keep – GitHub Actions for your monitoring tools
-
That people produce HTML with string templates is telling us something
Apologies for the lack of context, and for missing this comment until today.
Both are tools for defining kubernetes manifests (which are YAML) in a reusable manner.
Jsonnet is a formally specified extension of JSON. It’s essentially a functional programming language (w/some object oriented features) that generates config files in JSON/YAML/etc, so it’s straightforward to determine whether an input file is valid, and to throw an error that points to an exact line if it’s not. It has a high learning curve, especially for people whose only experience is with imperative languages.
https://jsonnet.org/
Helm charts also generate YAML/JSON config files, but they use Go templating. This is easier and faster to understand, since it’s mostly string substitution and not much logic (there’s conditionals, iterators, and very basic helper functions). Unfortunately a simple typo or mistake can cause errors that are difficult to diagnose (the message may indicate a problem far away in code from the actual mistake). It can also generate output that’s valid according to the string templating rules, but not what was intended, which can be very confusing to debug.
Despite these shortcomings, the vast majority of kubernetes applications are distributed as helm charts. I understand why things ended up this way, but I still wish it were more common for people to invest the upfront effort to learn the superior tool, so it could be more widespread.
-
TOML: Tom's Obvious Minimal Language
I like Google's Jsonnet [1], which has all of this except for 4.
Jsonnet is quite mature, with fairly wide language adoption, and has the benefit of supporting expressions, including conditionals, arithmetic, as well as being able to define reusable blocks inside function definitions or external files.
It's not suitable as a serialization format, but great for config. It's popular in some circles, but I'm sad that it has not reached wider adoption.
[1] https://jsonnet.org/
- Jsonnet – The Data Templating Language
babashka
-
A Tour of Lisps
It also gives you access to Babashka if you want Clojure for other use-cases where start-up time is an issue
https://babashka.org/
- Babashka: Fast native Clojure scripting runtime
-
What's the value proposition of meta circular interpreters?
I've tried researching this myself and can't find too much. There's this project metaes which is an mci for JS, and there's the SCI module of the Clojure babashka project, but that's about it. I also saw Triska's video on mci but it was pretty theoretical.
-
Adding Dependencies on Clojure Project the Node Way: A Small Intro to neil CLI
Created by the same guy who created babashka which is a way to write bash scripts, node scripts, and even apple scripts using Clojure. A very proficient and influential developer in the Clojure community. This is how borkduke's neil helps us:
- Babashka
-
Pure Bash Bible
Not what you asked for but there is Babashka for scripting in Clojure.
https://github.com/babashka/babashka
-
Critique of Lazy Sequences in Clojure
Clojure's lazy sequences by default are wonderful ergonomically, but it provides many ways to use strict evaluation if you want to. They aren't really a hassle either. I've been doing Clojure for the last few years and have a few grievances, but overall it's the most coherent, well thought out language I've used and I can't recommend it enough.
There is the issue of startup time with the JVM, but you can also do AOT compilation now so that really isn't a problem. Here are some other cool projects to look at if you're interested:
Malli: https://github.com/metosin/malli
Babashka: https://github.com/babashka/babashka
Clerk: https://github.com/nextjournal/clerk
-
Sharpscript: Lisp for Scripting
Being a Clojure addict, I guess I have to leave the obligatory link to Babashka too then: https://github.com/babashka/babashka (Native, fast starting Clojure interpreter for scripting)
-
Rash – The Reckless Racket Shell
which is now on hiatus. babashka: https://babashka.org
-
Are there any languages (that are in common use in companies) and higher-level that give you the same feeling of simplicity and standardization as C?
I've enjoyed babashka for scripting; which is close enough to clojure to allow using some/many libraries; but (probably) not for embedding.
What are some alternatives?
kube-libsonnet - Bitnami's jsonnet library for building Kubernetes manifests
janet - A dynamic language and bytecode vm
dhall-lang - Maintainable configuration files
malli - High-performance data-driven data specification library for Clojure/Script.
cue - CUE has moved to https://github.com/cue-lang/cue
joker - Small Clojure interpreter, linter and formatter.
cue - The home of the CUE language! Validate and define text-based and dynamic configuration
nbb - Scripting in Clojure on Node.js using SCI
json5 - JSON5 — JSON for Humans
clojure-lsp - Clojure & ClojureScript Language Server (LSP) implementation
cdk8s - Define Kubernetes native apps and abstractions using object-oriented programming
racket - The Racket repository