Re: [Caml-list] [ANN] OCamp - Reactive programming in the shell

["Frédéric Bour" <frederic.bour@lakaban.net>]

Code is finally available at:
     https://github.com/def-lkb/ocamp

Sorry for the little delay!

On 01/04/2015 22:32, Frédéric Bour wrote:
> OCamp extends unix shells with constructions to express memoization, 
> sharing of computations and reactive programming.
>
> # Subcommands
>
> ## fire
>
> Just wrap a unix command with "ocamp fire" to enable the extension:
>   $ ocamp fire bash
>
> This will spawn a new bash session where the following subcommands are 
> enabled.
>
> ## hipp
>
>   $ ocamp hipp <command>
>
> Will memoize the output and exit status of <command>.
> Later calls to the same <command> won't lead to actual execution, but 
> just to a duplication of its previous output.
> Concurrent calls to <command> will just share the same process, the 
> beginning of the output being replayed to later callers.
>
> The identity of a command is defined by its arguments and working 
> directory.
>
> ## stir
>
>   $ ocamp stir <command>
>
> Indicate potential changes in the output if <command> was rerun.
> Later calls to `hipp` will recompute <command> as if it was not yet 
> memoized.
>
> ## (un)follow
>
>   $ ocamp follow <command>
>
> First, <command> is memoized if it was not the case yet.
> Then changes to dependencies of <command> will trigger a reevaluation.
> Use `stir` to notify a change.
>
> (to follow is an hipp/stir reactivity).
>
> ## pull
>
>   $ ocamp pull <command>
>
> Closely related to `hipp`, but instead of marking dependency on the 
> output of <command>, the dependency applies to the "effects" of 
> <command>.
>
> Thus, if `stir` is used:
> - all pullers will be reevaluated.
> - hippers will be reevaluated only if the output is different.
>
> ## Summary
>
>   $ ocamp fire <command> - setup a new session alive until <command> 
> exits
>           pull <command> - mark dependency on effects of <command>
>           hipp <command> - mark dependency on output of <command>
>           stir <command> - notify that <command> might have been updated
>           follow <command> - eval <command>, and reactively recompute it
>                              whenever one of its dependencies change.
>           unfollow <command> - stop recomputing <command> when 
> dependencies
>                                change
>
> hipp and pull provide memoization.
> stir and follow bring a flavor of reactive programming.
>
> # Examples
>
> ## Fibonacci
>
>   $ cat fib.sh
>   #!/bin/sh
>   ARG="$1"
>   if [ "$ARG" -le 1 ]; then
>     echo "$ARG"
>   else
>     A=`ocamp hipp ./fib.sh $((ARG-1))`
>     B=`ocamp hipp ./fib.sh $((ARG-2))`
>     echo $((A+B))
>   fi
>
>   $ time ocamp fire ./fib.sh 50
>   12586269025
>     real    0m0.391s
>   user    0m0.153s
>   sys     0m0.060s
>
> ## Build-system
>
> `ocamp` provides simple primitives to construct and manage a 
> dependency graph.
>
> This might be a saner foundation to base a build-system on than make(1):
> - the command focus on one specific problem
> - no dsl is involved; rules can be plain unix commands, including a 
> shell, rather than a make-flavored simulation of shell
> - nothing is provided for resolving goals; indeed this is better left 
> to tools specifically built for goal-search.
>
> A quick'n'dirty script building ocamp itself is provided as an example.
>
> # Future
>
> The current release is a proof-of-concept and should be considered 
> alpha quality.
> The two features planned next are a way to make the graph persistent 
> (all data is kept in memory atm) and an interface to debug and/or 
> observe graph construction.
>
> Note: code is undergoing legal review and should be available soon \o/
>