herbs-cli VS ante

> higher level paradigms, DSLs or a language that provides such capabilities out of the box for these reasons

Based on exactly this arguments that we created HerbsJS [1], a domain-first library to build microservices. While the essential complexity can't be removed [2], we should put effort to remove the accidental complexity as much as possible.

BTW, great to see this kind of discussion here and congratulations to the team responsible for Cell Lang.

[1] https://herbsjs.org/

Great article!

Given the absence of libs / frameworks to help in the domain part of the architecture, we created Herbs [1], where our proposal is to shift the focus of developing a microservice from the infrastructure (http, DB, logs, etc) to the domain , with an emphasis on use cases [2] and entities [3].

It may seem small but it changes a lot where you put energy into developing your software, especially maintaining it.

[1] https://herbsjs.org/

[2] https://herbsjs.org/docs/usecase/getting-started

[3] https://herbsjs.org/docs/entity/getting-started

Being productive while following the best software development practices has been one of the greatest challenges for developers. Today I can say that with HerbsJS this challenge becomes much friendlier.

Herbs CLI

Have you had a look at Ante? It looks a lot like a Rust 2.0 with better ergonomics. There are a lot of interesting ideas.

Ante is what you are looking for. It's an ML descendant with no RTS nor AGC.

In my experience, people believe that programming languages are a solved space, and we should stick with what we have.

It's unfortunate; because languages are very polarized today. I think there's a lot of room for languages that are safe, fast, and most importantly, *easy.* Today's languages are generally two out of three.

Luckily, a lot of languages are exploring that space!

* Vale is blending generational references with regions, to have memory-safe single ownership without garbage collection or a borrow checker. [0]

* Cone is adding a borrow checker on top of GC, RC, single ownership, and even custom user allocators. [1]

* Lobster found a way to add borrow-checker-like static analysis to reference counting. [2]

* HVM is using borrowing and cloning under the hood to make pure functional programming ridiculously fast. [3]

* Ante is using lifetime inference and algebraic effects to make programs faster and more flexible. [4]

* D is adding a borrow checker!

[0] https://verdagon.dev/blog/zero-cost-refs-regions

[1] https://cone.jondgoodwin.com/

[2] https://www.strlen.com/lobster/

[3] https://github.com/Kindelia/HVM

[4] https://antelang.org/

[Ante](https://antelang.org/): lifetime inference, refinement types, algebraic effects.