I'm currenly in an industry with extremely high demands on
software determinism, both in space and time (hard realtime).
My conclusion so far is that most safety-critical industries
today are in desperate need of better (any) language support for
guaranteeing determinism, especially time. The amount of
time/money spent/wasted on complicated extra tooling processes
and tests to assure time-determinism is just insane, at least in
the avionics industry.
If D was to attack this problem in the same systematic way it can
restrict execution behaviour with `@safe pure nothrow @nogc` D
would have yet another killing feature in its feature pack.
I'm aware of the lack of absolute time-determinism in the CPU
architectures of today. But the industry still uses such
architectures, sometimes with memory-caches disabled and
forbidding of multi-core/cpu in its products.
Have anybody though about adding support for this in D? I assume
it would have to integrate with the backend in various
complicated ways. Both the frontend and the backend would need to
have options for generation of code that promotes deterministic
execution over smallest average time-execution (which is
currently the default optimization route taken by most compilers
and library algorithms).
Are there any languages or compilers that tries to attack this
problem?
Note that this problem is highly related to concept of
"cyclomatic complexity".
See also:
https://en.wikipedia.org/wiki/Cyclomatic_complexity
