https://stevana.github.io/towards_zero-downtime_upgrades_of_stateful_systems.html
I haven’t read that paper, but I just skimmed it now and I agree with the
sources of complexity that they identify: implicit state, control and volume.
Their “Functional Relational Programming” is also similar to what I’m doing:
- Their feeders and observers are my sources and sinks;
- Implicit parallelism (pipelining);
- They propose a relational model for transforming data that flows through this
pipeline, while I haven’t thought of it that way it makes sense: one of my
sources of inspiration is Jim Gray and in the video that I link to he said that
this pipelining architecture is used inside relational databases.
I would have to study the paper in more detail to say more than that, unless you
have a more specific question? Either way, thanks for sharing the paper!
My mistake: I should have been more specific - what is your opinion of section 5.2 (pages 15-18 of 66)?
For what it’s worth, I also looked into module reloading at runtime for GitHub - ButlerOS/module-loader , but that didn’t work in non interpreted mode.
There’s also GitHub - fbsamples/ghc-hotswap: Example code for how we swap compiled code within a running Haskell process. and GitHub - nmattia/haskell-hot-swap: Hot swapping compiled code while keeping a websocket connection open , I haven’t tried either yet though.
This section seems to be mostly about the role of state in functional programming. I agree with the analysis there, it seems fairly standard and uncontroversial.