anchor.diff:                    , comment   ::list()
                     }
          ).
  --define(ddTest, [timestamp,integer,integer,float,string]).
  +-define(ddTest, [timestamp,integer,integer,float,string]).  % test table DDerl types
   
  --define(ddTestName,ddTest@).  %% node sharded 
  +-define(ddTestName,ddTest@).  %% node sharded test table (local content per node) 
   
  --record(state,  % factorial state (stateless apart from delay)
  -                {wait = 1000}).
  +-record(state,  % process state (stateless apart from delay)
  +                {wait = 500 :: integer()}
  +       ).
   
  -% gen_server API calls
  +% gen_server API call exports
   
   -export([ start_link/1
           , start/1
           , stop/0
  -        , start_supervised/1
  -        , stop_supervised/0
           , wait/1
  +        , fac/1
           , write_test_record/4
  -        , fac/1
           ]).
   
  -% gen_server behavior callbacks
  +% sample usage for demo:
  +% imem_test_writer:start(333).
  +% imem_test_writer:wait(100).
  +% imem_test_writer:wait(5).
  +% imem_test_writer:stop().
  +% l(imem_test_writer).
  +
  +% gen_server behavior callback exports
   
   -export([ init/1
           , handle_call/3
  
positive.code: fac(0) -> 1;
  fac(N) -> N * fac(N-1). 
  
  % gen_server behavior callbacks
  
  init(Wait) ->
      ?Debug("~p starting...~n", [?MODULE]),
      imem_meta:create_check_table(?ddTestName, {record_info(fields, ddTest),?ddTest, #ddTest{}}, [{type,ordered_set},{record_name,ddTest}], system),
      imem_test_writer:write_test_record(0,0,0.0,"fac start"),
      random:seed(os:timestamp()),
      erlang:send_after(Wait, self(), write_record),    
      ?Debug("~p started!~n", [?MODULE]),
      {ok,#state{wait=Wait}}.
  
  handle_info(write_record, #state{wait=Wait}) ->
      Ran = random:uniform(),       %% 0..1
      %% X = round(30*Ran),         %% bad version causing 1/0
      X = round(29*Ran) +1 ,
      FX = fac(X),
      OneOverX = 1.0/X, 
      imem_test_writer:write_test_record(X,FX,OneOverX,"fac next"),
      erlang:send_after(Wait, self(), write_record),
      {noreply, #state{wait=Wait}}.
  
  handle_call({wait, Wait}, _From, #state{}=State) ->
      {reply, ok, State#state{wait=Wait}};
  
negative.code: -module(imem_test_writer).
  
  % -ifdef(TEST).                   % empty module in production
  
  -include("imem.hrl").           % import logging macros
  -include("imem_meta.hrl").      % import exceptions and data types
  
  -behavior(gen_server).          % implicitly defines the required callbacks
  
  -record(ddTest,   % test table record definition with erlang types
                    { time      ::ddTimestamp()
                    , x         ::integer()
                    , fX        ::integer()
  