diff --git a/lib/erl/src/Makefile b/lib/erl/src/Makefile
index b42e005..1a07b0a 100644
--- a/lib/erl/src/Makefile
+++ b/lib/erl/src/Makefile
@@ -67,7 +67,6 @@
 # beam files.
 clean:
 	rm -f $(TARGET_FILES)
-	rm -f *~
 	rm -f core
 	rm -rf $(EBIN)
 	rm -rf *html
diff --git a/lib/erl/src/oop.erl b/lib/erl/src/oop.erl
index 08c0e37..e3685ee 100644
--- a/lib/erl/src/oop.erl
+++ b/lib/erl/src/oop.erl
@@ -63,6 +63,7 @@
 		    ?NOATTR_SET
 	    end
     end.
+    
 
 %%% C++                   <-> Erlang
 %%% classes                   modules
diff --git a/lib/erl/src/thrift.app.src b/lib/erl/src/thrift.app.src
index 590e6a9..dc2926a 100755
--- a/lib/erl/src/thrift.app.src
+++ b/lib/erl/src/thrift.app.src
@@ -35,7 +35,7 @@
   {env, []},
 
   % The Module and Args used to start this application.
-  {mod, {thrift_app, []}}
+  {mod, {%APP_NAME%, []}}
  ]
 }.
 
diff --git a/lib/erl/src/thrift.erl b/lib/erl/src/thrift.erl
index 5dc8987..feabb1d 100644
--- a/lib/erl/src/thrift.erl
+++ b/lib/erl/src/thrift.erl
@@ -1,12 +1,13 @@
 %%% Copyright (c) 2007- Facebook
 %%% Distributed under the Thrift Software License
-%%%
+%%% 
 %%% See accompanying file LICENSE or visit the Thrift site at:
 %%% http://developers.facebook.com/thrift/
 
 -module(thrift).
 
--export([start/0, stop/0, config/1, config/2]).
+-export([start/2, shutdown/0, stop/1]).
+-behaviour(application).
 
 -include("thrift.hrl").
 
@@ -14,56 +15,11 @@
 %%% behavior definition
 %%%
 
-start() ->
-    application:start(thrift).
+start(Type, StartArgs) ->
+    ok.
 
-stop() ->
-    application:stop(thrift).
+shutdown() ->
+    application:stop(?MODULE).
 
-%%%
-%%% configuration
-%%%
-
-%% go to the global file by default
-config(Path) ->
-    config(Path, {file, ?CONFIG_FILE}).
-
-config(Path, Source) ->
-    case config1(Path, Source) of
-	{error, file_error, R} ->
-	    ?ERROR("error opening config ~p: ~p", [Source, R]),
-	    false;
-	{error, bad_item, Tuple} ->
-	    ?ERROR("malformed config item ~p found at ~p in ~p", [Tuple, Path, Source]),
-	    false;
-	{error, not_found} ->
-	    ?ERROR("config item ~p not found in ~p", [Path, Source]),
-	    false;
-	{value, V} ->
-	    {value, V}
-    end.
-
-%% go to a file
-config1(Path, {file, File}) ->
-    case file:consult(File) of
-	{error, R={_,_,_}} ->
-	    {error, file_error, file:format_error(R)};
-	{error, Posix} ->
-	    {error, file_error, Posix};
-	{ok, List} when is_list(List) ->
-	    config1(Path, List)
-    end;
-
-%% go through a list from a file or a sublist
-config1([P|Ps], List) when is_list(List) ->
-    case lists:keysearch(P, 1, List) of
-	{value, Tuple} when size(Tuple) == 2 ->
-	    List1 = element(2, Tuple), %% either another list or, if Ps is [], the item itself
-	    config1(Ps, List1);
-	{value, Tuple} ->
-	    {error, bad_item, Tuple};
-	false ->
-	    {error, not_found}
-    end;
-config1([], Item)     -> {value, Item};
-config1(Item, Source) -> config1([Item], Source).
+stop(_State) ->
+    ok.
diff --git a/lib/erl/src/thrift_logger.erl b/lib/erl/src/thrift_logger.erl
index 6deb222..12aa059 100644
--- a/lib/erl/src/thrift_logger.erl
+++ b/lib/erl/src/thrift_logger.erl
@@ -8,9 +8,7 @@
 
 -behaviour(gen_event).
 
--record(state, {config}).
-
--define(CONFIG(Item), config(Item, State)).
+-include("thrift_logger.hrl").
 
 %% TODO(cpiro): either
 %% make exceptions know whether they need to be displayed
@@ -25,14 +23,13 @@
 -export([init/1, handle_event/2, handle_call/2, 
          handle_info/2, terminate/2, code_change/3]).
 
--export([install/0, install/1, reconfig/0, reconfig/1]).
+-export([install/0, install/1]).
 
 %% ensure the regular logger is out and ours is in
 install() ->
     install([]).
-install(Config) ->
+install(Args) ->
     %% remove loggers
-    io:format("starting logger~n"),
     lists:foreach(fun(Logger) ->
       case Logger of
         _ -> gen_event:delete_handler(error_logger, Logger, normal)
@@ -41,19 +38,15 @@
 
     %% TODO(cpiro): sasl someday?
     %% gen_event:add_handler(error_logger, sasl_report_file_h, {LogFile, all}),
+    gen_event:add_handler(error_logger, ?MODULE, Args).
 
-    gen_event:add_handler(error_logger, ?MODULE, []),
+%% how to output
+format(Format, Data) ->
+    io:format(Format, Data).
 
-    reconfig(Config),
-
-    ok.
-
-%% load our config file and amend the given stuff
-reconfig() ->
-    reconfig([]).
-
-reconfig(Config) ->
-    gen_event:call(error_logger, ?MODULE, {reconfig, Config}).
+%% convenience
+sformat(Format, Data) ->
+    thrift_utils:sformat(Format, Data).
 
 %%====================================================================
 %% gen_event callbacks
@@ -67,15 +60,15 @@
 %% @end 
 %%--------------------------------------------------------------------
 init([]) ->
-    BootConfig = [
-      {term_width, 80},
-      {force_one_line, false},
-      {omit, []},
-      {gen_server_messages, true},
-      {lookup, false}
-    ], %% configuration before we try loading from file
+    {ok, #thrift_logger_state{
+       term_width = 110,
+       force_one_line = true,
+       omit = [oop_new], % req_processed
+       gen_server_messages = false,
+       lookup = true
+      }};
 
-    State = #state{config=BootConfig},
+init([State]) ->
     {ok, State}.
 
 %%--------------------------------------------------------------------
@@ -108,7 +101,7 @@
 	end,
 
     Length =
-	case (length(OutputSafe) + BannerLen) < ?CONFIG(term_width) of
+	case (length(OutputSafe) + BannerLen) < State#thrift_logger_state.term_width of
 	    true  -> short;
 	    false -> long
 	end,
@@ -119,7 +112,7 @@
 	    false -> multiline
 	end,
 
-    case { ?CONFIG(force_one_line), Length, OneLine } of
+    case { State#thrift_logger_state.force_one_line, Length, OneLine } of
 	%% one line and short ... print as is
 	{_, short, oneliner} ->
 	    format("~s~s~n", [Banner, OutputSafe]);
@@ -127,7 +120,7 @@
 	%% too long ... squash to one
 	{true, long, _} ->
 	    O = Banner ++ OutputSafe,
-	    Format = sformat("~~~ps >~n", [?CONFIG(term_width)-2]), % e.g. "~80s >~n"
+	    Format = sformat("~~~ps >~n", [State#thrift_logger_state.term_width-2]), % e.g. "~80s >~n"
 	    format(Format, [O]);
 
 	%% short but multiline... collapse to one
@@ -151,7 +144,7 @@
     case Format of
 	"** Generic server ~p terminating \n** Last message in was ~p~n** When Server state == ~p~n** Reason for termination == ~n** ~p~n" ->
 	    %% v- Pid is a pattern match, not a bind
-	    [Ref, LastMessage, Obj, Reason] = Data,
+	    [Pid, LastMessage, Obj, Reason] = Data,
 
 	    %% TODO: move as much logic as possible out of thrift_logger
 	    Ignore =
@@ -175,11 +168,11 @@
 		false ->
 		    Format1 = "** gen_server terminating in message ~p~n** State  = ~s~n** Reason = ~s~n",
 		    Message = sformat(Format1, [LastMessage, oop:inspect(Obj), oop:inspect(Reason)]), %% TODO(cpiro): hope Reason is an object?
-		    handle_event2(Symbol, Ref, "", Message, State)
+		    handle_event2(Symbol, Pid, "", Message, State)
 	    end;
 	_ ->
 	    Message = sformat(Format, Data),
-	    handle_event2(Symbol, Ref, "", Message, State)
+	    handle_event2(Symbol, Pid, "", Message, State)
     end,
     {ok, State};
 
@@ -194,7 +187,7 @@
     case Type of
 	{thrift_info, TI} ->
 	    %% should we show it?
-	    case not lists:member(TI, ?CONFIG(omit)) of
+	    case not lists:member(TI, State#thrift_logger_state.omit) of
 		true ->
 		    Message = handle_thrift_info(TI, Report, State),
 		    handle_event2(Symbol, Pid, "", Message, State);
@@ -256,7 +249,7 @@
 
 %%--------------------------------------------------------------------
 %% @spec handle_call(Request, State) -> {ok, Reply, State} |
-%%                                {swap_handler, Reply, Args1, State1,
+%%                                {swap_handler, Reply, Args1, State1, 
 %%                                  Mod2, Args2} |
 %%                                {remove_handler, Reply}.
 %% 
@@ -266,11 +259,6 @@
 %% handler to handle the request.
 %% @end 
 %%--------------------------------------------------------------------
-handle_call({reconfig, Amendments}, State) ->
-    {OkOrError, State1} = reconfig1(State, Amendments),
-    format(".. reconfig was ~p~n", [OkOrError]),
-    {ok, OkOrError, State1};
-    
 handle_call(_Request, State) ->
     Reply = ok,
     {ok, Reply, State}.
@@ -317,32 +305,3 @@
 %%====================================================================
 %%% Internal functions
 %%====================================================================
-
-%% how to output
-format(Format, Data) ->
-    io:format(Format, Data).
-
-%% convenience
-sformat(Format, Data) ->
-    thrift_utils:sformat(Format, Data).
-
-reconfig1(State, Amendments) ->
-    case thrift:config(thrift_logger) of
-	{value, Config} ->
-	    Config1     = lists:keysort(1, Config),
-	    Amendments1 = lists:keysort(1, Amendments),
-	    Config2     = lists:keymerge(1, Amendments1, Config1),
-
-	    State1 = State#state{config=Config2},
-	    {ok, State1};
-	_ -> 
-	    {error, State}
-    end.
-
-config(Item, State) ->
-    case thrift:config(Item, State#state.config) of
-	{value, V} ->
-	    V;
-	Else ->
-	    ?ERROR("config for ~p is unavailable: ~p", [Item, Else])
-    end.
diff --git a/lib/erl/src/transport/tSocket.erl b/lib/erl/src/transport/tSocket.erl
index c2bf920..491d86b 100644
--- a/lib/erl/src/transport/tSocket.erl
+++ b/lib/erl/src/transport/tSocket.erl
@@ -17,8 +17,8 @@
 
 -export([attr/4, super/0, inspect/1]).
 
--export([new/0, new/1, new/2,
-	 effectful_setHandle/2, effectful_open/1,
+-export([new/0, new/1, new/2, 
+	 effectful_setHandle/2, effectful_open/1, 
 	 isOpen/1, write/2, read/2, effectful_close/1]).
 
 %%%
@@ -91,9 +91,6 @@
     Handle = oop:get(This, handle),
     Val = gen_tcp:send(Handle, Str),
 
-    %% DEBUG
-    %% error_logger:info_msg("tSocket: wrote ~p~n", [Str]),
-
     %% error_logger:info_msg("WRITE |~p| (~p)", [Str,Val]),
     
     case Val of
@@ -111,8 +108,6 @@
 	    Port = oop:get(This, port),
 	    throw(tTransportException:new(?tTransportException_UNKNOWN, "TSocket: Could not read " ++ Sz ++ "bytes from " ++ Host ++ ":" ++ Port));
 	{ok, Data} ->
-	    %% DEBUG
-	    %% io:format("tSocket: read ~p~n", [Data]),
 	    Data;
 	{error, Error} ->
 	    exit(tTransportException:new(?tTransportException_NOT_OPEN, "in tSocket:read/2: gen_tcp:recv"))
