Re: Ada platforms and pricing, was: Re: a new language, designed for safety !

["Dan'l Miller" <optikos@verizon.net>]

On Monday, June 23, 2014 12:14:24 PM UTC-5, Dmitry A. Kazakov wrote:
> On Mon, 23 Jun 2014 12:17:38 +0100, Simon Wright wrote:
> > "Dmitry A. Kazakov" writes:
> >> Programming a state machine is turning all design upside down. If
> >> there were user-defined task support one could program this as if it
> >> were in proper tasks.
> 
> > I find it easier to think about state machines as state machines rather
> > than by encoding them using the program counter! I geuss it depends on
> > your starting point.

In the spirit of lambasting the lack of direct representation of finite-state machines (FSMs) in Ada:

  A programmer should not need to go through mental gymnastics to represent a crystal-clear analysis construct (e.g., an FSM) in some sort of contortion just because someone in 1978 omitted it from an excessively-sequential imperative programming language because excessively-sequential imperative programming languages encouraging vast call-trees of subroutines per thread of execution were in vogue during the 1970s and adjacent decades.

Perhaps Ada202X can do something more than mere dotting of "i"s and crossing of "t"s so as to provide a direct intuitive representation of FSMs within Ada (assuming that Ada does not already have such an intuitive design idiom for FSMs, as potentially explored below).  Direct intuitive representation of FSMs would be highly useful in Ada's historically-most-frequent deployments:  embedded realtime systems interacting with hardware.  The Ada202X compiler could mathematically-prove some aspects of sanity of the FSM, giving compile-time errors for certain categories of glaring design errors in the FSM a la the numerous other compile-time assurances for safety-critical systems that are already part of Ada.  (Plus it would give Ada a special sauce that very few other compiled languages have in either its core language or in its standard library, Erlang & C++'s Boost notwithstanding.  Btw, Ada does need a few more claims to fame to be competitive with the other current programming-language darlings that get asked to dance on the dance-floor more often than Ms. Ada does.  Direct intuitive representation of FSMs with compile-time error-checking [as a directed graph in graph-theory] could be one of those claims to fame.)

> As an example consider reading from a stream without blocking. When there
> is no more data available you switch to another co-routine (reading another
> stream). This is programmed as if reading from the stream was blocking. The
> co-routine is continued when more data become available. On top of these
> stream could be a mountain of protocols or a whole Ada compiler taking the
> stream as a source. Doing this as a state machine, upside-down driven by
> incoming characters would be extremely tedious.
> 
> The idea of user-defined tasking is that the user would also provide the
> pool to allocate the task stack and would activate/deactivate his tasks.

In the spirit of humbly learning something new and appreciating any potential beauty:

  Dmitry, do you advocate the use of "co-routines" (as Ada tasks, if I understand you correctly) for the modeling of arbitrarily-complex finite-state machines (FSMs)?  If so (and if it scales), perhaps you can explain the design idiom more completely so that it handles FSMs of arbitrary complexity.  Or perhaps you can provide a URL to an academic paper that describes representing FSMs of arbitrary complexity via "co-routines".

It seems that your usage here of "co-routines" to represent FSMs somewhat resembles C.A.R. Hoare's monitors, but perhaps I am taking your "co-routines" in a different direction than you intend.  If resembling Hoare's monitors (or POSIX's condition variables) [and assuming that each Ada task in the set of co-routines takes on the role of each state in an FSM], how does this idiom scale well in so far as not having immensely-complex conditional-branching tests for representing each task's/state's traversal of a link/edge in arbitrarily-complex FSMs.