dhall-lang VS wasp

Fail to see how this is any different than Dhall (https://dhall-lang.org/) other than it produces plists too.

Well, Dhall provides something between JSON and a Turing complete language that can make a lot of configuration much quicker to write, if you can hack the functional syntax.

http://dhall-lang.org/

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)

Indeed why? However the conclusion I have is not to use JSON but to use a type safe configuration language that can express my intent much better making illegal states impossible. One example of such lang is Dhall.

https://dhall-lang.org/

Throwing in a plug for https://dhall-lang.org/

> Dhall is a programmable configuration language that you can think of as: JSON + functions + types + imports

There are underpowered languages / tools, that can only solve a problem for which they are intended poorly. But not all limited tools are like that.

Say, eBPF is prominently not Turing-complete, which allows to guarantee that a eBPF program terminates, and even how soon. Still eBPF is hugely useful in its area.

Or, say, regular expressions are limited to regular languages; in particular, they famously [1] cannot process recursive structures, like trees. Still tools like grep / ag / rg are mightily useful.

Yes, I agree that YAML is underpowered for proper k8s configuration! But it's also too powerful for its own good in other aspects [2]. I wish Google used Dhall [3] or their own purely functional config language (FCL? I already forgot the name) instead of YAML; sadly, they did not.

[1]: https://stackoverflow.com/a/1732454/223424

[2]: https://ruudvanasseldonk.com/2023/01/11/the-yaml-document-fr...

[3]: https://dhall-lang.org/

Dhall: Dhall is a programmable configuration language that combines features like JSON, functions, types, and import capabilities. Its style leans towards functional programming, so if you're familiar with functional-style languages such as Haskell, you might find Dhall to be quite intuitive.

I've been thinking along these lines but more 'strongly validated' than statically typed in the sense that you'd be better off being able to load the entire config and then produce a list of problems (and should be able to offer good editor support if done correctly).

Though https://dhall-lang.org/ demonstrates that you can statically type quite a lot of configuration to great advantage, which appears to be programmatically embeddable in multiple languages per https://docs.dhall-lang.org/howtos/How-to-integrate-Dhall.ht...

I agree, I quite like https://dhall-lang.org/ for that reason. It strikes a good balance between features and being a config language.

If you already have some sort of foundation in programming, use AI and some great abstractions/frameworks to get things done even faster. For example, instead of creating everything from the ground up (and probably suffering on little things along the way) you can skip repeating yourself a ton of times by using Wasp, which is a great React/Node full-stack framework that takes care of managing the boilerplate side of programming for you. 🤯

Aider is one of my favorite AI agents, especially because it can work with existing codebases. We've seen a lot of good results from folks who used it with Wasp (https://github.com/wasp-lang/wasp) - a full-stack web framework I'm working on.

A "marketingy" demo video: https://www.youtube.com/watch?v=DXunbNBpgZg&ab_channel=Wasp

Thanks for reading! Find more about Wasp and support us on our journey to reaching 10,000 stars here.

For those who want the tool to have full control over their stack simply and easily, look no further! Wasp is an opinionated full-stack framework that leverages its compiler for a fast and easy way to create a database, backend, and frontend for your app. It uses React, Node.js, and Prisma, which are some of the most well-known tools that full-stack web developers are using.

Although our main product is Wasp, a full-stack framework on top of React & Node.js, here’s what we launched so far:

Yes, there is already a (good) SaaS template for Ruby on Rails called Bullet Train (https://bullettrain.co), so it might be helpful to distinguish yours as the JS-oriented option.

Your in good company, though, as your MVC framework of choice states that it is a "Rails-like" framework (https://wasp-lang.dev).

CoverLetterGPT is made with React, Node.js, and Prisma, powered by the Wasp framework, which takes care of all the plumbing and removes a ton of boilerplate. The best part is you can deploy your app for free when you’re ready by running a single CLI command: wasp deploy.

For example, according to the StateOfJS survey of 2022 (we're still waiting for 2023 results to roll in), there were 5 Front-end Frameworks with good retention in 2018; there were 11 in 2022. That’s a 120% increase in a matter of 4 years, and that’s not even taking into account the hot meta-frameworks like NextJS, Wasp, SvelteKit, or Astro!

On the flip side, if you’re a beginner or Junior dev, once you have the basics of HTML, CSS, and JS under your belt, it doesn’t really matter what framework you learn. I personally started learning backend development with PHP, but then later switched to frontend in Angular. In my second subsequent role I used React, and now I work with Wasp (a full-stack framework built on top of React and Node.js) to develop my side project, https://reflectdaily.app/. Developers never stop learning, so it’s kind of a non-argument to deride any specific framework — unless it really sucks, but then no one will continue to use it anyway.