anchor.diff:          case sin_dep_solver:all_deps(SolverState0,
                                        CompiletimeApps1,
                                        CompileSpecs) of
  -            Error1 = {failed, {possible_culprit, SpecList1}} ->
  -            ec_talk:say("Unable to resolve compile time dependencies, probably do "
  -                         "to the following constraints:"),
  -            lists:foreach(fun({AppName, LimitSet, Sources}) ->
  -                                  ec_talk:say(" constraint on ~p with constraints ~p "
  -                                               "originating from these application(s) ~p",
  -                                               [AppName, sets:to_list(LimitSet),
  -                                                sets:to_list(Sources)]);
  -                             (AppName) when is_atom(AppName) ->
  -                                  ec_talk:say(" application ~p in the project ",
  -                                               [AppName])
  -
  -                          end, SpecList1),
  -            ?SIN_RAISE(State0, Error1);
  -        {_, Deps1} ->
  -            lists:filter(fun({excluded, _}) ->
  -                                 false;
  -                            (_) ->
  -                                 true
  -                         end, Deps1)
  +            Error1 = {failed, {possible_culprit, _SpecList1}} ->
  +                ?SIN_RAISE(State0, Error1);
  +            {_, Deps1} ->
  +                lists:filter(fun({excluded, _}) ->
  +                                     false;
  +                                (_) ->
  +                                     true
  +                             end, Deps1)
           end,
       {SolverState0, CompiletimeDeps0}.
   
  
positive.code: get_runtime_deps(State0, SolverState0, Apps, Specs) ->
      case sin_dep_solver:all_deps(SolverState0, Apps,
                                   Specs) of
          Error1 = {failed, {possible_culprit, SpecList1}} ->
              ec_talk:say("Unable to resolve runtime dependencies, probably do "
                           "to the following constraints:"),
              lists:foreach(fun({AppName, LimitSet, Sources}) ->
                                    ec_talk:say(" constraint on ~p with constraints ~p "
                                                 "originating from these application(s) ~p",
                                                 [AppName, sets:to_list(LimitSet),
                                                  sets:to_list(Sources)]);
                               (AppName) when is_atom(AppName) ->
                                    ec_talk:say(" application ~p in the project ",
                                                 [AppName])
                            end, SpecList1),
              ?SIN_RAISE(State0, Error1);
          {SolverState1, Deps0} ->
              {SolverState1,
  
negative.code:                          end, Apps0),
      DefaultSpecs =
          lists:map(fun(AppName) ->
                            case sin_state:get_value({apps, AppName, vsn},
                                                     State0) of
                                undefined ->
                                    AppName;
                                Vsn ->
                                    {AppName, Vsn}
                            end
                    end, Apps1),
      {Apps1, DefaultSpecs ++ Constraints}.
  