Data Flow Patterns

Based Data

This is not a flow pattern, but instead describes a type of transformation that occurs on data.

Let org, mod be Data;
mod is based on org iff
the algorithm that produces mod uses org where
the algorithm cannot be simplified to remove org;

Based Flow

Let org be Data; 
Let A be a Point; 
x_A( dt ) is based on org iff 
the series of algorithms, that produce the resultant flow x_A( data ), use org where 
the series of algorithms cannot be simplified to remove org;

Write Access Flow

Let A be a Point; 
A has write access flow if 
x_A( {mode:set} | dt ) modifies A.Data based on dt;

Read Access Flow

Let A be a Point; 
A has read access flow if 
x_A( {mode:get} | {out:ctl} | dt ) modifies dt based on A.Data

Write Data Flow

Let A be a Point; 
A has write data flow and directed data flow if 
x_A( {mode:set} | ( dt := orig ) ) results in 
write access flow on some point B in the half cluster of A with 
the dt being based on orig;

Read Data Flow

Let A be a Point; 
A has read data flow if 
x_A( {mode:get} | dt ) results in  
read access flow, based on {mode:get}, on some Point B in the half cluster of A where 
the resultant flow data is based on B.Data;

Read-Only Data Cluster

Let A be a Point; 
A is a read-only data cluster iff 
A has the combined flow of  
( managed flow and 
read data flow and 
not write data flow);

Write-Only Data Cluster

Let A be a Point; 
A is a write-only data cluster iff 
A has the combined flow of 
( managed flow and 
write data flow and 
not read data flow);

Read-Write Data Cluster

Let A be a Point; 
A is a read-write data cluster iff 
A has the combined flow of 
( managed flow and 
write data flow and 
read data flow);

Brokered Flow Patterns

Tight Unit Flow

Let A, B[i], for i=[0,n], be Points; 
Let k belong to [0,n]; 
Let incall = x_A( {in: {rel:A_B[k]} } | {out:ctl} | dt ); 
Let outcall = x_A( {out:ctl} | dt ); 
A has tight unit flow on B[i] if 
( incall results in A_B[k]( {out:ctl} | dt ) with results in outcall ) and  
( outcall is directed flow on out );

The above concept is a very vital one on which other patterns will be built. Since so many future patterns will be based on it it requires some shorthand notation.

Let A, B[i], for i=[0,n], be Points where 
A has tight unit flow on B[i]; 
Let C be a Point; 
Let A_B[k]( data ), in C.Algorithm for k=[0,n], be equivalent to 
C_A( {in:{rel:A_B[k]}} | dt );