Re: [boost] [review] Dataflow Library

Subject: Re: [boost] [review] Dataflow Library
From: Bruno Lalande (bruno.lalande_at_[hidden])
Date: 2008-09-08 05:09:43

>> Okay, but which applications need runtime configurability?  Would not
>> the performance advantages of a compile-time structure be more valuable
>> than the flexibility of runtime configuration in most applications?
>>
>
> Distributed applications could be a good use case. If you have your
> components on different machines, you can't take advantage of
> compile-time structure anyways.
>
> Even for normal applications it is often very useful to be able to
> reorganize your pipeline without a recompile, at least for coarse
> grained components, where the benefit of static checking and
> optimization might be less important. In particular, the ability to
> add or remove sink and sources, or disabling optional components, is
> very useful.

A few month ago I was developing a motions library (not finished yet)
that led me to the same kind of questions. The principle is quite the
same as Accumulators or Dataflow (btw I wonder if I could reimplement
everything using one of them). The goal is to easily define how some
values change in time, by starting with some very basic movements
(linear speed, random values, etc...) and make the values pass through
a pipeline that alter them to add some effects (inertia, stepping,
recording, dependencies between motions, etc...). I wanted to have
compile-time connections inside the pipeline because a runtime
overhead wasn't acceptable as it was for a game engine. But sometimes
some flexibility was required: disabling a dependency, removing an
effect, etc... Finally it turned out that the best option was to have
some special components implementing those points of flexibility. So I
added some components called "dropping", "variant", "switch" that are
still connected at compile-time but implement a precise point of
flexibility at runtime. That way, the runtime overhead is limited only
to the very few flexibility that's really needed in a precise context.
The concept is finally the following: sometimes you need runtime
flexibility, but you always know at compile-time if you'll need it,
how you'll need it and where you'll need it.

Bruno