anchor.diff:  
               %% Gossip removals.
               Message = {remove_subscription, Node},
  -            OutgoingMessages = lists:map(fun(Peer) -> {Peer, {protocol, Message}} end, PartialViewList0),
  +            OutgoingMessages = lists:map(fun(Peer) -> {Peer, {protocol, Message}} end, PartialView0),
   
               %% Update state.
  -            State = State0#scamp_v2{partial_view=PartialView},
  -            PartialViewList = partial_view_list(State),
  -
  -            {ok, PartialViewList, OutgoingMessages, State};
  +            {ok, PartialView, OutgoingMessages, State0#scamp_v2{partial_view=PartialView}};
           false ->
               OutgoingMessages = [],
  -            {ok, PartialViewList0, OutgoingMessages, State0}
  +            {ok, PartialView0, OutgoingMessages, State0}
       end;
   handle_message(#scamp_v2{partial_view=PartialView0}=State0, {forward_subscription, Node}) ->
  -    lager:info("~p: Received subscription for node ~p.", [node(), Node]),
  -    PartialViewList0 = partial_view_list(State0),
  +    case partisan_config:get(tracing, ?TRACING) of 
  +        true ->
  +            lager:info("~p: Received subscription for node ~p.", [node(), Node]);
  +        false ->
  +            ok
  +    end,
   
       %% Probability: P = 1 / (1 + sizeOf(View))
       Random = random_0_or_1(),
       Keep = trunc((length(PartialView0) + 1) * Random),
   
  -    case Keep =:= 0 andalso not lists:member(Node, PartialViewList0) of 
  -        true ->
  -            lager:info("~p: Adding subscription for node: ~p", [node(), Node]),
  +    case Keep =:= 0 andalso not lists:member(Node, PartialView0) of 
  +        true ->
  +            case partisan_config:get(tracing, ?TRACING) of 
  +                true ->
  +                    lager:info("~p: Adding subscription for node: ~p", [node(), Node]);
  +                false ->
  +                    ok
  +            end,
               PartialView = [Node|PartialView0],
  -            State = State0#scamp_v2{partial_view=PartialView},
  -            PartialViewList = partial_view_list(State),
   
               %% Respond to the node that's joining and tell them to keep us.
  -            lager:info("~p: Notifying ~p to keep us: ~p", [node(), Node, node()]),
  +            case partisan_config:get(tracing, ?TRACING) of 
  +                true ->
  +                    lager:info("~p: Notifying ~p to keep us: ~p", [node(), Node, node()]);
  +                false ->
  +                    ok
  +            end,
               OutgoingMessages = [{Node, {protocol, {keep_subscription, myself()}}}],
   
  -            {ok, PartialViewList, OutgoingMessages, State};
  +            {ok, PartialView, OutgoingMessages, State0#scamp_v2{partial_view=PartialView}};
           false ->
               OutgoingMessages = lists:map(fun(N) ->
  -                lager:info("~p: Forwarding subscription for ~p to node: ~p", [node(), Node, N]),
  +                case partisan_config:get(tracing, ?TRACING) of 
  +                    true ->
  +                        lager:info("~p: Forwarding subscription for ~p to node: ~p", [node(), Node, N]);
  +                    false ->
  +                        ok
  +                end,
                   {N, {protocol, {forward_subscription, Node}}}
  -                end, select_random_sublist(State0, 1)),
  -            {ok, PartialViewList0, OutgoingMessages, State0}
  +            end, select_random_sublist(State0, 1)),
  +            {ok, PartialView0, OutgoingMessages, State0}
       end;
  -handle_message(#scamp_v2{in_view=InView0}=State, {keep_subscription, Node}) ->
  -    lager:info("~p: Received keep_subscription for node ~p.", [node(), Node]),
  -    PartialViewList = partial_view_list(State),
  +handle_message(#scamp_v2{partial_view=PartialView0, in_view=InView0}=State, {keep_subscription, Node}) ->
  +    case partisan_config:get(tracing, ?TRACING) of 
  +        true ->
  +            lager:info("~p: Received keep_subscription for node ~p.", [node(), Node]);
  +        false ->
  +            ok
  +    end,
  +
       InView = [Node|InView0],
       OutgoingMessages = [],
  -    {ok, PartialViewList, OutgoingMessages, State#scamp_v2{in_view=InView}}.
  +    {ok, PartialView0, OutgoingMessages, State#scamp_v2{in_view=InView}}.
   
   %%%===================================================================
   %%% Internal functions
   %%%===================================================================
   
   %% @private
  -partial_view_list(#scamp_v2{partial_view=PartialView}) ->
  -    PartialView.
  -
  -%% @private
  -select_random_sublist(State, K) ->
  -    List = partial_view_list(State),
  -    lists:sublist(shuffle(List), K).
  +select_random_sublist(#scamp_v2{partial_view=PartialView}, K) ->
  +    lists:sublist(shuffle(PartialView), K).
   
   %% @reference http://stackoverflow.com/questions/8817171/shuffling-elements-in-a-list-randomly-re-arrange-list-elements/8820501#8820501
   shuffle(L) ->
  
positive.code:     OutgoingSubscriptionMessages = case Difference > (?PERIODIC_INTERVAL * ?SCAMP_MESSAGE_WINDOW) of 
          true ->
              %% Node is isolated.
              lager:info("~p: Node is possibily isolated.", [node()]),
  
              Myself = myself(),
  
              lists:map(fun(N) ->
                  lager:info("~p: Forwarding additional subscription for ~p to node: ~p", [node(), Myself, N]),
                  {N, {protocol, {forward_subscription, Myself}}}
              end, select_random_sublist(State, 1));
          false ->
  
negative.code:             []
      end,
  
      {ok, PartialView, OutgoingSubscriptionMessages ++ OutgoingPingMessages, State}.
  
  %% @doc Handling incoming protocol message.
  handle_message(#scamp_v2{partial_view=PartialView0}=State, {ping, SourceNode}) ->
      case partisan_config:get(tracing, ?TRACING) of 
          true ->
              lager:info("~p: Received ping from node ~p.", [node(), SourceNode]);
          false ->
              ok
      end,
  
      LastMessageTime = erlang:timestamp(),
      OutgoingMessages = [],
      {ok, PartialView0, OutgoingMessages, State#scamp_v2{last_message_time=LastMessageTime}};
  handle_message(#scamp_v2{partial_view=PartialView0, in_view=InView0}=State0, {bootstrap_remove_subscription, Node}) ->
      case partisan_config:get(tracing, ?TRACING) of 
          true ->
              lager:info("~p: Received bootstrap_remove_subscription from node ~p.", [node(), Node]);
          false ->
              ok
      end,
  
      Myself = myself(),
      C = partisan_config:get(scamp_c, ?SCAMP_C_VALUE),
  
      case Node of
          %% Remove ourselves, but attempt to preserve the scaling relation.
          Myself ->
              %% 1. Notify InView[0 - (L - C - 1)] to replace with PartialView[0 - (L - C - 1)]
              NumToIterate = length(InView0) - (C - 1),
  
              ReplacementMessages = case NumToIterate > 0 of
                  true ->
                      lists:map(fun(N) ->
                          Nth = lists:nth(N, InView0),
                          Replacement = lists:nth(N div length(PartialView0), PartialView0),
                          {Nth, {protocol, {replace_subscription, Node, Replacement}}}
                      end, lists:seq(1, NumToIterate));
                  false ->
                      []
              end,
  
              %% 2. Notify InView[(L - C - 1) - ] to remove.
              RemainderToIterate = length(InView0) - NumToIterate,
              
              RemovalMessages = case RemainderToIterate > 0 of
                  true ->
                      lists:map(fun(N) ->
                          Nth = lists:nth(N, InView0),
                          {Nth, {protocol, {remove_subscription, Node}}}
                      end, lists:seq(1, RemainderToIterate));
                  false ->
                      []
              end,
  
              %% Reset our state.
              {ok, [], ReplacementMessages ++ RemovalMessages, State0#scamp_v2{in_view=[], partial_view=[]}};
          _ ->
              %% Not us, do nothing.
              {ok, PartialView0, [], State0}
      end;
  handle_message(#scamp_v2{partial_view=PartialView0}=State0, {replace_subscription, Node, Replacement}) ->
      case partisan_config:get(tracing, ?TRACING) of 
          true ->
              lager:info("~p: Received replace_subscription for node ~p => ~p.", [node(), Node, Replacement]);
          false ->
              ok
      end,
  
      %% Replacement reorganizes the graphs so that the removed nodes parents connect to 
      %% its children; but, this doesn't update in links, right?  Is that missing in the 
      %% protocol description?
  
      PartialView = lists:map(fun(N) ->
              case N of
                  Node ->
                      Replacement;
                  _ ->
                      N
              end
          end, PartialView0),
  
      {ok, PartialView, [], State0#scamp_v2{partial_view=PartialView}};
  handle_message(#scamp_v2{partial_view=PartialView0}=State0, {remove_subscription, Node}) ->
      case partisan_config:get(tracing, ?TRACING) of 
          true ->
              lager:info("~p: Received remove_subscription for node ~p.", [node(), Node]);
          false ->
              ok
      end,
  
      case lists:member(Node, PartialView0) of 
          true ->
  