ThoughtStorms Wiki

Context : ATreeByTheRiver

Here's a common problem.

Git source-code manager is designed like a river. There are various tributaries (different repos of other programmers, different branches for specific developments) etc. It's easy and automatic to pull them into the single main flow as and when you need it.

But we don't have the equivalent tools to help us fan out from a single flow into multiple customized derivatives.

Yes, we can fork code-bases, but forking is a one-time operation. And once your forked derivatives are separate there are few automatic ways to keep them updated from changes to the parent stream. The moment your customization breaks with the mainstream, git merging etc. fail.

Even if you try to put your customizations in terms of patches to the mainstream, they can still break.

Contrast with inheritance in ObjectOriented programming where you do automatically get some of the benefits from the super-classes changing and being improved. Your subclass rarely breaks syntactically. (Although obviously the meaning can change)

Surely this is a standard DevOps requirement that there should be tooling support for these days?

Surely someone has defined an algebra or defined set of operations for "fanning out" in this way.

Is there an AlgebraOfFeeds parallel?

I asked this on StackOverflow

My Quora Question.

Tools like Git seem to help with "fan-in" pattern of managing code. What I mean is that they help when you want to bring multiple forks / contributors together again into a single release.

But are there any good tools to help with the opposite. A "fan-out" pattern where you have a continuously evolving common core but want to manage multiple derivative / customized versions of the code?

I guess this is BuildAutomation and DevOps types software.

Found myself writing this today about the problem of keeping the same thing in two places in a DigitalGarden

Yeah. I'm fascinated by what I call the "fan out problem". How to handle things that start from a common root and diverge. You want to allow the derivatives to change, but also, sometimes allow updates at the root to percolate through to all the derivatives.

This is a problem for writing, for code, pretty much everywhere. (It's the problem of brittle inheritance in OO programming)

Manually copy and pasting is good for allowing derivatives to evolve separately, but lousy for letting changes to the root percolate to the derivatives.

Transclusion is the opposite. (With the caveat that my own implementation still has some issues here, but they will be fixed)

But if someone could actually figure out a viable way of representing how you could combine live updates from a root, with dynamic patches to add variation in the derivatives, that don't break when the root changes (or at least break in very informative / recognisable / and fixable ways) then it would be revolutionary.

Thinking about it, perhaps it's a job for GPT and LangChain ... "watch this origin text, and when it changes, create a new derivative text that modifies the original with these extra points and modifications".

Backlinks (2 items)