Clojurians Log v2

@adam622 the problem with a hand-coded dependency graph is that the tasks are sort of "locally owned" by different teams. This project coordinates tasks across the org.

eql looks really neat, definitely something to investigate

@eraserhd are you familiar with terraform at all? would you say your tool is similar?

I am familiar, we use it. I have big rants on terraform. Our thing is much higher level.

Our thing's tasks are like, "we need a marketing site". That integration might use terraform.

There's some similarities, except that we really lean on forward-chaining rules. We need to have things built as early as possible, and we incrementally discover the information we need to do things.

A terraform-like thing using Clara would be nice!

I want to write a terraform like thing in clojure. So I may look closer at what you're saying here.

@dominicm Pulumi uses Terraform under the hood (and therefore takes advantage of the existing Terraform ecosystem), perhaps adapting Pulumi to Clojure would be a reasonable route to take https://github.com/pulumi/pulumi, https://github.com/pulumi/pulumi-terraform

Interesting, will take a look

@eraserhd we probably share complaints about terraform, and also the level at which you are describing things sounds similar to a project I tried to tackle things.

My main complaint is that it is trying to be declarative. I think that's a mistake in that domain. We frequently need one object per thing in some database, for example, and that leads to terrible duplication and weird text ETL procedures.

Those ETL procedures defeat the idea of what terraform is for. So they've added things like loops and getting external data, but it is kind of terrible and they don't want you to use it.

Oh I know. And the modules don't even help! Count doesn't even work for the "loop construct" in a number of cases, so you have to take explicit counts for everything

In reality, it should be pure functional.

right?!

The terraform language sucks, generally. I'd love it if they had a minimal extensible core.

I quite like the idea of figuring out some primitives for building your own tf :)

In Clojure, terraform really just becomes a data structure and a plan/apply procedure. The data structure can be generated by a function.

I mean, Clara is probably good here :D But not necessary.

The data structure needs some kind of ?var to bind results of some operations to inputs of others. Unlike the go people, we know about proper unification :D

So, I'm looking at clara to do the dependency graph of work semi-automatically. For example, when do you go fetch the list of GitHub users? Well, if something wants to query them (and then you cache it). If you've diffed the list of users, and something inserts a new user, then you need to change your actions based on that. This is a pretty half-baked idea though 🙂

So, are you using it ahead-of-time to build a plan? Or are you using it during execution?

execution

thinking about trade-offs, I decided that a plan is possible to do as an auxiliary based on a secondary set of rules which inform you of the "optimistic write output" of a task.