anchor.diff:    StdErr     = filename:join([LogDir, "beehive.err"]),
   
     lists:flatten([
  -    build_env({name, App#app.name}),
  -    build_env({repos, App#app.url}),
  -    build_env({revision, App#app.revision}),
  -    build_env({path, BeehivePath}),
  -    build_env({branch, App#app.branch}),
  -    {stdout, StdOut},
  -    {stderr, StdErr},
  -    OtherEnvs
  -  ]).
  +                 build_env({name, App#app.name}),
  +                 build_env({repos, App#app.url}),
  +                 build_env({revision, App#app.revision}),
  +                 build_env({path, BeehivePath}),
  +                 build_env({branch, App#app.branch}),
  +                 {stdout, StdOut},
  +                 {stderr, StdErr},
  +                 OtherEnvs
  +                ]).
   
   build_env({Key, Value}) ->
     RealValue = case Value of
  -    undefined -> "undefined";
  -    _ -> Value
  -  end,
  +                undefined -> "undefined";
  +                _ -> Value
  +              end,
     T = lists:flatten([
  -    string:to_upper(erlang:atom_to_list(Key)),
  -    "=",RealValue,""
  -  ]),
  +                     string:to_upper(erlang:atom_to_list(Key)),
  +                     "=",RealValue,""
  +                    ]),
     {env, T}.
   
  -% If erlang had 'meta-programming,' we wouldn't have to do all this work to validate the proplists
  +%% If erlang had 'meta-programming,' we wouldn't have to do all this work to validate the proplists
   from_proplists(Proplists) -> from_proplists(Proplists, #app{}).
   from_proplists([], App)  -> App;
   from_proplists([{name, V}|Rest], App) -> from_proplists(Rest, App#app{name = V});
  
positive.code:     [N] -> App#app{name = generate_unique_name(N, 5)};
      [A,B] -> App#app{name = generate_unique_name(A, 5), branch = B}
    end.
    
  %%-------------------------------------------------------------------
  %% @spec (Name) ->    {ok, Value}
  %% @doc Generate a unique name based on a given name
  
negative.code:     _ ->  []
    end.
  
  %% APPLICATION STUFF
  update_by_name(Name) ->
    case find_by_name(Name) of
      not_found -> {error, "Cannot find app to update"};
      App ->
        %% Should this be synchronous or asynchronous?
        NewApp = App#app{updated_at = date_util:now_to_seconds(), latest_error = undefined, revision = undefined},
        ?NOTIFY({app, updated, NewApp}),
        {ok, save(NewApp)}
  